Entendiendo cómo funcionan las tuplas

No había quedado claro la diferencia entre listas y tuplas y cuando usar cada una hasta ahora, gracias.

Para los que no lo sabían, los strings (cadenas de caracteres) al igual que las tuplas, también son considerados por python como inmutables.

La única manera de modificar el contenido de una variable de tipo string, es reasignando completamente su valor. No es posible realizar cambios individuales en un índice particular.

Tuplas → Conjunto inmutable de valores ordenados

• eficientes
  .
  Listas → Conjunto dinamico de valores ordenados
• versatiles
  .
  (ﾉ◕ヮ◕)ﾉ*:･ﾟ✧

Funciones que aplican a tuplas:

• len
• max
• min
• sum
• any
• all
• sorted

Métodos que aplican a tuplas:

• index
• count

Hay ciertas maneras de cambiarles los valores a una tupla, un ejemplo es este:

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)

Un recurso para reforzar un poco el tema 😄

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.

Resumen de las tuplas

#declarar tupla
mi_tupla = ()
mi_tupla = (1,2,3)

#generar una tupla de 1 solo valor (Obligatorio la ,)
mi_tupla = (1,)

#acceder a un indice de la tupla
mi_tupla = (1,2,3)
mi_tupla[0] #1
mi_tupla[1] #2
mi_tupla[2] #3

#reasignar una tupla
mi_tupla = (1,2,3)
mi_otra_tupla = (4,5,6)
mi_tupla =+ mi_otra_tupla

#metodos de las tuplas
mi_tupla = (1,1,1,2,2,3)
mi_tupla.count(1) #3	el numero 1 aparece 3 veces en la tupla
mi_tupla.index(3) #5	indice de la primera instancia donde se encuentra un elemento
mi_tupla.index(1) #0
mi_tupla.index(2) #3

Nota importante de la clase que nos comparte el profesor:

La estructura de datos más rápida dentro del lenguaje Python es la tupla, por su condición de ser estática (o inmutable). Por lo anterior, si se construyen un FOR LOOP con un tupla, y otro con una lista, ambos con la misma cantidad de elementos; la ejecución más rápida se da en caso de la tupla.

Al concepto de tupla y lista le veo una similitud a char y varchar de MySQL

• Tupla y char = Permiten una cantidad fija de elementos dentro y no se pueden modificar luego siendo asi de tipo inmutables.
• Lista y varchar = Permiten agregar la cantidad de elementos que se quiera, logrando ser mutables.

Para complementar, les comparto el siguiente enlace:

El Libro de Python

Listas

>>> numeros = [1,2,3,4,5]
>>> numeros
=> [1, 2, 3, 4, 5]

>>> objetos = [1,2.2,True,'Mau']
>>> objetos
=> [1, 2.2, True, 'Mau']

>>> objetos = [1,2.2,True,'Mau']
>>> objetos.append('Hello')
>>> objetos
=> [1, 2.2, True, 'Mau', 'Hello']

>>> list1 = [1,2,3,4,5]
>>> list2 = ['mau', 'angie', 'other', 100]
>>> list1 + list2
=> [1, 2, 3, 4, 5, 'mau', 'angie', 'other', 100]

