Tuplas (El Estuche Sellado)

Fig. 5.5: Una tupla: cápsula sellada de solo lectura.

La Tupla (tuple) es la hermana difícil de la Lista. Comparte el mismo ADN: es una secuencia ordenada con posiciones 0, 1, 2… Pero tiene una diferencia decisiva: es Inmutable. Una vez que guardas algo ahí, ahí se queda.

Piensa en un Estuche Sellado de instrumentos de precisión. Puedes ver cada pieza por la ventana de la tapa, leer la etiqueta, contar las piezas. Lo que no puedes hacer es abrirlo para reorganizarlas.

¿Por qué querrías algo que no se puede cambiar?

Hay datos que no deberían cambiar, porque modificarlos sería un error, sin excepción:

• Las coordenadas GPS de tu casa.
• Los días de la semana.
• La configuración fija de un servidor.

Una tupla no es una restricción caprichosa. Es una garantía escrita en el código: si alguien intenta modificar ese valor, Python lo detiene antes de que el daño ocurra. Eso incluye errores tuyos a las 2 a. m.

Gestión del Estuche

1. Construcción

Usamos paréntesis ().

coordenadas: tuple[int, int] = (10, 20)

¡Ojo!: (10) no es una tupla, es el número 10 con paréntesis de adorno. Para una tupla de un elemento la coma es obligatoria: (10,). Parece un capricho, pero es lo que separa “crear una tupla” de “solo agrupar con paréntesis”.

2. Lectura Sí, Escritura No

Leer una tupla funciona exactamente igual que en las listas: índices y rebanadas.

coordenadas = (10, 20)
print(coordenadas[0])    # 10
print(len(coordenadas))  # 2

Lo que cambia es el intento de sabotaje: si tratas de modificar algo, Python lanza una alerta de seguridad (TypeError).

# Esto fallará
coordenadas[0] = 50
# TypeError: 'tuple' object does not support item assignment

El mensaje dice, traducido, “la tupla no admite que le asignes elementos”. Es el estuche sellado cumpliendo su trabajo.

3. Desempacar (Unpacking)

El uso más común de las tuplas casi no parece “usar una tupla”: es repartir varios valores de un golpe en varias variables.

coordenadas = (10, 20)
x, y = coordenadas        # x vale 10, y vale 20

Por eso se dice que una función “puede devolver dos cosas”: en realidad devuelve una tupla, y tú la desempacas.

Adelanto: el bloque siguiente usa def y return (Capítulo 9) y los operadores // y % (Capítulo 6). No necesitas entenderlos hoy; quédate con la idea de la tupla que viaja de regreso. El Capítulo 9 retoma este ejemplo con calma.

def dividir(a, b):
    return a // b, a % b       # devuelve la tupla (cociente, resto)

cociente, resto = dividir(17, 5)   # cociente = 3, resto = 2

Lo verás por todos lados: recorrer un diccionario con for clave, valor in ..., o intercambiar dos variables de un tirón con a, b = b, a. Todo eso es desempacar tuplas.

Úsalas para blindar los datos que el resto del programa debe ver pero nunca tocar.

Resumen del Capítulo

• Las Listas ([]) son ordenadas, mutables e indexadas desde cero; se gestionan con .append(), .remove(), del, .insert(), .pop(), sorted()/.sort().
• Asignar una lista a otra variable no la copia: crea un alias sobre el mismo estante. Para una copia real, usa .copy().
• Los Diccionarios ({clave: valor}) buscan por nombre, no por posición; .get() evita el KeyError de una clave ausente, y .items() recorre pares completos.
• Una lista de diccionarios (list[dict]) es la forma natural de guardar varios registros con los mismos campos.
• Los Conjuntos (set) no admiten duplicados y no tienen orden; sirven para limpiar listas repetidas y para uniones (|), intersecciones (&) y diferencias (-).
• Las Tuplas (()) son como las listas pero inmutables: una vez creadas, no se pueden modificar, solo leer.
• El desempaque (x, y = tupla) reparte los valores de una tupla en varias variables de un solo golpe.