Original article: Python Tuple VS List – What is the Difference?

Tuplas (Tuple) y listas (List) son dos de los cuatro tipos de datos incorporados que puedes usar en Python para almacenar colecciones de datos. Los otros dos serían conjuntos (Set) y diccionarios (Dictionary).

Ambos son muy útiles y pueden parecer similares tras un primer vistazo. Pero tienen diferencias significativas y cada uno de ellos será más útil según el caso.

En este artículo vamos a dar una visión general de cómo funcionan las tuplas y las listas. Hablaremos acerca de sus características y sus casos de uso, y mostraré sus parecidos y diferencias.

Puedes probar los códigos de ejemplo mostrados en el artículo usando la shell interactiva de Python, la cual tienes disponible en tu máquina una vez instalado Python.

¡Comencemos!

¿Qué son tuplas y listas en Python?

Tuplas y Listas son estructuras de datos incorporadas en Python.

Son contenedores para el almacenamiento de una colección ordenada de uno o más elementos, accesibles mediante indexación.

Una tupla pertence a la clase 'tuple',<class 'tuple'>, mientras que una lista pertenece a la clase 'list', <class 'list'> .

Digamos que has creado una tupla llamada mi_tupla. Puedes comprobar su tipo de la siguiente manera:

>>>type(mi_tupla)

#output
<class 'tuple'>

Esto es particularmente útil para depuración.

Veamos ahora algunas otras similitudes entre tuplas y listas.

Similitudes entre tuplas y listas en Python

Como ya he mencionado anteriormente, tuplas y listas son muy similares, y comparten ciertas características que veremos a continuación.

Tuplas y listas pueden almacenar múltiples elementos bajo una única variable

Tanto las tuplas como las listas o bien pueden estar vacías o bien pueden contener uno o incluso múltiples elementos bajo una única variable.

La única diferencia radica en la sintaxis: las tuplas se crean rodeando los elementos que va a contener mediante paréntesis, (), mientras que las listas se crean usando corchetes,[].

Para crear una tupla vacía, puedes usar solo los paréntesis,(), o bien el método constructor tuple().

>>>type(())
<class 'tuple'>

>>>mi_tupla = ()

>>>type(mi_tupla)
<class 'tuple'>

#or..


>>>mi_tupla = tuple()

>>>type(mi_tupla)
<class 'tuple'>

Para crear una lista vacía puedes usar simplemente los corchetes o llamar al método constructor list().

>>>type([])
<class 'list'>


>>>mi_lista = []

#or..

>>>mi_lista = list()

Cuando estemos creando una tupla con solo un elemento, no hay que olvidarse de añadir una coma al final.

>>>edad = (28,)

Si estás usando el método tuple(), serán necesarios dobles paréntesis.

>>>edad = tuple((28,))

>>>type(edad)
<class 'tuple'>

Si no añades la coma al final, Python no lo reconocerá como una tupla.

>>>edad = (28)

>>>type(edad)
<class 'int'>

>>>edad = tuple((28))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Se pueden crear tuplas de uno o más elementos sin utilizar los paréntesis (ojo, con el método, tuple() sí son necesarios):

>>> mi_tupla = 'python',  # <-- obsérvese la coma final.
>>> type(mi_tupla)
<class 'tuple'>

>>> otra_tupla = 1, 2, 3  # <-- aquí no es necesaria la coma.
>>> type(otra_tupla)
<class 'tuple'>

Al crear una lista con solo un elemento, no es necesario añadir la coma final.

>>> edad = [28]

>>> type(edad)
<class 'list'>

Los elementos almacenados son generalmente de naturaleza similar y están relacionados unos con otros de alguna manera.

Puedes crear una tupla o una lista que contenga sencillamente una secuencia de cadenas, de enteros o de valores Booleanos, estando los elementos de la secuencia separados por comas.

Se puede crear una tupla o una lista que contenga una mezcla de diferentes tipos de datos.

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False]

#or..

>>>mi_informacion = list(("Dionysia",27,True,"Lemonaki",7,"Python",False))

print(mi_informacion)
['Dionysia', 27, True, 'Lemonaki', 7, 'Python', False]

Listas y tuplas pueden contener elementos duplicados, apareciendo múltiples veces.

>>>informacion = ("Jimmy",50,True,"Kate",50)

>>>print(informacion)
('Jimmy', 50, True, 'Kate', 50)

or..

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27]

Si te olvidas de las comas, obtendrás un error:

>>>informacion = ("Jimmy" 50,True,"Kate",50)
File "<stdin>", line 1
    >>>informacion = ("Jimmy" 50,True,"Kate",50)
    ^
