No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Tuplas

21/31
Recursos

Aportes 180

Preguntas 22

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Las tuplas al igual que las listas en Python son secuencias pero las tuplas son secuencias inmutables (eso significa que no se pueden modificar) de objetos.

驴C贸mo identificar una tupla en Python?
Las tuplas en Pyhton poseen siguiente sintaxis:

tuple_name = ('first_value', 2, 'u_can_add_ints')

Mientras que las listas en Python tienen esta sintaxis:

list_name = [1,'2', 3]

Como pueden apreciar, para la asignaci贸n de las tuplas, el contenido debe ir 鈥渆mpaquetado鈥 mediante par茅ntesis 鈥()鈥, mientras que para las listas, se empaquetan en corchetes 鈥淸]鈥.

Para declarar una tupla en Python se realiza lo siguiente:

tuple_name = ()

El contenido de la tupla pueden ser de tipo int, float y string.

Nota: en caso de que tu tupla s贸lo contenga un valor, debes agregar una comar 鈥,鈥, por ejemplo:

En caso de contener un int:

tuple_name = (1,) 

En caso de contener un float:

tuple_name = (2.0,) 

En caso de contener un string:

tuple_name = ('string',) 

Tuplas

  1. Una tupla consiste en objetos inmutables. (Objetos que no pueden cambiar despu茅s de la creaci贸n)

  2. Una tupla tiene poca memoria.

  3. Una tupla se almacena en un solo bloque de memoria.

  4. Crear una tupla es m谩s r谩pido que crear una lista.

  5. Un elemento en una tupla no se puede quitar ni reemplazar.

Listas

  1. Una lista consta de objetos mutables. (Objetos que se pueden cambiar despu茅s de la creaci贸n)

  2. La lista tiene una gran memoria.

  3. La lista se almacena en dos bloques de memoria (uno es de tama帽o fijo y el otro es de tama帽o variable para almacenar datos)

  4. Crear una lista es m谩s lento porque se necesita acceder a dos bloques de memoria.

  5. Un elemento en una lista se puede eliminar o reemplazar.

fuente

Quiero a帽adir que las tuplas tambi茅n se pueden representar sin par茅ntesis

my_tuple = 1, 2, 3
print(my_tuple)

o

my_tuple = (1, 2, 3)
print(my_tuple)

Les comparto una imagen donde se explica un poco m谩s la diferencia entre tuplas, listas, conjunto y diccionario por si alguno tiene dudas al respecto 馃槃

Tuplas:

  • Secuencias inmutables de objetos, osea son listas de valores que no podemos modificar.

  • Pueden ser de tipo

    • Entero int (1,)
    • Flotante float (2.0,)
    • String (鈥楽tring鈥)
    • Booleano (true)
  • Las tuplas al igual que los strings podemos acceder por indice

my_tuple(1,2,3)
my_tuple[0] = 1
my_tuple[1] = 2
my_tuple[2] = 3

  • Podemos desempaquetar tuplas, para ello hay que definir ciertas variales para reasignarlas.
    x, y, z = my_tuple
    x = 1 y=2 z=3
<"""
Tuplas 

son secuencias inmutables de objetos

A diferencia de las cadenas pueden contener cualquier tipo de objetos

Pueden utilizarse para devolver varios valores en una funcion
"""

#creacion de una tupla vacia
my_tuple = ()
print(type(my_tuple))

my_tuple = (1, 'dos' , True)

#se puede acceder a las duplas por el index
print(my_tuple[0])
print(my_tuple[1])
print(my_tuple[2])

#no se pueden modificar las tuplas, provoca error
# my_tuple[0] = 2

#no se pueden modificar pero si pueden apuntar a otro lugar de memoria
my_tuple = (1)

#tipo de objeto int debido a que no se uso sintaxis adecuada
print(type(my_tuple))

#los items deberan estar separados por comas
my_tuple = (1,)
print(type(my_tuple))

#tuplas pueden sumarse
#la variable no se modifica, apunta a otro lugar de memoria
my_other_tuple = (2,3,4)
my_tuple += my_other_tuple
print(my_tuple)

#se pueden asignar los items de las tuplas a otras variables
x, y, z = my_other_tuple
print (x,y,z)

#se pueden asignar el retorno de las funciones a una tupla
def coordenadas():
    return(5,4)

coordenada = coordenadas()
print(coordenada)

#asignar los items de la tupla a variables x y
x , y = coordenada

print(x, y)>