>>> list1 = [1,2,3,4,5]
>>> list1 * 5
=> [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

Tuplas

Son listas pero estáticas, esto quiere decir que NO podemos agregar/eliminar/modificar valores, pero SI puedo recorrer la lista (inmutables)

>>> mi_tupla = (1,2,3,4,5)
>>> mi_tupla[1]
2
```

```python
# No puedo agregar/eliminar o modificar los valores
>>> mi_tupla = (1,2,3,4,5)
>>> mi_tupla[1] = 100
=> Traceback (most recent call last):
=>   File "<stdin>", line 1, in <module>
=> TypeError: 'tuple' object does not support item assignment
>>> mi_tupla[1].append(200)
=> Traceback (most recent call last):
=>   File "<stdin>", line 1, in <module>
=> AttributeError: 'int' object has no attribute 'append'
>>> mi_tupla[1].pop(1)
=> Traceback (most recent call last):
=>   File "<stdin>", line 1, in <module>
=> AttributeError: 'int' object has no attribute 'pop'

📦 Las tuplas y las listas son similares pero no iguales. Difieren en su comportamiento:

• Dinámico: Se puede agregar elementos.

>>> elements = [1,"z", 2.4, False]
>>> elements.append(True)

• Estático: No se puede agregar elementos.

>>> elements = (1,"z", 2.4, False)

Hice un código que mide la diferencia de tiempo que se demora una lista y una tupla. Con 10,000,000 elementos cada uno.

Quizá alguien mejore el código ya que pienso que la tupla no esta siendo declarada y asignada de forma correcta.
A pesar de ello la lista demora más tiempo.

import time

#lista
inicio=time.time()
#codigo a medir
lista=list(range(10000000))

fin=time.time()

tlista=fin-inicio
print(f"Tiempo que se demoro la lista = {tlista}")

#tupla
inicio=time.time()
#codigo a medir
tupla=tuple(lista)

fin=time.time()
ttupla=fin-inicio
print(f"Tiempo que se demoro la tupla = {ttupla}")

#direrencia de tiemp
print(f"La diferecia entre tlista y ttupla = {tlista-ttupla}")

Differences between lists and tuples

Tuplas: Son un tipo de objeto estatico dentro de python a diferencia de las listas que son un objeto dinamico, es decir son un tipo de dato que su valor no va a cambiar, al igual que cuando creamos una variable constante. Y al momento de realizar una iteracion en el codigo del proyecto tendremos mejores tiempo de cargas utilizando tuplas en vez de listas:

tupla = (1, 2 ,3 ,4 ,5)

–> A diferencia de las listas las tuplas se encierran en ().

IMPORTANTE Un objeto inmutable es un objeto que no puede cambiar.

EN PYTHON LAS LISTAS NO ES NECESARIO QUE LA PONGAS ENTRE “[ ]” python lo detecta y asume que es una lista pruebenlo…

Es ineficiente trabajar con listas en Python porque la listas son dinámicas, le podemos agregar y quitar elementos. Pero esto hace que Python requiera más memoria para poder mantener vivas a estas listas. Por esta razón es que nacen las Tuplas.

Las tuplas son un tipo de objeto especial al que vamos a llamar estático. La ventaja de usar tuplas es que cuando hacemos iteraciones, tendremos un reacción más rápida del programa que si usamos las listas. Las tuplas son la estructura de datos mas rapida que tenemos dentro de datos. El terminó técnico para referirnos a las tuplas es que son objetos inmutables. Cuando digan que un objeto es inmutable significa que este elemento no puede cambiar. Otro objeto inmutable son las strings

Iteración: La iteración es el acto de repetir un proceso, para generar una secuencia de resultados (posiblemente ilimitada), con el objetivo de acercarse a un propósito o resultado deseado. En el contexto de las matemáticas o la informática, la iteración (junto con la técnica relacionada de recursión) es un bloque de construcción estándar de algoritmos.

def tuplas():

    mi_tupla = (1, 2, 3, 4, 5)
    print(mi_tupla)


tuplas()

La diferencia entre las tuplas y las listas es que las listas son dinamicas (se les puede agregar, quitar, mover elementos) mientras que las tuplas son estaticas.
Al momento de hacer ciclos es mas recomendable usar tuplas ya que el codigo funciona mas veloz.

Mis apuntes:

Operación con listas:
suma_lista = nombre_lista + nombre_lista2
multi_lista = nombre_lista*3

Tuplas: tipo de objeto especial inmutabley ordenado. NO se puede agregar o eliminar elementos de una tupla. Estructura de datos que se muestra de forma rapida.
sintaxis: se representan escribiendo los elementos entre paréntesis y separados por comas.

tupla = (var1,var2,var3, ... , varn)

recorrer una tupla con ciclo for

for var in tupla:
    print(tupla)

slice a tupla:

tupla[<indice>:<indice2>] : muestra los elementos de la tupla desde <indice> hasta el valor anterior a <indice2>. El conteo de <indice> puede iniciar en 0, siendo el inicio de la lista.

tupla[:<indice>] : muestra los elementos de la tupla desde el inicio hasta el valor anterior a <indice>.

tupla[<indice>:<indice2>:<# pasos>] : muestra desde <indice> hasta el valor anterior a <indice2> con salteo de <# pasos>.

tupla[:] : indica mostrar todos los elementos de la tupla, desde inicio hasta final.

tupla[::- <indice>] : mostrara todos los elementos de la tupla, pero el - <indice> indica mostrar desde el ultimo elemento hasta inicio de esta. El conteo puede iniciar en -1, siendo el ultimo elemento de la tupla.

tupla[<indice>:- <indice2>] : muestra los elementos de la tupla desde el <indice> hasta el valor anterior a - <indice2>.

tupla[<indice>:<indice2>:- <# pasos>] : muestra los elementos de la tupla desde <indice> hasta el valor anterior a <indice2> con salteo de - <# pasos> desde el final hasta inicio de la tupla.    

inmutable: string, tupla
mutable: lista
dir(variable) : muestra las propiedades o métodos disponibles de la variable.

Hola les comento las diferentes formas de crear tuplas:

• Para crear una tupla vacía, usa paréntesis () o el constructor de la clase tuple() sin parámetros.
• Para crear una tupla con un único elemento: elem, o (elem, ). Observa que siempre se añade una coma.
• Para crear una tupla de varios elementos, sepáralos con comas: a, b, c o (a, b, c).
• Las tuplas también se pueden crear usando el constructor de la clase, tuple(iterable). En este caso, el constructor crea una tupla cuyos elementos son los mismos y están en el mismo orden que los ítems del iterable. El objeto iterable puede ser una secuencia, un contenedor que soporte la iteración o un objeto iterador.

Las tuplas a diferencia de las lista son INMUTABLES (No se pueden modificar, agregar o quitar elementos).

my_tuple = () >>>> Tupla vacía

my_tuple = (1, ‘dos’, True) >>>>> Tupla mixta

my_tuple = (1,) >>> tupla con valor unitario (FUNDAMENTAL LA COMA!!!)

my_other_tuple = (2,3,4)

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

x,y,z = my_tuple >>> x = 2, y = 3, z= 4 “”"

para poder hacer cambios en una tupla, se puede hacer así:

1. convertirmos la tupla en una lista
2. agregamos o quitamos el elemento
3. convertirmos la lista en una tupla

fruits = ("apple", "pear", "orange", "peach")

fruitToList = list(fruits)
fruitToList[0] = "berry"

fruits = tuple(fruitToList)

print(fruits)
print(type(fruits))

Las tuplas se podría decir que son como una constante, ¿no?
Una vez declarada no puedes modificar su valor/contenido.

Una tupla es una colección de objetos ordenados que encierra sus elementos con paréntesis () y los separa con comas. Las tuplas son muy similares a las listas, y pueden almacenar objetos de tipo distinto como enteros y strings entre otros. Sin embargo, al contrario que las listas, presentan la propiedad de inmutabilidad. Esto implica que los elementos de una tupla no pueden reasignarse.

# TUPLAS

# Son estructuras de datos INMUTABLES
# O sea que no se pueden modificar (ni agregar ni eliminar)
# Se puedn definir de nuevo

# Declarar una tupla
example = ('dato de la tupla 1', 'dato de la tupla 2')

# REASIGNAR UNA TUPLA
tupla = (1,2,3)
tupla_2 = (4,5,6)
tupla =+ tupla_2

Notas 📒

✏️ Tuplas

• Las tuplas ocupan menos espacio en memoria que las listas.
• Las tuplas son inmutables y con esto no se puede agregar, eliminar o modificar sus elementos.
• Se iteran de la misma maneara que las listas
• Se puede utilizar los operadores + y * con las tuplas

Información importante: Las listas son grupos de elementos dinámicos, es decir podemos agregar o eliminar elementos dentro de las listas. Las duplas son grupos de elementos estáticos, es decir, NO podemos usar los comandos de agregar o quitar elementos dentro de las tuplas.

Las tuplas usan mucho menos memoria, por eso son mas eficaces y rápidas. No son tan versátiles como las listas.

#LISTAS
#trabaja de forma dinámica
#ineficientes porque se puede cambiar
#consumen más recursos
#es más lento a nivel de procesamiento con los ciclos
#puedes modificar los elementos dentro de la lista

mi_lista=[1,2,3,4,5,6,7,8,9]

#TUPLAS
#trabajan de forma estática
#no puedes borrar elementos
#es más veloz a nivel de procesamiento con los ciclos
#no es mutable

mi_tupla=(1,2,3,4,5,6,7,8,9)

TUPLAS
Son un tipo de objeto estático, son INMUTABLES (no pueden cambiar los datos) en cambio las listas son dinámicas y son MUTABLES.
Utilizan los ()

• Las tuplas son la estructura de datos más rápidas que se tienen en Python.

Tuplas

Son como las listas, pero estáticas

• Permiten tener una ejecución más rápida en bucles for para recorrerlas
• Consumen mucha menos memoria
• Es la estructura de datos más rápida en Python
• Es inmutable, es decir no se le pueden agregar ni quitar elementos

Me ha sorprendido el principio de esta clase y ver lo tan flexible o dinamico que llega a ser Python, aunque hacer esto en JS tambien es sencillo con el spread operator pero eso de multiplicar un array o un string X veces si me sorprendio 😂

.

aaah no, ya no. Ya llegue a la parte donde dice que eso es ineficiente y en su lugar se usan las tuplas xd

Interesante la comparación entre listas y tuplas para entender mejor el concepto

Tupla = inmutable, no se pueden modificar
Lista = dinámicas, las puedes modificar

En Python las tuplas se declaran similar que las listas, se ingresa el nombre de la tupla y los datos a almacenar entre () ‘paréntesis’ separados por , “comas”. Lo que diferencia a las tuplas de las listas es que las tuplas no se pueden modificar una vez tienen valores declarados su tamaño es fijo.

Las tuplas al tener estas limitaciones son mas ‘ligeras’ que las listas, por lo que las tuplas pueden ser usadas en lugar de las listas y ahorrar memoria | recursos.

Al usar en módulo .pop en listas y pretender borrar el último indice no es necesario especificar el índice mismo, ya que por defecto ese módulo eliminará el ultimo objeto de la lista, Para el caso de los sets será el primer elemento el elemento removido.

          ------>Tuplas<--------

Tuplas es para ahorrar a python el esfuerzo de “manterner vivas a las listas, y eso se hace usando Tuplas” == "Son la estructura de datos mas rapida que tenemos disponible dentro de python."
Tuplas esta hecho con objetos estaticos. Por lo que no se puede agregar o quitar mas (INMUTABLE) objetos/ variables asi como las listas lo hacen.
Listas estan hechos con obetos dinamicos. (MUTABLE).

Al final facundo con las tuplas pueden usar esto: “for numero in mi_tupla:” enter y 4 espacios depues “print (nombre de la variable que quieras imprimir)” Y los objetos de pondran ordenados.

Tuplas: cuando usamos tuplas, python utiliza menos recursos para mantenerlas vivas en nuestro programa.
A diferencia de cuando usamos listas, ya que las listas al ser mutables python utiliza más recursos para poder estarlas modificando.

"La inmutabilidad, es simplemente la ausencia de métodos de mutación"

La diferencia entre lista y tupla es que a la lista se le puede quitar o agregar elementos, eso la hace mutable mientras que la tupla no se le pueden quitar ni agregar elementos, pero al momento de realizar procesos, es mas eficaz que una lista.

La lista se declara así:
lista = [variable, variable2, variable3, … n]
Y la tupla de la siguiente manera:
tupla = (variable, variable2, variable3 … n)

Las listas son variables (mutable).
Las tuplas son constantes (inmutable).

Excelente aporte para conocer la diferencia entre Listas y Tuplas. Poco a poco voy entendiendo la estructura de Python.

El profesor Facundo expone la idea de mutable e inmutable muy bien, dando ejemplos con una tupla a la que no le puede agregar ni quitar elementos que esta contiene; pero también explico que las listas por el contrario si son mutables y lo comprueba con ejemplos. Hasta acá todo muy bien, y yo por mi parte intente lo mismo que él, haciendo uso de la consola (lo ilustro a continuación):

¿Alguien que me pueda aclarar la confusión?

Tambien podemos desempacar las tupluas de la siguente manera:

>>> numeros = (1,2,3)
>>> x,y,z = numeros
>>> x
1
>>> y
2
>>> z
3
>>> 

Saludos.

A una tupla no se le puede agregar o quitar elementos. Pero si es posible recorrerla usando for.

Si ejecutamos

numeros.pop()

Sin indicar el índice del elemento que queremos sacar de la lista, Python entiende que se trata del último elemento de esta. 🐍

En cierto grado, es ineficiente trabajar con listas porque estas son mutables. Es decir, se pueden agregar o quitar datos a voluntad con el uso de métodos. Esto consume memoria. Las tuplas son una solución ante ello.
Tuplas -> objetos inmutables (en los que no se pueden usar métodos para modificaros).

Entonces, dada la definición de inmutabilidad también se puede hacer una analogía entre constantes y variables. Donde las constantes son inmutables a comparación de las variables que pueden ser modificadas.

La diferencia entre una tupla y una lista (Array en otros lenguajes) es que la tupla es inmutable y la lista es mutable. Cabe mencionar que con las listas puedes hacer operaciones y tiene métodos para manipular el contenido de la misma.

Tambien se pueden iterar ambos tipos de objetos, las listas y las tuplas, para que podamos accede a sus contenidos

Las listas son dinámicas se le pueden agregar elementos y eliminar eso hace que python el lenguaje por debajo necesite mas memoria para tener viva las listas
el tipo de dato nos ahorra el problema son: Las tuplas, son estáticas y sus elementos se ponen entre ()
no se les puede agregar ni borrar elementos
la ventaja de usar tublas si recorremos con el ciclo for es mas rápido a diferencia de las listas
Las tuplas son inmutables: ese elemento no puede cambiar al igual que una string

Tengo una pregunta: si quiero comparar una letra con cada uno de los valores guardados en una tupla, cómo le hago?

Las tuplas también le podemos hacer slicing

>>> tupla = (1, 2, 3, 4, 5)
>> tupla[::-1]
> (5, 4, 3, 2, 1)

supongo entonces que las variabales que almacenan datos son igual al tuplas, porque no encontre ninguna diferencia entre ellas en la practica, mas bien entre variables y listas, si hay diferencia.

Muy ineteresante la diferencia entre tupla y listas, en varios años de universidad y eso nunca me lo habian explicado de una manera tan simple

Excelente vídeo.
La diferencia en como escribir en el editor tuplas y listas es que las primeras van en paréntesis y las últimas van en corchetes. Las primeras son estáticas, las últimas son dinámicas. Las primeras no se pueden cambiar, a las últimas si se les puede eliminar y/o agregar datos.

La principal diferencia entre las listas y las tuplas de Python, y el motivo por el que muchos usuarios solamente utilizar listas, es que las listas son mutables mientras que las tuplas no lo son.

ósea le podemos cambiar el contenido a las listas pero a las tuplas no.

martes, 20 de julio de 2021
23:26

¿Qué ES UNA TUPLA?
Son conjuntpo imutable de valores ordenados
-se le puede aplicar la siguientes funciones
Len
Max
Min
Sum
Any
All
sorted
¿Qué son las listas ?
Conjunto dinamico de valores ordenados

Como se declara una tupla?
Variable=(elemto1,elemento2,…….;elemento n)

APUNTE:

#Entendiendo cómo funcionan las tuplas

numeros = [1, 2, 3, 4, 5]
numeros
[1, 2, 3, 4, 5]
numeros.append('Hola')
numeros
[1, 2, 3, 4, 5, 'Hola']
numeros.pop(5)
'Hola'
numeros
[1, 2, 3, 4, 5]
'Hola' + ' ' + 'Mundo'
'Hola Mundo'
numeros2 = [6, 7, 8, 9]
numeros
[1, 2, 3, 4, 5]
numeros2
[6, 7, 8, 9]
lista_final = numeros + numeros2
lista_final
[1, 2, 3, 4, 5, 6, 7, 8, 9]
numeros * 5
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
mi_tupla = (1, 2, 3, 4, 5)
mi_tupla
(1, 2, 3, 4, 5)
#Aqui viene la diferencia con las lista, las tuplas:
mi_tupla.append(5)
#Error, 
# ya que la tuplas son un tipo de objeto estatico
# las listas son un tipo de objeto dinamico a 
# las cuales le podemos agregar y borrar 
# elementos a la tuplas no. Entonces cual es 
# la ventaja de usar tuplas y no lista, cuando 
# hacemos iteraciones(recoremos una lista con 
# un ciclo for podemos tener un ejecución más 
# rápida)
mi_tupla.pop(2)
#Error
# Pero si hacemos un for
for numero in mi_tupla:
...    print(numero)
...
1
2
3
4
5
# La diferencias con la listas es que el ciclo
# for funciona de una mejor manera con las tuplas.
# Las tuplas son la estructura más rapida que
# nosotros tenemos disponible dentro de python,
#  la diferencia con las listas es que las
#  podemos  modificar, las tuplas son inmutaples
# otro elemento inmutaples son los strings

Si alguien quiere borrar la terminal sin la necesidad de salirte con exit(), puedes usar lo siguiente:

import os
os.system('cls')

Según lo que entendí.

Una tupla es una lista constante, no se puede modificar, por ejemplo:

dias_semana = ("Lunes","Martes","Miercoles","Jueves","Viernes","Sabado","Domingo")

Los días de la semana nunca van a cambiar.
Una lista si puede modificar su contenido, por ejemplo una lista de oficios diarios

oficios_diarios = ["Leer", "Comer un helado","Estudiar en PLATZI", "Caminar"] 

Se le puede añadir o eliminar oficios a la lista.

manejo de tuplas

que es un tipo de listado que no se puede modificar en el tiempo como es en el caso de la listas dinamicas que se puede agregar o quitar elementos

La documentación oficial de Python dice que las tuplas se usan cuando los datos a ser almacenados en ellas, serán INMUTABLES, es decir no cambiaran en el tiempo

Gente, también pueden hacer esto con las listas:

lista = [1, 2, 3, 4], [5, 6 ,7 ,8], [9, 10 ,11, 12], [13, 14, 15 ,16]

Lo intenté antes de empezar esta clase y funcionó.

#tuplas: listas unidas
numeros = [1,2,3,4]

numeros2= [4,5,6,7]
listafinal = numeros + numeros2
listafinal
[1, 2, 3, 4, 4, 5, 6, 7]

las listas son utiles por que son dinamicas

las listas implican mucha memoria eso se soluciona con tuplas

recorrer for una lista es mas rapida con una tupla

es rapida por que no es dinamica: INMUTABLE

mi_tupla = (1,2,3,4,5)
mi_tupla.append(5) #genera error
for numero in mi_tupla:
print (numero)

mi_tupla = mi_tupla * 5
mi_tupla
(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

de esta manera si se “agregan” ???

Es la primera vez que escucho el concepto de tupla. Sin embargo, de la manera en como explica el profesor me quedo muy claro.

Oh, recuerdo que antes había escuchado ese término y no entendía la diferencia entre tuplas y listas c:

tuplas mayor velocidad, pero menos dinamismo

entonces las tuplas para ver si lo entendi es que para ahorrar memoria y se usa cuando ya no se van a agregar mas datos

con solo poner numeros.pop(-1) elimina el último dato de la lista

La verdad, para hacer cambios en tuplas solo basta con convertirlo en una lista (se usa la función list(la tupla escogida)) para hacer dicha modificación y luego convertirlo en una tupla nuevamente (se usa la función tuple(lista elegida)).

Pudiera decirse que utilizaríamos ciertas duplas para definir valores constantes & las listas valores que son utilizados como estructuras de datos.

Me queda muy claro cual es la diferencia

Uso de tuplas en Python y apuntes de clase 😃

No me dio tiempo de comentar en el video anterior, he usado listas para depurar grandes cantidades de información, estoy trabajando con un diccionario de idiomas americanos nativos, que tiene 11 mil entradas, y estoy realizando aplicaciones varias sobre este material, las listas y otros tipos de datos de python me han sido de gran ayuda. PS: soy la única persona en América y quizás del mundo, que está dedicado al rescate informático de estos idiomas ancestrales.

https://docs.python.org/es/3/tutorial/datastructures.html?highlight=tuplas#tuples-and-sequences

mi_tupla

• Las tuplas al igual que las listas soportan diferentes operaciones como por ejemplo, la suma y la multiplicación. Un ejemplo, para que veas lo sencillo que resulta operar con tuplas,

>>> print((1, 2, 3) + (4, 5, 6))
(1, 2, 3, 4, 5, 6)
>>> print(("Hola",) * 2)
("Hola", "Hola")

es increible como pase meses en otro curso (fuera de platzi) sin saber la diferencia, y vos lo explicas en 6 minutos, muchas graciaaas

Si quisieras agregar una(s) letra(s) a un string deberías crear un nuevo string el cual sería la concatenación del primer string más la(s) letra(s) que deseas agregar.

Las tuplas son a las listas lo que las constantes a las variables.

Tuplas: Son un tipo de objeto estatico dentro de python a diferencia de las listas que son un objeto dinamico, es decir son un tipo de dato que su valor no va a cambiar, al igual que cuando creamos una variable constante. Y al momento de realizar una iteracion en el codigo del proyecto tendremos mejores tiempo de cargas utilizando tuplas en vez de listas:

Estructura de tuplas:

es_tupla = (1, 2, 3, 4)

A diferencia de las listas las tuplas se encierran en ().
IMPORTANTE Un objeto inmutable es un objeto que no puede cambiar.

<aside>
💡 los strings (cadenas de caracteres) al igual que las tuplas, también son considerados por python como inmutables.

La única manera de modificar el contenido de una variable de tipo string, es reasignando completamente su valor. No es posible realizar cambios individuales en un índice particular.

</aside>

Comparto mis apuntes de la clase:

Diferencias entre lista y tuplas

• La diferencia clave entre estas dos, es que mientras las tuplas son objetos inmutables (que no se pueden modificar son estaticas) las listas son mutables (osea que pueden ser modificadas).
• Cuando vemos la eficiencia en cuanto a tiempo, vemos que las tuplas tienen una ventaja sobre las listas especialmente cuando buscar un valor es considerado
• Si tenesmos data que no esta hecha para ser modificada en primer lugar, tu deberias escoger las tuplas sobre las listas.

Información resumida de esta clase
#EstudiantesDePlatzi

• Si puedo hacer operaciones con las listas

• Las listas son dinámicas, es decir, puedo agregar y borrar elementos. Esto lo hace poco eficiente en Python

• Las tuplas funcionan con estos corchetes ( ) y son estáticas, es decir, no puedo agregar o borrar elementos

• Las tuplas son estructuras de datos más rápidas que las listas

No entendí por qué las strings son inmutables:( Probe esto y cambio ¿Alguién me explica porfi?

Progreso ♥

Las tuplas sin inmutables, esto quiere decir que no pueden cambiar, esta es la diferencia con las listas.

Las tuplas son estructuras de datos estáticas que no vamos a poder modificar, lo que nos permiten es que al ejecutar código se gaste menos memoria.
Por otro lado recordar que puedo hacer operaciones entre listas.

• numeros=[1,2,3,4,5]

numeros2=[6,7,8,9]
numero_final=numeros+numeros2
numero_final
[1, 2, 3, 4, 5, 6, 7, 8, 9]

numeros * 5
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

mi_tupla=(1,2,3,4,5)
mi_tupla
(1, 2, 3, 4, 5)

mi_tupla.append(5)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
AttributeError: ‘tuple’ object has no attribute ‘append’

mi_tupla.pop(2)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
AttributeError: ‘tuple’ object has no attribute ‘pop’

for numero in mi_tupla:
… print(numero)
…
1
2
3
4
5

El nombre que le des al for, es indiferente. Si escribes for letra in mi_tupla: y print(letra), también te muestra los números del 1 al 5. Lo que está claro es que es una buena práxis llamar a cada cosa por su nombre.

¿Por qué me sale el texto “El sistema no puede encontrar el archivo especificado” cuando termina de correr mi programa?

Indica qué posición del arreglo quieres quitar ==> 0
[‘Hola’, 4.5, True]
El sistema no puede encontrar el archivo especificado.

C:\Users\frive\OneDrive\Escritorio\código_python
λ

Ejemplo de la clase

def run():

arreglo = [0, "texto", 3.14159]
print(arreglo)
print()

entero = int(input("Escribe un número entero ==> "))
arreglo[0] = entero        # arreglo.append(entero)
print(arreglo)
print()

cadena = input("Escribe una palabra ==> ")
arreglo[1] = cadena
print(arreglo)
print()

flotante = float(input("Escribe un número decimal ==> "))
arreglo[2] = flotante
print(arreglo)
print()

logico = bool(input("Escribe un valor boleano, True o False ==> "))
arreglo.append(logico)  #Incrementa una variable a un arreglo
print(arreglo)
print()


print(arreglo[0])
print(arreglo[1])
print(arreglo[2])
print(arreglo[3])
print(arreglo[::-1])
print()

print("Prueba del for en el arreglo")
for elemento in arreglo:
    print(elemento)

print()
posicion = int(input("Indica qué posición del arreglo quieres quitar ==> "))
arreglo.pop(posicion)
print(arreglo)

if name == “main”:
run()

Tuplas:
:
Las tuplas son listas inmutables que no se pueden modificar. No se pueden modificar ni editar elementos, ni añadir ni quitar.
Para hacer una tupla van con parentesis.
:
Tupla = (1,2,3,4,5,6,7,8,9)
:
Print(Tupla[0])
:
Arriba estoy haciendo una llamada a que me muestre el elemento del indice 0
:
:
:
Básicamente la única diferencia que hay entre listas y tuplas, es que las listas: se pueden modificar pero por eso mismo, ocupan mas espacio en memoria. en cambio las tuplas: como no se pueden modificar, la computadora accede a ellas de manera mas rápida al iterar, pues esta no se puede modificar.

De la forma en la que yo lo entiendo seria que las tuplas no son modificables, mientras que las listas son completamente modificables. Me corrigen si estoy errado.