Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso Básico de Python

Curso Básico de Python

Facundo García Martoni

Facundo García Martoni

Entendiendo cómo funcionan las tuplas

29/32
Recursos

Las tuplas son estructuras de datos inmutables. Es decir, no puedes modificar una tupla a agregando o quitando un valor. Lo único que puedes hacer es definir de nuevo esa tupla a. Los objetos inmutables (como los strings) son tipos de datos para Python que apuntan a un lugar específico en memoria y que su contenido no puede ser cambiado. Al cambiar el contenido predefiniendo el contenido de la variable a, entonces cambiará su posición en memoria.

Cómo trabajar con tuplas en Python

Declarar tupla

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

Generar una tupla de 1 solo valor

La , es obligatoria.

mi_tupla = (1,)

Acceder a un índice 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

Métodos para trabajar con tuplas

Usando el ejemplo:

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

Encontraremos los siguientes métodos:

  • mi_tupla.count(1)
    Devolverá 3, ya que el número 1 aparece 3 veces en la tupla.
  • mi_tupla.index(3)
    Devolverá 5, índice de la primera instancia donde se encuentra un elemento.
  • mi_tupla.index(1)
    Devolverá 0
    mi_tupla.index(2)
    Devolverá 3.

Aporte creado por: Rusbel Bermúdez.

Aportes 203

Preguntas 27

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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.

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

Listas

Sintaxis Descripción
[] Guardar diferentes tipos de variables
var_obj.append(elem) Agregar el valor al final de la lista
var_obj.pop(index) Eliminar el valor indicado de la lista
var_obj + var_obj2 Combinar listas
var_obj * n Nos repite la lista “n” veces
>>> 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'

Para complementar, les comparto el siguiente enlace:

El Libro de Python

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.

Differences between lists and tuples

Lists Tuples
Mutable Immutable
More memory Low memory
---- Faster process

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)

<h1>desenpaquetar</h1>

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

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.

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

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)
def tuplas():

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


tuplas()

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

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

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.

😃

Las tuplas son mas rapidas que las listas porque contienen valores de solo lectura.

¡Excelente clase!

Yo al principio pensaba que las tuplas eran como matrices (Lista de listas), pero en cambio, son conjuntos de elementos inmutables, a diferencia de las listas que son dinámicas, lo que hace que sean más eficientes y requieran de menos recursos para ejecutarse, ya que no se les puede agregar ni quitar elementos

Las tuplas son inmutables. Los string también.

las tuplas a diferencia de las listas son un tipo de elemento estático

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.

(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

Muy clara la explicación de la diferencia entre las tuplas y las listas, en resumen:

Las tuplas: Es una estructura de datos inmutable (no puede cambiar)
Las listas: Es una estructura de datos mutable (puede recibir modificaciones)

buen curso

tulas

Es importante ahorrar memoria siempre que podamos con nuestro código.

Duplas son la estructura de datos mas rapida que disponemos en python.

Las listas son dinamicas y a veces trabajar con ellas son ineficientes.

Gracias!

def run():
    my_tuple = (1, 2, 3, 4) # tuples cannot be modified as lists
    print(my_tuple)

if __name__ == '__main__':
    run()

Que excelente explicacion sobre la diferencia entre listas y tuplas, gracias Facundo

Las estructuras de datos son un tema muy interesante

las tuplas son constanstes y las listas varian para los que se preguntan la diferencia

muy clara la diferencia!!! gran profesor

🤖🤖🤖

las tuplas básicamente las usas cuando tienes valores que no vas a modificar en tu programa, INMUTABLES, por ejemplo puedes crear una tupla para las opciones de un menu de tu programa o si estas haciendo un calendario puedes crear una tupla para los dias de la semana que es algo que no cambiara.

Listas = dinamicas
Tuplas = estaticas
.
Ventajas?

  • Iteraciones mas rapidas con tuplas que con listas
  • Inmutables

También podemos reasignarle valores:

mi_tupla
#(1, 2, 3, 4)
mi_tupla = mi_tupla + (5,6,7)
#(1, 2, 3, 4, 5, 6, 7)

Las tuplas son elementos estáticos, es decir, una vez creado no pueden ser modificados. La ventaja de las tuplas es que cuando vayan a ser utilizadas en el código serán mucho más eficientes que las listas y el programa podrá correr más rapido.

Ejemplo de una lista convertida en tupla:

lista=[1,2,3.4,“Hola”, True]
tupla=tuple(lista)
print(tupla)

(1,2,3.4,“Hola”, True)

Muy buena explicación!

Excelente profesor Facundo

buen video

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

Buena clase!