La principal diferencia entre una tupla y una lista, es que los valores de la lista se pueden modificar a lo largo del c贸digo, en un tupla no. La ventaja que tiene usar tuplas es que ocupa menos espacio en memoria a diferencia de la lista, ya que en la lista ocupamos dos bloques de memoria para que pueda ser mutable.

En el siguiente enlace m谩s ejemplos sobre las tuplas : https://www.w3schools.com/python/python_tuples.asp

Las tupas son inmodificables pero si reasignables

Listas

  • Colecci贸n de datos ordenados
  • Pueden contener objetos de diferentes tipos
  • Mutables
  • Accesibles mediante un indice
list = ["mango", "fresa", "manzana]

Arreglo

  • Colecci贸n de datos ordenados
  • Sus objetos deben ser del mismo tipo
  • Mutable
  • Accesible mediante un indice
  • En python requiere importar la libreria para usarlas
import array as arr
a = arr.array ('i', [1, 2, 3])

Tupla

  • Colecci贸n de datos no ordenados
  • Puede contener objetos de diferentes tipos
  • No mutables
  • Accesible mediante un indice
tuple = ("mango", "fresa", "manzana")

https://www.geeksforgeeks.org/python-list-vs-array-vs-tuple/

Diganme si tengo al mal 馃槖

Tuplas = Lista de objetos inmutables. No se puede modificar los elementos de la tupla.

Si se puede modificar TODA la tupla por otra tupla.

Son muy utiles para almacenar listas de objetos de distinto tipo de dato.

Una caracteristica muy util es desempaquetar una tupla, sin necesidad de un ciclo.

Las Tuplas no se pueden modificar, pero si se pueden reasignar.

Pienso que las tuplas sirven para crear como un array de constantes, o como dice David devolver valores de funciones en diferentes variables, que buena utilidad la de las tuplas.

print("Me estoy enamorando de Python.")

Syntactically, a tuple is a comma-separated list of values:

>>> t = 'a', 'b', 'c', 'd', 'e'

Although it is not necessary, it is common to enclose tuples in parentheses to help us quickly identify tuples when we look at Python code:

>>> t = ('a', 'b', 'c', 'd', 'e')

To create a tuple with a single element, you have to include the final comma:

>>> t1 = ('a',) 
>>> type(t1) 
<type 'tuple'>

Tomado del libro 鈥淧ython for everybody鈥, p谩gina 117.

As铆 que esto tambi茅n es v谩lido.

>>> t = 3,
>>> type(t)
<class 'tuple'>

Particularmente esto me causo mucho conflicto, no lo hab铆a visto en otros lenguajes, pero la raz贸n es porque el constructor de una tupla es la coma. 隆Woooooo!

Para 鈥渕odificar鈥 una Tupla

mi_tupla = (1, 'dos', True)
mi_lista = list(mi_tupla)
print("Antes: ",mi_tupla)
mi_lista[2] = 'III' 
mi_tupla = tuple(mi_lista)
print("Despues: ",mi_tupla)

En realidad se crea una lista a partir de una tupla y luego se crea una tupla a partir de una lista (modificada).

Tengo una duda.
En este primer ejemplo se escribi贸:
my_tuple=(1,鈥榙os鈥,True)
my_tuple=(3,)
S茅 que se guard贸 en distinta parte de la memoria.
Pero, 驴C贸mo podr铆a acceder a la primera?

Gracias

Super interesante estas tuplas, muy util para crear arreglos que tengan distintos valores de distintos tipos de datos, fue lo que mas me llamo la atenci贸n.

Esto es poderoso, ya que puedo tomar un registro (una tupla) de una base de datos, colocarlo en una tupla y procesarlo, con una m铆nima cantidad de transformaciones.

No se modifican, se crean nuevas. Excelente.

Muy buenos los comentarios de los compa帽eros. Siempre se hallan cosas interesantes en los comentarios.
Saludos a todos.

# Tuplas
# Son datos que jamas se pueden cambiar
# Pueden contener cualquier tipo de dato que quieras
# Pueden utilizarse para devolver valores obtenidos mediante una funcion
# Se puede reasignar la tupla creada para la variable para insertar otros valores pero no podemos de por si modficar los datos que tengan en una posicion dada de la tupla

# Ejemplo de tutpla
tupla_inicial = ()

tupla_reasignable = ()
# Lo curioso que nosotros podemos recorrer la tupla como una cajita(array) por el cual obtener los datos desde la posicion inicial de este a partir desde el 0 a n elementos que tengamos dentro de la tupla
tupla_reasignable = ('hola', 'como estas', 'adios')

print(tupla_reasignable[2])

primerNumeroTupla = (1,)
sumaDeTupla = (2,3,4)

primerNumeroTupla += sumaDeTupla

print(primerNumeroTupla)

# Desestructurar objetos
# variables por las posicion de los objetos recordar que es una cajita(array)
# ej: 
# cajita = (1,2,3,4,5)
# destructuracion
# primerNumero,segundoNumero,tercerNumero,cuartoNumero = cajita
# print(primerNumero) = 1 Ta Da!!

# Tener en mente que estas variables van desde la ultima posicion en adelante 
x, y, z = sumaDeTupla

print(x)
print(y)
print(z)```

Hice algo que me pareci贸 un buen ensayo.
Saludos.

def saludo ():
    print (f'\n\nListo {dataPlayer[0]}!!!')

def codGen ():
    codUser = (f'{dataPlayer[0][:3]}'+f'{dataPlayer[1][:1]}'+f'{dataPlayer[2][1::2]}'+f'{dataPlayer[3][:1]}'+f'{dataPlayer[4][1:]}')
    print (f'\n\nTU CODIGO DE USUARIO ES: {codUser}')

print ('Hola.\nVamos a registrar tus datos')
user = input ('Nombre de usuario: ')
age = input ('Edad actual: ')
country = input ('Residencia actual: ')
wins = input ('Victorias de Equipo: ')
defeats = input ('Derrotas de Equipo: ')


dataPlayer = (user, age, country, wins, defeats)

codGen ()
saludo()

print (f'\nDatos Registrados:\nUsuario: {dataPlayer[0]}\nEdad: {dataPlayer[1]}\nPais: {dataPlayer[2]}\nVictorias: {dataPlayer[3]}\nDerrotas: {dataPlayer[4]}\nGracias.')

馃槏 ahora todo tiene sentido!

Cada clase que tomo me encanta m谩s que la anterior. 馃槉
Gracias profesor Aroesti!

Un dato curioso de las tuplas es que se calculan mas r谩pido que las listas

Para complementar el concepto me pareci贸 bastante interesante este post sobre las diferencias y las ventajas que tienen usar una tupla y una lista: https://www.afternerd.com/blog/difference-between-list-tuple/

Unpacking
El desempaquetado (unpacking) es una caracter铆stica muy especial de Python que nos permite asignar un conjunto de valores a un conjunto de variables con la condici贸n de que la cantidad de variables tiene que ser siempre igual a la cantidad de valores. Por ejemplo, una tupla como (10, 20, 30) la podr铆amos asignar a las variables x, y, z respectivamente utilizando unpacking de la siguiente forma:

Tuplas:

  • Inmutables
  • Aceptan cualquier tipo de datos
  • Acepta mas tuplas anidadas dentro de otra.
  • Es indexable.
>>> my_tuple = 1, [1,2], {1:"one", 2: "two"}, (1,2,"three")
>>> type(my_tuple)
<class 'tuple'>
>>> my_tuple
(1, [1, 2], {1: 'one', 2: 'two'}, (1, 2, 'three'))
>>>

Qu茅 son las tuplas 馃悕
En Python, una tupla es un conjunto ordenado e inmutable de elementos del mismo o diferente tipo.
Pueden utilizarse para devolver varios valores en una funci贸n.
Las tuplas se representan escribiendo los elementos entre par茅ntesis y separados por comas.

>>> (1, "a", 3.14)
(1, 'a', 3.14)

En realidad no es necesario escribir los par茅ntesis para indicar que se trata de una tupla, basta con escribir las comas, pero Python escribe siempre los par茅ntesis:

>>> 1, "a", 3.14
(1, 'a', 3.14)

La funci贸n len() devuelve el n煤mero de elementos de una tupla:

>>> len((1, "a", 3.14))
3

Una tupla puede no contener ning煤n elemento, es decir, ser una tupla vac铆a.

>>> ()
()
>>> len(())
0

Una tupla puede incluir un 煤nico elemento, pero para que Python entienda que nos estamos refiriendo a una tupla es necesario escribir al menos una coma.
El ejemplo siguiente muestra la diferencia entre escribir o no una coma. En el primer caso Python interpreta la expresi贸n como un n煤mero y en el segundo como una tupla de un 煤nico elemento.

>>> (3)
3
>>> (3,)
(3,)

Python escribe una coma al final en las tuplas de un 煤nico elemento para indicar que se trata de un tupla, pero esa coma no indica que hay un elemento despu茅s:

>>> (3,)
(3,)
>>> len((3,))
1

Con las tuplas tambi茅n las podemos agregar, reasignandolas de la siguiente manera

>>>my_tuple = (1, )
>>> my_other_tuple = (2, 3, 4)
>>> my_tuple += my_other_tuple
>>> print(my_tuple)
(1, 2, 3, 4)

Tambi茅n podemos desempaquetar una tupla de la siguiente manera:

>>> x, y, z = my_other_tuple
>>> x
2
>>> y
3
>>> z
4

Regresar los valores de una funci贸n

>>> def coordenadas():
...     return(5,4)
>>> coordenada = coordenadas()
>>> coordenada
(5, 4)
>>> x, y = coordenadas()
>>> x
5
>>> y
4

Importante diferenciar.

Listas: permiten cambiar los elementos por otro

my_list = [1,2,3]

Tuplas: no se cambian los valores, para hacerlo se deberia cambiar toda la tupla, suelen gastar menos memoria,

my_tuple = (1,2,3)

Diccionarios: Tiene una llave y un valor

my_dic = {uno : 1, dos : 2, tres : 3}

Bien explicado! no me qued贸 claro si una tupla puede guardar una funci贸n y luego acceder a ella por medio de la tupla.

Entiendo que el tema de las listas, tuplas, conjuntos y diccionario es un tema amplio para estudiar que merece el revisarse constantemente. Son objetos poderosos para trabajar el registro de los datos. Consult茅 una info b谩sica y para comenzar, en esta p谩gina: https://j2logo.com/python/tutorial/tipos-de-datos-basicos-de-python/#tipos-datos-otros

TUPLAS
Son inmutables, es decir no pueden ser mutados los objetos dentro de una tuppla, solo se puede realizar una re-asignaci贸n

Tambien se pueden devolver mas de un valor en las funciones !

def cordenadas():
    return 4,5
    
x = cordenadas()

print (x)

x,y = cordenadas()

print (x,y)

y,_ = cordenadas()

print (y)```

Se pueden re-asignar mas no modificar: clave esta parte

A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The main difference between the tuples and the lists is that the tuples cannot be changed unlike lists. Tuples use parentheses, whereas lists use square brackets.
https://www.tutorialspoint.com/python3/python_tuples.htm

RESUMEN:

Tupla -> _son cadenas de objetos inmutables, es decir que no pueden ser modificados. _
Pueden ser cadenas con cualquier tipo de objetos.
Se pueden utilizar en funciones para devolver varios valores, a diferencia del return que solo devuelve un solo valor.

CLASE: TUPLE
驴Como se define python? my_tuple = () #Como vemos solo se requiere ()
Que contiene: puede devolver varios objetos de diferentes clases.

Ejemplo(Consola de python)

my_tuple=()
type(my_tuple)
<class 鈥榯uple鈥>

my_tuple=(1, 鈥榙os鈥, True) #valores de tipo int, string, bool
my_tuple[0] #Estamos llamdo a los indices de las tuplas
1

my_tuple[1]
鈥榙os鈥

print(my_tuple[1])
dos

my_tuple[2]
True

Si tratas de reasignar un valor a un indice de la tupla nos votar谩 error:

my_tuple[2]=3
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object does not support item assignment

Para definir a TUPLAS DE 1 SOLO VALOR
se define d la siguiente manera: -> my_tuple=(1,) <鈥 Con un 1 seguido de una coma

Ejemplos:
>>> my_tuple=(1)
>>> type(my_tuple)     #Como no introducimos la coma, la tupla se dedfinio con un valor int =1
class 'int'>
>>> my_tuple=(1,)      #Manera correcta de asignai贸n
type(my_tuple)
<class 'tuple'>

**
OPERACIONES CON TUPLAS:**
tratamos de asignar variables a los valores de las tuplas:
Ejemplo:
>>> my_other_tuple=(2,3,4)
>>> x,y,z=my_other_tuple
>>> my_tuple+=my_other_tuple
>>> my_tuple
(1, 2, 3, 4)

LAS FUNCIONES PUEDEN DEVOLVER TUPLAS
>>> def cordenadas():
鈥 return(5,4)

>>> cordenada=cordenadas()
>>> print(cordenada)
(5, 4)
>>> type(cordenada)
<class 鈥榯uple鈥>

Las tuplas se pueden modificar__
??

En la clase sobre tuplas aprendimos que estas son secuencias inmutables de objetos. A diferencia de las cadenas, las tuplas pueden contener cualquier tipo de valor. Tambi茅n vimos que las tuplas se pueden utilizar para devolver varios valores en una funci贸n y que no se pueden modificar una vez definidas, aunque s铆 se pueden reasignar.

Para acceder a los elementos de una tupla, se usa el 铆ndice, comenzando en 0. Adem谩s, es posible desempaquetar los valores de una tupla en variables individuales.

Aqu铆 tienes algunos ejemplos de c贸digo que se mostraron en la clase:

# Definir una tupla
mi_tupla = (1, "hola", True)

# Acceder a los elementos de una tupla
primer_elemento = mi_tupla[0]  # 1
segundo_elemento = mi_tupla[1]  # "hola"
tercer_elemento = mi_tupla[2]  # True

# Reasignar una tupla
mi_tupla = (2, "adios", False)

# Desempaquetar valores de una tupla
mi_tupla = (5, 4)
x, y = mi_tupla
print(x)  # 5
print(y)  # 4

# Devolver varios valores en una funci贸n
def coordenadas():
    return 5, 4

x, y = coordenadas()
print(x)  # 5
print(y)  # 4

隆Espero que te haya resultado 煤til este resumen!

Tuplas en Python

En Python, una tupla es una estructura de datos inmutable que puede contener elementos de diferentes tipos de datos. Es muy similar a una lista, pero a diferencia de las listas, no se pueden modificar una vez creadas. Las tuplas se crean utilizando par茅ntesis en lugar de corchetes, y los elementos se separan con comas.

mi_tupla = ("manzana", "banana", "cereza")

Las tuplas son 煤tiles cuando se necesitan datos que no deben modificarse despu茅s de su creaci贸n, o cuando se desea tener datos que no puedan ser modificados accidentalmente. Adem谩s, a menudo se utilizan para devolver m煤ltiples valores de una funci贸n en un solo objeto.
.
Para acceder a un elemento espec铆fico de la tupla, se puede utilizar el operador de indexaci贸n, que funciona de manera similar a las listas:

print(mi_tupla[0]) # Imprime "manzana"

Dado que las tuplas son inmutables, no se pueden agregar o eliminar elementos, ni modificar los elementos existentes. Sin embargo, se pueden concatenar dos o m谩s tuplas para crear una nueva tupla:

tupla_1 = ("manzana", "banana")
tupla_2 = ("cereza",)
nueva_tupla = tupla_1 + tupla_2 # Se crea una nueva tupla
print(nueva_tupla) # Imprime ("manzana", "banana", "cereza")

Algo que falto explicar es que en el proceso de desempacar una tupla se necesita que se especifique la cantidad correcta de variables para desempaquetar todos los elementos de la tupla. Si la cantidad de variables utilizadas en el proceso de desempaquetar es menor que la longitud de la tupla, o si es mayor, ocurrir谩 un fallo.
Estos fallos ocurren para garantizar que se mantenga la integridad de la tupla y se evite la p茅rdida de datos o asignaciones incorrectas. Es importante asegurarse de utilizar la cantidad correcta de variables al desempaquetar una tupla para evitar estos errores y garantizar un comportamiento correcto en el c贸digo.

Les dejo un buen video de las tuplas 馃槈:

La Tupla y el Array se me hacen un poco parecidos. Ser谩 que son un tipo de Arrays para usar en Python?

La parte del desempaquetado me pareci贸 brutal, muy buen profesor

El garbage collector es necesario en un escenario en donde hay tipos inmutables.

En resumen

Una tupla es una secuencia de valores agrupados.

Una tupla sirve para agrupar, como si fueran un 煤nico valor, varios valores que, por su naturaleza, deben ir juntos.

El tipo de datos que representa a las tuplas se llama tuple. El tipo tuple es inmutable: una tupla no puede ser modificada una vez que ha sido creada.

Una tupla puede ser creada poniendo los valores separados por comas y entre par茅ntesis. Por ejemplo, podemos crear una tupla que tenga el nombre y el apellido de una persona:

>>> persona = ('Perico', 'Los Palotes')
>>> persona
('Perico', 'Los Palotes')

Interesante dato sobre las tuplas, no sab铆a que pod铆an tener 1 solo elemento y que para que python las interprete como tupla hab铆a que ponerle una coma 馃槉
Al comienzo dije ah bueno sobre las tuplas ya s茅 馃槢 y me voy ahora con un conocimiento m谩s.

Algo que me gustar铆a remarcar de lo dicho por el profe, es que al igual que las listas, los elementos de las tuplas ocupan posiciones concretas, y mediante esa posici贸n que ocupan podemos acceder directamente a los elementos.

  • Las tuplas al igual que las listas en Python son secuencias pero las tuplas son secuencias inmutables de objetos (eso significa que no se pueden modificar)
  • A diferencia de las cadenas pueden contener cualquier tipo de objeto.
  • Puede utilizarse para devolver varios valores en una funcion

驴C贸mo identificar tuplas y listas en Python?


# Sintaxis de tuplas en PY:
tuple_name = ('first_value', 2, 'can_add_ints')

# Sintaxis de聽*listas*聽en Py:
list_name = [1,'2', 3]

Como pueden apreciar, para la asignaci贸n de las聽tuplas, el contenido debe ir 鈥渆mpaquetado鈥 mediante par茅ntesis 鈥()鈥, mientras que para las listas, se empaquetan en corchetes 鈥淸]鈥.

  • Para declarar una tupla en Python se realiza lo siguiente: tuple_name = ()
  • El contenido de la tupla pueden ser de tipo聽int,聽float y聽string
  • En caso de que la tupla contenga un solo valor, se debe agregar una 鈥,鈥 EJ: tuple_name = (1,)
  • En caso de contener un聽float: tuple_name = (2.0,)
  • En caso de contener un聽string: tuple_name = ('string',)
  • Las tuplas tambi茅n se pueden representar sin par茅ntesis: my_tuple = 1, 2, 3

