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)

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 (‘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

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

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

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

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 ‘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__
??

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 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 “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
• 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 = (‘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

#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 ‘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!