Saltearse al contenido

tuple

La definición habitual —«una lista que no se puede modificar»— es correcta y es la que hace que la gente use tuplas por razones equivocadas. Una tupla no es una lista restringida: es un registro de campos fijos, donde la posición significa algo. (x, y) es un punto; [x, y] es una colección de dos números que da la casualidad que son coordenadas.

Una lista es una colección de cosas iguales; una tupla es una cosa con partes.

Misma longitud, distinta reserva
tuple de 5 — capacidad exacta → 8 B → 8 B → 8 B → 8 B → 8 B = 40 B + 5 × 8 list de 5 — capacidad 8 → 8 B → 8 B → 8 B → 8 B → 8 B libre 8 B libre 8 B libre 8 B = 56 B + 8 × 8

La tupla se crea con el tamaño justo porque nunca va a crecer. La lista reserva de más para que `append` sea barato. Ahí está su diferencia de memoria.

Una tupla de cinco elementos ocupa 80 bytes; una lista de cinco construida a base de append, 120 con su reserva. Con mil elementos la diferencia es de 816 bytes (8 040 contra 8 856): el 12,5 % de reserva de la lista. Ojo con la comparación: list(range(1000)) ocupa 8 056 porque se crea con la capacidad exacta y no tiene reserva; para ver la sobreasignación hay que construirla añadiendo elementos.

Tupla frente a lista, en bytes
Elementos tuple list con append list(range(n)) Diferencia
5 80 B 120 B 104 B 40 B
1 000 8 040 B 8 856 B 8 056 B 816 B

python mediciones/02-03-tuple.py

Lo que hace útil a una tupla no es el acceso por índice, es desempaquetar:

punto = (3, 4)
x, y = punto # desempaquetado simple
primero, *resto = range(5) # primero=0, resto=[1, 2, 3, 4]
a, _, c = (1, 2, 3) # el guion bajo ignora el medio

El *resto recoge lo que sobra en una lista. El _ es una convención: no hay nada especial en ese nombre, simplemente comunica que no se usa.

El patrón más útil es el intercambio y la desestructuración de retornos:

x, y = y, x # sin variable temporal
categoria, total = analizar(datos) # retorno múltiple sin clase

Una función que devuelve una tupla está devolviendo un registro; quien la llama lo desarma en la misma línea.

t = (1, "dos", [3, 4])
t[2].append(5) # funciona
t[2] = [9] # TypeError
hash(t) # TypeError: unhashable type: 'list'

El capítulo 04 de la Parte I lo desarrolló: la tupla congela sus referencias, no los objetos. La consecuencia para este capítulo es práctica: una tupla sólo es hashable si todo su contenido lo es, y por tanto sólo sirve como clave de diccionario en ese caso.

Una tupla de inmutables es la única forma de tener una clave compuesta sin inventar una clase:

ventas = {}
ventas[("2026-11", "norte")] = 1500
ventas[("2026-11", "sur")] = 980

Eso sustituye a un diccionario anidado ({año: {región: total}}) cuando quieres recorrer las combinaciones como una sola colección. Y funciona porque hash(("2026-11", "norte")) es estable: la tupla combina los hashes de sus elementos.

El límite es el del capítulo 04 de la Parte I: si un elemento de la tupla es una lista, la tupla deja de ser hashable y la clave falla. Para claves compuestas con partes mutables, el camino es convertirlas a texto o a otra tupla de inmutables.

  • Para colecciones que crecen. t = t + (x,) es O(n) por operación; la lista es la estructura correcta.
  • Para datos homogéneos de longitud variable. Una lista de tres números no gana nada siendo tupla, y pierde legibilidad si alguien espera poder añadir.
  • Para reemplazar una dataclass. Si necesitas nombres de campo, NamedTuple los da con un coste algo mayor en memoria y en construcción (capítulo 09); si necesitas métodos, no es una tupla.

Escribe una función dividir(a, b) que devuelva cociente y resto, y explica por qué devolver una tupla es mejor que devolver una lista en este caso.

Solución
def dividir(a, b):
return divmod(a, b) # ya existe, y devuelve exactamente eso
cociente, resto = dividir(17, 5)

Devolver una tupla comunica que el resultado es un registro de dos campos fijos, no una colección que el llamador pueda ampliar. Si devolviera una lista, el llamador podría hacer r = dividir(...); r.append(3) y crear un tipo de dato que la función nunca prometió.

Además, la tupla es hashable (los dos enteros lo son), así que el resultado puede ser clave de diccionario o entrar en un set. Una lista no.

El caso real donde esto importa es un retorno de tres o cuatro valores: si empiezas a necesitar nombres, el siguiente paso no es un comentario, es NamedTuple o una dataclass.

Comprobación con datos de ejemplo:

print("cociente y resto:", cociente, resto)
print("es tupla:", isinstance(dividir(17, 5), tuple))
print("hashable:", {dividir(17, 5): "ok"})
try:
{[3, 2]: "no"}
except TypeError as error:
print("lista como clave:", error)
assert (cociente, resto) == (3, 2), "17 = 3 * 5 + 2"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 2: tuplas como registros y como listas congeladas.
  • CPython 3.13: Objects/tupleobject.c.
  • Mediciones: mediciones/02-11-coste.py.
  • 02 · list por dentro: la reserva que la tupla no tiene.
  • 04 · array y memoryview: la otra forma de no tener objetos.
  • 09 · Registros: NamedTuple y dataclass, el paso siguiente.