Tupla

Lo que aprend铆 y entend铆.

Practicando un poco 馃槂

def run():
    # Las tuplas son inmutables
    tupla = (1,"2",3.0)
    # Agregar una coma cuando es una tupla de un valor
    tupla_one_value = (5,)
    # Sumar tuplas
    tuple_join = tupla + tupla_one_value
    # desempaquetar tupla
    a, b, c = tupla
    # devolver una tupla con una funcion
    def coordenada():
        return (1,3)
    
    x, y = coordenada()


    print(f"""
            tupla \t\t-> {tupla}
            tupla_one_value \t-> {tupla_one_value}
            tuple_join \t\t-> {tuple_join}
            a, b, c \t\t-> {a} {b} {c}
            x, y \t\t-> {x} {y}
    """)


if __name__ == '__main__':
    run()

Les dejo mis apuntes de la clase donde explico algunos m茅todos para als tuplas y algunas de sus caracter铆sticas
Apuntes

Que clase m谩s tesa!!!, o sea el contenido es claro, pero siento que despu茅s de 2 o 3 d铆as, sin practica no hay mucho que pueda recordar, as铆 que siento que volver茅 a ver esta clase de nuevo en un tiempo para refrescar conceptos y tratar adaptar mejor estos conceptos tan poderosos.

