Tuplas en Python

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. El siguiente ejemplo ilustra estos dos conceptos.

>>> t = (1,'dos',3)
>>> type(t)
<class 'tuple'>
>>> t[0] = 'uno'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

A pesar de todas sus similitudes, existen diferentes motivos por los cuales optar por una tupla y no una lista en nuestro script, según RealPython (en inglés) son los siguientes:

• Manipular tuplas agiliza la ejecución del programa en comparación con una lista equivalente (aunque esta diferencia no sea apreciable con tamaños pequeños de listas o tuplas).
• Cuando quieres que los datos sean constantes durante toda la ejecución del programa y no puedan modificarse accidentalmente.
• En los diccionarios las claves tienen que ser objetos inmutables, por tanto pueden ser tuplas pero no listas.

Embalar y desembalar una tupla

Las tuplas también pueden declararse sin necesidad de usar paréntesis. Cual sea el caso, la declaración de una tupla también se le denomina “embalar” la tupla (tuple packing en inglés), ya que todos sus elementos quedan asociados a un solo objeto.

>>> t = 'uno', 'dos', 'tres', 'cuatro'
>>> type(t)
<class 'tuple'>

En el caso tuplas con un solo elemento hay que añadir una coma para que el intérprete de Python lo considere una tupla.

>>> t = 1
>>> type(t)
<class 'int'>
>>> t = 1,
>>> type(t)
<class 'tuple'>

Al paso inverso se le denomina “desembalar” la tupla (tuple unpacking en inglés), ya que los elementos de la tupla se copian en objetos distintos.

>>> t = ('uno', 'dos', 'tres', 'cuatro')
>>> a, b, c, d = t
>>> a
'uno'
>>> b
'dos'
>>> c
'tres'
>>> d
'cuatro'

El número de objetos declarados para “desembalar” la tupla tiene que coincidir con el número de elementos de la tupla, ya que en caso contrario el intérprete lanza un error del tipo ValueError.

>>> t = ('uno', 'dos', 'tres', 'cuatro')
>>> a, b, c = t
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
>>> a, b, c, d, e = t
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 5, got 4)

Para evitar este error, existe la posibilidad de “desembalar” varios elementos de la tupla en una misma variable insertando un asterisco (*) delante de su nombre.

>>> cabeza, *cola = ('uno', 'dos', 'tres', 'cuatro')
>>> print(cabeza)
uno
>>> print(cola)
['dos', 'tres', 'cuatro']

Indexación y rebanado de tuplas

Los elementos de una tupla se indexan del mismo modo que los caracteres de una cadena y los elementos de una lista. Es decir al primer elemento le corresponde el índice 0, al segundo el índice 1, etc. Y empezando por el final podemos referenciar el último elemento con el índice -1, el penúltimo -2 etc.

>>> t = ('uno', 'dos', 'tres', 'cuatro')
>>> t[0]
'uno'
>>> t[3]
'cuatro'
>>> t[-1]
'cuatro'

Asimismo a una tupla se le puede rebanar una porción utilizando la misma notación para el rebanado de strings.

>>> t = ('uno', 'dos', 'tres', 'cuatro')
>>> t[1:]
('dos', 'tres', 'cuatro')
>>> t[1:3]
('dos', 'tres')

Métodos de las tuplas

Las tuplas sólo disponen de dos métodos que son los siguientes:

• t.count(x) : cuenta el número de veces que el elemento x está en la tupla t.

>>> t = (1, 1, 2, 3)
>>> t.count(1)
2

• t.index(x) : retorna el índice más pequeño del elemento x en la tupla t.

>>> t = (1, 1, 2, 3)
>>> t.index(1)
0

Conversión entre listas y tuplas

La conversión entre estos dos tipos de objetos es muy sencilla. Si queremos convertir una lista en una tupla tenemos que usar declarar la tupla pasándole la lista en el constructor.

>>> l = [1, 2, 3, 4]
>>> t = tuple(l)
>>> t
(1, 2, 3, 4)

El paso inverso es equivalente, pero pasándole la tupla al constructor de la lista.

>>> t = (1, 2, 3, 4)
>>> l = list(t)
>>> l
[1, 2, 3, 4]