Listas vs Tuplas en Python

Listas vs Tuplas en Python

Una pregunta que nos surge cuando somos principiantes es: ¿Cual es la diferencia entre una lista y una tupla?
La respuesta es que hay 2 diferencias, existe la diferencia técnica y la diferencia cultural.

Este artículo no es de mi autoría, es una traducción al español, cito el enlace al final de la entrada.

En primer lugar, algo que es igual, tanto para las listas como para las tuplas, es que ambas son contenedoras de una secuencia de objetos:

>>> my_list = [1, 2, 3]
>>> type(my_list)
<class 'list'>
>>> my_tuple = (1, 2, 3)
>>> type(my_tuple)
<class 'tuple'>

Ambos pueden tener elementos de cualquier tipo, incluso dentro de una sola secuencia. Ambos mantienen el orden de los elementos.

Ahora pasemos a ver las diferencias. La diferencia técnica entre las listas y tuplas es que las listas son mutables (pueden ser cambiadas) y las tuplas son inmutables (no se pueden cambiar). Esta es la única distinción que hace el lenguaje Python sobre ellas:

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

Esa es la única diferencia técnica entre las listas y tuplas, aunque se manifiesta de varias maneras. Por ejemplo, las listas tienen un método .append() para añadir más elementos a la lista, mientras que las tuplas no lo hacen:

>>> my_list.append("four")
>>> my_list
[1, 'two', 3, 'four']
>>> my_tuple.append("four")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'

Las tuplas no tienen necesidad del método .append() porque no se pueden modificar.

La diferencia cultural trata de como se utilizan realmente las listas y las tuplas: las listas se utilizan cuando se tiene una secuencia homogénea de longitud desconocida, las tuplas se utilizan cuando se conoce el número de elementos de antemano debido a que la posición del elemento es semánticamente significativa.

Por ejemplo, supongamos tenemos una función que dentro de un directorio nos devuelve todos los archivos .py (*.py). Esto se debería devolver en una lista, porque no sabemos cuantos archivos podemos encontrar.

>>> find_files("*.py")
["control.py", "config.py", "cmdline.py", "backward.py"]

Por otra parte, supongamos que necesitamos almacenar 5 valores para representar la ubicación de las estaciones de observación meteorológicas: id, city, state, latitude y longitude. Una tupla es lo más adecuado para esto en lugar de una lista:

>>> denver = (44, "Denver", "CO", 40, 105)
>>> denver[1]
'Denver'

A continuación, el primer elemento es el id, el segundo es la ciudad y así sucesivamente.

Python tiene una facilidad llamada namedtuple que puede hacer el significado más explicito:

>>> from collections import namedtuple
>>> Station = namedtuple("Station", "id, city, state, lat, long")
>>> denver = Station(44, "Denver", "CO", 40, 105)
>>> denver
Station(id=44, city='Denver', state='CO', lat=40, long=105)
>>> denver.city
'Denver'
>>> denver[1]
'Denver'

La diferencia técnica y la diferencia cultural tienen una alianza incomoda, ya que están aveces en desacuerdo. ¿Porque deberían ser homogéneas las secuencias mutables, pero las secuencias heterogéneas no serlo? Por ejemplo, no puedo modificar mi estación meteorológica porque un namedtuple es una tupla, que es inmutable:

>>> denver.lat = 39.7392
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: can't set attribute

Y aveces las consideraciones técnicas tienen prioridad sobre las consideraciones culturales. No se puede utilizar una lista como clave de diccionario, porque solamente los valores inmutables pueden ser mezclados, osea, solo los valores inmutables pueden ser claves. Para utilizar una lista como clave, se puede convertir a tupla:

>>> d = {}
>>> nums = [1, 2, 3]
>>> d[nums] = "hello"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> d[tuple(nums)] = "hello"
>>> d
{(1, 2, 3): 'hello'}

Otro conflicto entre lo técnico y lo cultural: hay momentos en que el mismo Python utiliza una tupla cuando una lista tiene más sentido. Cuando se define una función con *args, nos lo pasa como una tupla, a pesar de que la posición de los valores no es significativa. Se puede decir que es una tupla porque no se puede cambiar lo que fue pasado, pero esto es solo una valoración de la diferencia técnica sobre la cultural.

Lo se, lo se, en *args, la posición podría ser significativa debido a que son parámetros posicionales. Sin embargo, en una función que ha de aceptar *args y pasarlos a otra función, que es solo una sentencia de argumentos, ninguno diferente de otro, el numero de ellos puede variar entre invocaciones.

Python utiliza tuplas aquí porque son un poco más espacio-eficientes que las listas. Esto muestra el lado pragmático de Python: en lugar de discutir por la semántica lista/tupla de *args, solo se tiene que utilizar la estructura de datos que funcione mejor para el caso.

En la mayoría de los casos, debemos elegir entre utilizar una lista o una tupla en base a la diferencia cultural. Debemos pensar en nuestros datos. Si podríamos llegar a tener diferentes longitudes, entonces es probable que utilicemos una lista. Si cuando escribimos el código sabemos de antemano la cantidad de elementos, entonces es probable que utilicemos una tupla.

Por otro lado, la programación funcional hace hincapié en las estructuras de datos inmutables como una manera de evitar los efectos secundarios que puedan hacer difícil interpretar el código. Si somos fans de la programación funcional, es probable que prefieramos tuplas por su inmutabilidad.

Entonces: ¿Tuplas o listas? No es siempre una respuesta sencilla.

Fuente: http://nedbatchelder.com/blog/201608/lists_vs_tuples.html