Las tuplas son cadenas de datos que nos permiten almacenar todo tipo de datos dentro de Python tal y como se puede hacer con las listas. Pero en gran diferencia no podemos modificarlas despu茅s de haberlas creados(Son datos inmutables).

Las tuplas se definen con () y las listas con []

my_tuple = (1,"Mexico", True)

x,y,z = my_tuple

print(f'Esta es mi tupla {my_tuple} y estos son sus valores X {x} Y {y} Z {z}')

my_tuple = (1,)

驴C贸mo identificar una tupla en Python?
馃馃馃
Las tuplas en Pyhton poseen siguiente sintaxis:
tuple_name = (鈥榝irst_value鈥, 2, 鈥榰_can_add_ints鈥)
馃
Mientras que las listas en Python tienen esta sintaxis:
list_name = [1,鈥2鈥, 3]

Buena clase!

En Python, una tupla es un conjunto ordenado e inmutable de elementos del mismo o diferente tipo. Las tuplas se representan escribiendo los elementos entre par茅ntesis y separados por comas. Una tupla puede no contener ning煤n elemento, es decir, ser una tupla vac铆a.

En verdad excelente. Gracias

Peque帽o recordatorio de las caracter铆sticas de los array y listas en Python
Lista:
-Colecci贸n de datos ordenados
-Se pueden modificar los datos que contiene
-Puede incluir datos de distintos tipos
-Accesible mediante 铆ndice
Se declaran as铆: list = [鈥渕ango鈥, 1, True]

