Tuplas

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 “empaquetado” 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)

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 (‘String’)
  • 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

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 😄

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

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.

<"""
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)>

Las tupas son inmodificables pero si reasignables

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

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.

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 “Python 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!

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 😒

Para “modificar” 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).

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

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:

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)```

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

Cada clase que tomo me encanta más que la anterior. 😊
Gracias profesor Aroesti!

😍 ahora todo tiene sentido!

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.')

❤

# 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)```

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

No se modifican, se crean nuevas. Excelente.

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.

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.

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/

Tengo una duda.
En este primer ejemplo se escribió:
my_tuple=(1,‘dos’,True)
my_tuple=(3,)
Sé que se guardó en distinta parte de la memoria.
Pero, ¿Cómo podría acceder a la primera?

Gracias

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 ‘tuple’>

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

my_tuple[1]
‘dos’

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: ‘tuple’ 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 ‘tuple’>

Las tuplas se pueden modificar__
??

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 = (‘first_value’, 2, ‘u_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 = [“mango”, 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(‘i’, [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, ‘tres’, 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, ‘Pepe’, 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

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

#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

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}

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 ‘tuple’>

my_tupla = (1, ‘dos’, True)
my_tupla[0]
1

my_tupla[1]
‘dos’

my_tupla[2]
True

my_tupla = (1)
type(my_tupla)
<class ‘int’>

my_tupla = (1,)
type(my_tupla)
<class ‘tuple’>

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 ‘coordenada’ is not defined

coordenadas
(5, 4)

x, y = coordenadas()
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: ‘tuple’ 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: ‘tuple’ 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…para 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!

excelente clase

Hice un resumen de las estructuras de datos con algunos ejemplos https://drive.google.com/file/d/1p_ljmmtBdSTHh_5rnXXUeD2Qs2XhUpYK/view?usp=sharing, espero les sirva.

MUY PRACTICO ESA ULTIMA PARTE

Clarisimo 😀

No sabía que se podía asignar una tupla entera a otra cosa, pero tiene sentido, no estás modificando la tupla, simplemente estás reasignando la variable entera.

buena clase

<my_tuple=()
tipo=type(my_tuple)
print(tipo)
my_tuple2=(1, 'dos', True)
primer_elemento=my_tuple2[0]#Recuerda que Python siempre empieza a contar desde 0
print(primer_elemento)
my_tuple3=(1)#Lo señala como tipo 'int' porque no hemos agregado una coma
tipo3=type(my_tuple3)
print(tipo3)
my_tuple4=(1,)#Ahora si lo señala como tupla
tipo4=type(my_tuple4)
print(tipo4)
my_other_tuple1=(1,)
my_other_tuple=(2,3,4)
my_other_tuple1 +=my_other_tuple #Estamos combinando las tuplas
print(my_other_tuple1)
x,y,z=my_other_tuple#Desempaquetar elementos de la tupla
print(x)
print(y)
print(z)

def coordenadas():#Esta funcion guarda una tupla
    return (5,4)

coordenada=coordenadas()#La variable coordenada ahora guarda la funcion que guerda a su vez una tupla
print(coordenada)
x,y=coordenadas()
print(x,y)
>

[2:27] Para definir una tupla usamos los paréntesis. Por ejemplo my_tuple = ().

[2:59] A diferencia de java y otros lenguajes, los tipos de valores dentro de una tupla pueden ser mixtos. Podemos acceder a los valores de la tupla mediante índices.

Tuplas, un elemento muy versátil, no existente en otros lenguajes de programación.

Tuplas

Las tuplas son secuencias inmutables (no se pueden modificar) de objetos, que a diferencia de las cadenas pueden contener cualquier tipo de objetos. Estas pueden utilizarse para devolver varios valores en una función.

def coordenadas():

    # En nuestra función devolveremos la tupla (5, 4).
    return (5,4)

# Si ejecutamos la función vamos a recibir la tupla.
>>> coordenadas()
(5,4)

# Tambien podemos "desempaquetar" la tupla que recibimos,
# esto significa que podemos asignar cada valor que nos llega de la
# tupla a variables que definamos.
>>> x, y = coordenadas()

# Si imprimimos la primera variable desempaquetada veremos
# el primer valor de la tupla.
>>> x
5

# Y muy parecido al ejemplo anterior, con nuestra
# variable "y" tendremos el segundo valor.
>>> y
4

Genial, organizamos y podemos reasignar valores 😉

[3:37] Se dice que una tupla es inmutable, debido a que despues de creada sus elementos no se pueden modificar. (Aunque en esos casos si lo requerimos lo que podemos hacer es crear una nueva)