2.8. Tuplas

Una tupla es una secuencia de valores inmutable y ordenada. Una vez creada, los elementos de su interior no pueden añadirse, eliminarse ni cambiarse.

2.8.1. Crear tuplas

Usa paréntesis (o simplemente comas) para crear una tupla:

empty   = ()
point   = (3, 4)
triple  = 1, 2, 3                # parentheses are optional
mixed   = (1, "two", 3.14)
nested  = ((1, 2), (3, 4))

2.8.1.1. La trampa del elemento único

Los paréntesis alrededor de un valor son solo paréntesis; lo que realmente hace una tupla es la coma. Una tupla de un solo elemento necesita una coma final:

>>> (1)
1                                # just an int in parens
>>> (1,)
(1,)                             # a one-element tuple
>>> type((1)), type((1,))
(<class 'int'>, <class 'tuple'>)

2.8.2. Longitud, indexación y particionado

Igual que las listas y las cadenas – len(), la indexación, el particionado, in y + / * funcionan todos de la misma manera:

>>> point = (3, 4, 5)
>>> len(point)
3
>>> point[0]
3
>>> point[1:]
(4, 5)
>>> 4 in point
True
>>> (1, 2) + (3, 4)
(1, 2, 3, 4)

2.8.3. Inmutabilidad

Las tuplas no tienen append, pop, sort ni ningún otro método en el sitio. La asignación indexada lanza TypeError:

>>> point = (3, 4)
>>> point[0] = 99
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item assignment

Para «modificar» una tupla, construye una nueva con los valores cambiados.

2.8.4. Desempaquetado

El principal superpoder de una tupla es el desempaquetado: asignar cada elemento a una variable separada en una sola sentencia.

El desempaquetado vincula cada elemento de una tupla a una variable nombrada en una sola asignación.

>>> point = (3, 4)
>>> x, y = point
>>> x
3
>>> y
4

El lado derecho puede ser cualquier iterable – una lista, una cadena, el valor de retorno de una función:

>>> a, b, c = "abc"
>>> a, b, c
('a', 'b', 'c')

Un * inicial recoge «el resto» de un desempaquetado en una lista:

>>> first, *rest = [10, 20, 30, 40]
>>> first
10
>>> rest
[20, 30, 40]

2.8.5. Múltiples valores de retorno

Una función puede devolver una tupla para entregar varios valores a la vez; el llamador los desempaqueta a la entrada:

def size_of(rect):
    return (rect[2] - rect[0], rect[3] - rect[1])

width, height = size_of((10, 20, 110, 140))
# width = 100, height = 120

Los paréntesis en el return son opcionales – un simple return a, b también es una tupla.

2.8.6. Tupla frente a lista

Una guía práctica de cuál usar:

• Tupla para datos de forma fija, a menudo heterogéneos: puntos (x, y), colores (r, g, b), múltiples valores de retorno, argumentos de función empaquetados para su uso posterior.

• Lista para datos de longitud variable, a menudo homogéneos: una lista de mediciones, una cola de elementos por procesar, cualquier cosa a la que esperes añadir elementos.

Las tuplas también son hashables (siempre que cada elemento de su interior sea hashable), así que pueden usarse como claves en un dict.