Array:
-Colecci贸n de datos del mismo tipo primitivo ordenados
-Se puede modificar
-Accesible mediante 铆ndice
-Los datos se guardan de forma contigua as铆 es m谩s f谩cil encontrar los datos
-Se utiliza cuando necesitamos almacenar datos del mismo tipo

Cuando se define un array lo primero que haremos es establecer cu谩l es el tipo de dato que va a contener, se asignar谩 con una letra identificativa. Esto que parece una restricci贸n garantiza tambi茅n, cuando se trabaja con miles o millones de datos, que todos sean del mismo tipo.

El array se declara as铆:
// Primero hay que importar el m贸dulo array
import array as arr
// Creamos un array de tipo int
a = arr.array(鈥榠鈥, [1, 2, 3])
La i hace referencia al c贸digo que hemos mencionado antes.

Tuplas
Caracter铆sticas de las tuplas:
-Son secuencias inmutables de objetos, es decir, no podemos borrar ni modificar los que tiene, pero si se pueden reasignar.
-A diferencia de las cadenas pueden contener cualquier tipo de objeto
-Puede utilizarse para devolver varios valores en una funci贸n
-Ocupan menos espacio en memoria.
-Se almacenan en un bloque de memoria
-Se utilizan porque son m谩s r谩pido de crear que una lista.

