En esta guía, aprenderá las similitudes y diferencias entre las tuplas y listas de Python. También comprenderá cuándo debe usar una tupla.
La lista y las tuplas son estructuras de datos integradas en Python. Se pueden utilizar para almacenar una colección de elementos.
Desde la compatibilidad con la indexación y el corte hasta la contención de tipos de datos heterogéneos, las tuplas y las listas pueden parecer tener una funcionalidad similar. Por lo tanto, comprender las similitudes y diferencias entre los dos puede ayudarlo a decidir qué estructura de datos usar.
Vamos a empezar.
👩🏽💻 Puede iniciar un REPL de Python y seguir este tutorial. También puede usar el editor Python en línea de kirukiru.es para codificar.
Tabla de contenido
Python Tuple vs List: ¿Cuáles son las similitudes?
Empecemos aprendiendo las similitudes entre listas y tuplas. Para facilitar un mejor aprendizaje, presentamos ejemplos tanto de listas como de tuplas.
#1. Iterables de Python
En Python, las listas se encierran entre un par de corchetes, mientras que las tuplas se encierran entre paréntesis. También puede crear una tupla como un conjunto de valores separados por comas, sin paréntesis.
Ambos son iterables; para que pueda recorrerlos usando un bucle for.
La siguiente celda de código muestra cómo iterar a través de una lista.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Como se explica a continuación, también puede iterar a través de una tupla usando un bucle
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Compatibilidad con la creación a partir de otras secuencias
La siguiente similitud entre listas y tuplas es que se pueden crear a partir de secuencias existentes, como cadenas.
sample_str = "Coding!"
La siguiente celda de código muestra cómo list(string) devuelve una lista, cuyos elementos de lista son los caracteres de la cadena.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
De manera similar, se puede crear una tupla a partir de una cadena u otra secuencia usando tupla(secuencia). La siguiente celda de código muestra cómo puede hacerlo.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Compatibilidad con la indexación y el corte
Python admite la indexación cero en la que el primer elemento está en el índice cero, el segundo en el índice uno, y así sucesivamente. Python también admite la indexación negativa, donde el último elemento está en el índice -1, el penúltimo elemento está en el índice -2, y así sucesivamente.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
El elemento en el índice -2 es el penúltimo elemento, ‘g’.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Puede usar el corte cuando desee trabajar con una pequeña sección de la lista o tupla. lista[start:end] devuelve una porción de la lista que comienza en el inicio del índice y se extiende hasta el final: 1. El valor predeterminado para un inicio es 0, y el final es el último elemento en el iterable.
Puede dividir tuplas usando la misma sintaxis. Vamos a crear porciones de la lista y la tupla que creamos anteriormente.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Además de los valores inicial y final, también puede especificar un valor de paso. tuple(start:end:step) devuelve una porción de la tupla desde el principio hasta el final – 1, en pasos de paso.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Aquí, establecemos el valor del paso en 2. Entonces, el segmento contiene cada segundo elemento.
#4. Colecciones de múltiples tipos de datos
En los ejemplos que hemos considerado, todos los elementos de la lista y las tuplas eran del mismo tipo de datos.
Sin embargo, puede almacenar valores de diferentes tipos de datos dentro de una sola lista o una tupla.
El fragmento de código debajo de student_list contiene el nombre de un estudiante como una cadena, la edad como un número entero y las marcas aseguradas como un flotante.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Podemos pensar en un ejemplo similar para una tupla.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Soporte para pruebas de membresía
Tanto las listas como las tuplas le permiten realizar pruebas de membresía para detectar la presencia de ciertos elementos. Si desea verificar si un elemento específico está presente en una lista o una tupla, puede usar el operador in.
El elemento de expresión en iterable se evalúa como True si el iterable contiene el elemento; de lo contrario, Falso.
"Alex" in student_list # False "Jane" in student_tuple # True
Hasta ahora, has aprendido las similitudes entre listas y tuplas en Python. A continuación, aprendamos las diferencias clave entre las dos estructuras de datos.
Python Tuple vs List: ¿Cuáles son las diferencias?
#1. Mutabilidad de listas e inmutabilidad de tuplas en Python
La diferencia más crucial entre una lista y una tupla en Python es que una tupla es inmutable. Esto significa que no puede modificar una tupla en su lugar.
▶️ Aquí tienes un ejemplo.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Una lista es una estructura de datos mutable, por lo que podemos modificar la lista cambiando un elemento en un índice específico, como en la siguiente celda de código.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Listas de longitud variable frente a tuplas de longitud fija
La lista de Python es una estructura de datos de longitud variable.
Puedes hacer lo siguiente:
- Agregar un elemento al final de la lista
- Agregar elementos de otra lista al final de la lista actual
- Eliminar elementos en un índice específico de la lista
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶️ La salida del fragmento de código anterior.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Las tuplas son estructuras de datos de longitud fija. Por lo tanto, no puede agregar o eliminar elementos de una tupla existente. Pero puede redefinir la tupla para que contenga diferentes elementos.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Tamaño en memoria
Ahora construiremos sobre lo que aprendimos en la sección anterior: la lista es una estructura de datos de longitud variable.
Cuando define la lista inicialmente, se le asigna un tamaño específico en la memoria. Ahora, cuando modifica una lista usando los métodos append() o extend(), se debe asignar memoria adicional para almacenar los elementos agregados. Esta asignación casi siempre se hace más que la cantidad de elementos que agrega.
Por lo tanto, es necesario realizar un seguimiento de la cantidad de elementos en la lista y el espacio asignado. Además, como las listas son de longitud variable, hay un puntero que apunta a la dirección de los elementos de la lista. Como resultado, las listas de longitud k ocupan más memoria que una tupla con los mismos k elementos.
Aquí hay una ilustración simple.
Puede usar el método getsizeof() del módulo sys incorporado en un objeto de Python para obtener el tamaño de un objeto en la memoria.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
Una lista ocupa más memoria que una tupla para el mismo número y valor de elementos, como se verifica en el resultado a continuación.
# Output Size of list:104 Size of tuple:88
¿Cuándo debería usar una tupla de Python?
Por las diferencias y similitudes entre las listas y las tuplas de Python, sabe que si necesita una colección mutable, debe usar una lista.
Pero, ¿cuándo debería usar una tupla en su lugar?
Vamos a repasar eso en esta sección.
#1. Colección de solo lectura
Siempre que desee que una colección sea inmutable, debe definirla como una tupla. Supongamos que color = (243,55,103) una tupla que contiene los valores RGB correspondientes a un tono de color. Definir el color como una tupla garantiza que no se pueda modificar.
En esencia, cuando necesite que una colección sea de solo lectura: los valores no deben modificarse durante el programa, debe considerar usar una tupla. Esto evitará la modificación no intencionada de los valores.
#2. Claves del diccionario
Por ejemplo, crea un diccionario utilizando los elementos de la lista key_list como claves. Puede usar el método dict.fromkeys() para crear un diccionario a partir de una lista.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Suponga que modifica la lista para que contenga ‘D’ como primer elemento (índice 0), antes de crear el diccionario.
Ahora, ¿qué sucede con la tecla del diccionario ‘A’?
Si intenta crear un diccionario a partir de key_list y accede al valor correspondiente a la clave ‘A’, se encontrará con un KeyError.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
Las claves de un diccionario deben ser únicas. Por lo tanto, no puede tener una segunda ‘D’ como clave.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Si, en cambio, usa una tupla, dicha modificación es imposible y es menos probable que se produzcan errores. Por lo tanto, debería preferir crear un diccionario utilizando los elementos de una tupla como claves.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Argumentos de función
La inmutabilidad de las tuplas también las hace adecuadas para pasarlas como argumentos de función.
Considere la siguiente función find_volume() que devuelve el volumen de un paralelepípedo dadas las dimensiones: largo, ancho y alto.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Supongamos que estas dimensiones están disponibles en una lista llamada dimensiones. La llamada a find_volume() con dimensiones como argumento devuelve el volumen.
dimensions = [2,8,5] find_volume(dimensions) 80
Siempre puede cambiar las dimensiones almacenadas en una lista.
dimensions = [20,8,5] find_volume(dimensions) 800
Sin embargo, a veces necesitará que los valores permanezcan constantes y resistan la modificación. Ahí es cuando debería considerar almacenar los argumentos como una tupla y usarlos en la llamada a la función.
#4. Valores de retorno de funciones
En Python, encontrará tuplas en los valores de retorno de las funciones. Cuando devuelve varios valores de una función, Python los devuelve implícitamente como una tupla.
Considere la siguiente función return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Toma un número num como argumento
- Devuelve la lista de números pares en el intervalo. [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Como hay dos elementos en la tupla, puede descomprimirlos en dos variables, como se muestra a continuación.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Conclusión
Espero que este tutorial proporcione una comparación completa de Python tuple vs list.
Terminemos el tutorial con un breve resumen:
- La lista y las tuplas son estructuras de datos integradas en Python.
- Similitudes: iterables, soporte para indexación, división, diferentes tipos de datos y operador para pruebas de membresía.
- Diferencia clave: las listas son mutables y las tuplas son inmutables.
- Otras diferencias: Longitud fija de tuplas y longitud variable de listas, menor tamaño en memoria de tuplas.
- ¿Cuándo deberías usar una tupla? Para colecciones inmutables, claves de diccionario y argumentos de funciones.
A continuación, consulte los proyectos de Python para practicar y aprender. O aprenda métodos para eliminar elementos duplicados de las listas de Python. ¡Feliz aprendizaje! entonces, ¡feliz codificación! 👩🏽💻