SyntaxError: invalid syntax
>>>my_informacion = ["Dionysia" 28,True,"Lemonaki",7,"Python",False]
 File "<stdin>", line 1
    my_informacion = ["Dionysia" 28,True,"Lemonaki",7,"Python",False]
                                 ^
SyntaxError: invalid syntax

Para comprobar la longitud y determinar cuantos elementos hay en la tupla o en la lista, habrá que hacer uso del método len() .

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27]

>>>len(mi_informacion)
7

Tuplas y Listas en Python soportan desempaquetado

Esencialmente, cuando se crea una tupla o una lista, varios valores son 'empaquetados' en una única variable, como ya he mencionado anteriormente.

>>>front_end = ("html","css","javascript")

Esos valores puede ser 'desempaquetados' y asignados a variables individuales.

>>>front_end = ("html","css","javascript")

>>>contenido,estilismo,interactividad = front_end

>>>contenido
'html'

>>>estilismo
'css'

>>>interactividad
'javascript'

Hay que asegurarse de que el número de variables que creas es exactamente el mismo que la cantidad de valores de la tupla/lista, de otro modo Python lanzará un error:

>>>front_end = ("html","css","javascript")

>>>contenido,estilismo = front_end
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)


#or..


>>>front_end = ("html","css","javascript")

>>>contenido,estilismo,interactividad,datos =  front_end
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)

Se puede acceder a los elementos por su índice tanto en tuplas como en listas

Como he mencionado anteriormente, tuplas y listas son una colección ordenada de elementos.

El orden es establecido e inmutable, siendo preservado durante toda la vida del programa.

El orden en que se especifican los elementos será siempre el mismo desde el momento en que son creados.

Cada valor en una tupla o una lista tiene un identificador único, su índice.

Cada elemento de una tupla/lista puede ser accedido haciendo referencia a su índice.

La indexación en Python (y en muchos otros lenguajes de programación y en Informática en general) comienza en 0.

De modo que el primer elemento tiene índice 0, el segundo tiene índice 1, y así sucesivamente.

Para acceder a un elemento, escribe el nombre de la tupla/lista y a continuación el índice del elemento entre corchetes.

>>>nombres = ("Jimmy","Timmy","John","Kate")

>>>nombres[2]
'John'

O bien:

>>>lenguages_de_programacion = ["Python","JavaScript","Java","C"]

>>>lenguages_de_programacion[0]
'Python'

>>>lenguages_de_programacion[1]
'JavaScript'

Bien, ya hemos visto en qué son similares, veamos ahora en qué difieren tuplas y listas.

Diferencias entre tuplas y listas en Python

Las Tuplas son inmutables, mientras que las Listas son mutables

Las tuplas en Python son inmutables, lo que significa que una vez creada una tupla, sus elementos no pueden cambiar.

Las tuplas no pueden ser alteradas.

Si intentas cambiar el valor de uno de sus elementos, obtendrás un error:

>>>nombres = ("Jimmy","Timmy","John","Kate")

>>>nombres[2] = "Kelly"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

No puedes añadir, reemplazar, reasignar o eliminar ningún elemento ya que las tuplas no pueden cambiar su configuración.

Esto implica que las tuplas tienen longitud fija. Su longitud nunca cambia a lo largo del ciclo de vida del programa.

Cuando usar tuplas

Las tuplas son una excelente opción si lo que quieres es que los datos de tu colección sean de solo lectura, que nunca cambien y se mantengan constantes. Tienen la capacidad de garantizar que los datos que contienen nunnca serán alterados.

Las tuplas pueden utilizarse como claves en un diccionario siempre que contengan tipos inmutables (cadenas, números u otras tuplas). Una lista, al ser mutable, no puede utilizarse para este fin.

Cuando usar listas

Por otro lado, las listas pueden ser fácilmente modificadas, ya que son mutables.

Se puede añadir elementos, eliminarlos, cambiarlos de posición o intercambiar unos por otros.

Las listas son útiles si lo que quieres es que tus datos sean flexibles, que puedan ser modificados cuando sea necesario.

Las listas soportan una variedad de métodos incorporados de Python que llevan a cabo ciertas operaciones sobre ellas, operaciones no soportadas por la tuplas.

Todo ello implica que la longitud, el tamaño de una lista pueda variar durante el ciclo de vida del programa.

Veamos ahora algunas operaciones sencillas que modifican una lista.

Como actualizar listas en Python

Ya que las listas son mutables, necesitarás conocer algunas de las formas básicas de actualizar los datos contenidos en una lista.

Como actualizar un elemento en una lista

Para actualizar un elemento en particular, hacemos referencia a su índice entre corchetes y asignamos el nuevo valor.

# sintaxis general
>>>nombre_lista[indice] = nuevo_valor