Se declaran de la siguiente forma:
my_tuple = (1, 2, 鈥榯res鈥, True)

En caso de que tu tupla s贸lo contenga un valor, debes agregar una coma 鈥,鈥 para que python lo reconozca como tupla, por ejemplo:
my_tuple = (1,)

Tambi茅n podemos juntar tuplas de la siguiente forma:
my_tuple += my_other_tuple

Las tuplas pueden ser desempaquetadas para duplicar esos valores a otras variables, al desempaquetar debemos duplicar todas las variables que haya dentro de la tupla.
Se realiza de la siguiente forma:
my_tuple = (1, 2, 3, 鈥楶epe鈥, True)
a, b, c, d, e = my_tuple
Se van duplicando en el mismo orden.

Tipos de datos estructurados: Muchos datos(bytes) dentro de una sola variable.
Mutabilidad
Tuplas: Secuencias inmutables de datos. Contienen caualquier tipo de dato(puede haber tuplasd mixtas). Devuelven varios valores en una funci贸n. Es una lista de data que no se puede modificar.
Se puede accesar global o por indiece.
Se desempaquetan asignandole una variable a cada indice.
Variable = (tupla,)

Podemos poner como el valor retornable una tupla: return (2,3,4,5)

A la hora de definir una tupla con solo objeto, es necesario que pongamos una coma para se帽alizar que tenemos una tupla y no un entero o cadena ( o cualquier tipo de dato que pongamos singularmente)

Creo que la forma m谩s f谩cil de definir una tupla (si vienes de otros lenguajes de programaci贸n) es como un array est谩tico (o en C++ un array com煤n), me parece genial que con las tuplas se puede hacer lo que en JavaScript se llamar铆a (destructuring) jaja

#las tuplas son secuencias inmutables de objetos
#las tuplas se pueden usar para devolver m谩s de un valor

my_tuple = () #una tupla vac铆a se puede definir solamente con par茅ntesis
type(my_tuple) #Esto es para saber qu茅 es de tipo tupla

#asign谩ndoles valores de mi tupla
my_tuple = (1, 'dos', True) #reaccionando la tupla con valores de diferente tipo

#imprimiendo estos valores
print(my_tuple[0]) #esto deber铆a imprimir el primer valor de mi tupla porque en programaci贸n al 铆ndice empieza en 0. En este caso ser铆a el entero 1
print(my_tuple[1]) #en este caso se imprimiria el segundo valor de mi dupla Qu茅 es la cadena 'dos'.

#conociendo el error al intentar cambiar un valor asignado a mi tupla
#my_tuple[0] = 2 #A qu茅 intentamos cambiar el primer valor, que ser铆a el n煤mero 1, por el n煤mero 2.
#my_tuple = (1) #si podemos reasignar una tupla pero para que sea de tipo tupla necesita coma despu茅s del primer valor.
#type(my_tuple) #aqu铆 dir铆a que es un entero y no una tupla

my_other_tuple = (2, 3, 4) #Creamos otra tupla
my_tuple += my_other_tuple #Creamos un nuevo espacio de memoria con los valores de my_tuple y my_other_tuple. Y ponemos a la variable my_tuple a apuntar a ese espacio de memoria

my_tuple = (1, 2, 3)
variable_1, variable_2, variable_3 = my_tuple #si tengo una tupla de tres n煤meros yo puedo asignar esos numeros a tres variables diferente.

def coordenadas():
    return (5, 4)

x, y = coordenadas()
print(x, y)

#aqu铆 yo aprend铆 qu茅 las tuplas las puedo usar para asignar una cierta cantidad de n煤meros a una cierta cantidad de variables y tambi茅n puedo con las funciones devolver m谩s de un n煤mero mediante tuplas

esta muy interesante, tuve que retornar el video poquito para entenderle mejor

buen aporte

Tuplas: son secuencias inmutables de Objetos(es como una lista la cual no podemos modificar con posterioridad pero si las podemos asignar)

A diferencia de los Strings las Tuplas pueden tener cualquier tipo de objeto.