>>>lenguajes_de_programacion = ["Python","JavaScript","Java","C"]
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguajes_de_programacion[2] = "C++"
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'C++', 'C']

Como añadir elementos a una lista

Hay varios métodos incorporados en Python para añadir elementos a una lista.

El método .append() añade un elemento nuevo al final de la lista.

# sintaxis general
>>>nombre_lista.append(elemento)

>>>lenguajes_de_programacion = ["Python","JavaScript","Java","C"]
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguajes_de_programacion.append("C++")

>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C', 'C++']

Para añadir el elemento en una posición determinada, usa el método  .insert().

Este método inserta el elemento en la posición dada. El resto de elementos de la lista que van después del elemento que se quiere insertar, son desplazados una posición hacia la derecha.

# sintaxis general
>>>nombre_lista.insert(index,item)

>>>nombres = ["Cody","Dillan","James","Nick"]
>>>print(names)
['Cody', 'Dillan', 'James', 'Nick']


>>>nombres.insert(0,"Stephanie")

>>>print(nombres)
['Stephanie', 'Cody', 'Dillan', 'James', 'Nick']

Si lo que se necesita es añadir más de un elemento, haremos uso del método .extend().

Este método añade un iterable al final de la lista. Por ejemplo, se puede añadir una lista al final de una lista ya existente.

# sintaxis general
>>>nombre_lista.extend(iterable)

>>>lenguajes_de_programacion = ["Python","JavaScript"]
>>>mas_lenguajes_de_programacion = ["Java","C"]

# añadir mas_lenguajes_de_programacion a lenguajes_de_programacion
>>>lenguajes_de_programacion.extend(mas_lenguajes_de_programacion) 

>>>print(programming_languages)
['Python', 'JavaScript', 'Java', 'C']

Como eliminar elementos de una lista

Hay dos métodos incorporados para eliminar elementos de una lista.

Uno de ellos es el método .remove(), que elimina la primera instancia del elemento que se le proporciona como argumento.

# sintaxis general
>>>nombre_lista.remove(elemento)

>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]
>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguaje_de_programacion.remove("Java")
>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'C']

# elimina solo la primera ocurrencia
>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C","Python"]
>>>lenguaje_de_programacion.remove("Python")
>>>print(lenguaje_de_programacion)
['JavaScript', 'Java', 'C', 'Python']

El otro es el método .pop().

Si lo invocamos sin argumentos, eliminará el último elemento de la lista.

Se le puede pasar como argumento el índice del elemento específico que se quiera eliminar.

Este método devuelve el elemento eliminado, lo que puede ser útil en caso de que se quiera usar posteriormente, almacenándolo en una variable.

>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]

>>>lenguaje_de_programacion.pop()
'C'


>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'Java']

# guarda el valor retornado en una variable
>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]

>>>language_favorito = programming_languages.pop(0)
>>>print(language_favorito)
Python

Conclusión

Aquí acabamos nuestra introducción sobre fundamentos de tuplas y listas y como son usadas normalmente.

Para recapitular, las similitudes entre tuplas y listas son:

  • Son considerados objetos (instancias de una clase).
  • Son contenedores de colecciones de datos, pudiendo ser estos de cualquier tipo.
  • Son colecciones ordenadas, mantienendo siempre ese orden. Una vez que se ha definido el orden de los elementos, ya no cambiará. Esto puede parecer contradictorio en el caso de las listas. Una tupla mantiene su orden desde el mismo momento en que se crea, no pudiendo alterarlo el programador. En una lista podemos cambiar el orden, pero una vez establecido ese nuevo orden, se garantiza que se mantendrá hasta que decidamos volver a cambiarlo. Esta es una característica que no se garantiza, por ejemplo, en el caso de los diccionarios.
  • Tanto en tuplas como en listas puedes acceder a un elemento en particular mediante su índice.

Las diferencias entre tuplas y listas son:

  • Una tupla es inmutable. Úsalas cuando sepas con seguridad que tus datos no van a variar durante el ciclo de vida del programa o cuando quieras garantizar que se mantendrán constantes.
  • Una lista es mutable. Se puede añadir o eliminar elementos. Las listas crecen y decrecen durante la vida del programa. Úsalas cuando tus datos, por su propia naturaleza, sean susceptibles de variar.

Si quieres aprender Python en profundidad, freeCodeCamp ofrece una certificación de Python gratis.

El curso comienza con las bases más elementales y avanza hasta temas más complejos como estructuras de datos y bases de datos relacionales. Al final, hay cinco proyectos que solidificarán tus conocimientos.

¡Gracias por leer y feliz aprendizaje!

Dejo el enlace al tutorial oficial de Python en español.