Las tuplas pueden devolver varios valores en una funcion

Las tuplas no se pueden modificar pero si se pueden reasignar

puedes reasignar el valor dentro de la tupla poniendola entre parentesis y tambien puedes sumarizarlas

podemos reasignar las tuplas de las maneras que nosotros queramos

Como regresar varios valores de una funcion

podemos regresar el valor de una tupla con la funcion de coordenadas

def coordenadas ():

鈥 return (5, 4)

  • Las tuplas son secuencias de objetos inmutables, es decir que no se pueden modificar.
  • A diferencia de las cadenas de textos, que tambi茅n son inmutables, las tuplas pueden contener cualquier tipo de objeto.
  • Las tuplas se pueden usar para devolver varios valores en una funci贸n.
  • Las tupas se pueden sumar con otras tuplas, en este caso no estamos modificando, si no reasignando.
  • Se puede desempaquetar los valores de una tupla en varias variables.
my_tuple=(1,2,3)
x,y,z=my_tuple # x=1, y=2, z=3

Entendido el manejo de tuplas

Las tuplas son listas de objetos que no se pueden modificar

Me gusto mucho el hecho de que se puedan sumar las tuplas, es curioso la forma en que se hace.

隆Maravilloso!

Tupla: Son secuencias inmutables de objetos.

No pueden modicarse!!

Acceptable

En verdad am茅 la clase de tuplas. Hace alg煤n tiempo trabaj茅 en un programa que tenia ese tipo de datos y yo todo terco trataba de modificar sus valores. Vaya error en el que estaba.

Nada mas util que las tuplas

Aqui es donde se ponen interesantes las cosas.

Se pone la cosa seria.

cual es la diferencia entre una tupla y un vector?

Es muy buena la utilizacion de las tuplas, ya que no se pueden modificar y eso puede ayudar a que tu programa no sea modificado.

Estos conceptos ya me vuelan la cabeza! .
En el buen sentido por que esta genial el curso!

Est谩 muy bien explicado!

Corriganme si me equivoco:
Arreglos: Puede almacenar una colecci贸n del mismo tipo de dato, los datos pueden modificarse o reasignar datos al arreglo.
Tuplas: Puede almacenar una colecci贸n de objetos de distintos tipos de datos, los datos no pueden modificarse, pero se puede reasignar datos a las tuplas.

En Mexico los conocemos como Arrays

my_tupla = ()
type(my_tupla)
<class 鈥榯uple鈥>

my_tupla = (1, 鈥榙os鈥, True)
my_tupla[0]
1

my_tupla[1]
鈥榙os鈥

my_tupla[2]
True

my_tupla = (1)
type(my_tupla)
<class 鈥榠nt鈥>

my_tupla = (1,)
type(my_tupla)
<class 鈥榯uple鈥>

my_otra_tupla = (2, 3, 4)
my_tupla += my_otra_tupla
print(my_tupla)
(1, 2, 3, 4)

x, y, z = my_otra_tupla
x
2

y
3

z
4

def coordenadas():
鈥 return(5, 4)

coordenadas = coordenadas()
coordenada
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
NameError: name 鈥榗oordenada鈥 is not defined

coordenadas
(5, 4)

x, y = coordenadas()
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object is not callable

print(x, y)
2 3

def coordenadas():
鈥 return(5, 4)

coordenadas = coordenadas()
coordenada = coordenadas()
Traceback (most recent call last):
File 鈥<stdin>鈥, line 1, in <module>
TypeError: 鈥榯uple鈥 object is not callable

def coordenadas():
鈥 return(5, 4)

coordenada = coordenadas()
coordenada
(5, 4)

x, y = coordenadas()
print(x, y)
5 4

x
5

y
4

Este tema es fascinante鈥ara repasar y profundizar mucho

Muy bien explicado

genial

my_tuple = (1,) #Creacion de tuplas print(my_tuple) >>>1 my_other_tuple = (2, 3, 4) my_tuple += my_other_tuple #reasignaci贸n de tuplas print(my_tuple) >>>(1, 2, 3, 4) x, y, z = my_other_tuple print (x) >>>2

Tambi茅n sirve para darse una idea de como realizar operaciones con matrices, que veo se usara mas adelante en los cursos de Data Scients

Concepto cr铆tico: mutabilidad, inmutabilidad y referencia en Python: A efectos pr谩cticos, es como si se tratara de un puntero (empleando conceptos de otros lenguajes) a ese objeto, Es decir, no contiene su valor, sino una referencia a 茅l. ``` >>> my_tuple = (1, ) >>> my_other_tup

Excelente clase!