Tuplas en Python: Una guía completa

Una tupla es una secuencia ordenada e inmutable en Python. Puede contener elementos de cualquier tipo — enteros, strings, flotantes, otras tuplas — y esos elementos mantienen su posición permanentemente después de que se crea la tupla. Esta página cubre todo lo que necesitas para trabajar con tuplas: cómo crearlas, leerlas, combinarlas y saber cuándo elegirlas en lugar de una lista de Python.

¿Qué es una tupla en Python?

Una tupla se escribe como una secuencia separada por comas encerrada entre paréntesis:

Tres propiedades clave definen las tuplas:

• Ordenadas — los elementos tienen una posición fija (índice 0, 1, 2, …).
• Inmutables — no se pueden cambiar, agregar ni eliminar elementos después de la creación.
• Permiten duplicados — el mismo valor puede aparecer más de una vez.

Tuplas vs. listas

Tanto las tuplas como las listas almacenan secuencias ordenadas, pero su mutabilidad difiere de forma fundamental:

Usa una tupla cuando los datos no deban cambiar — constantes de configuración, valores de retorno de funciones que llevan múltiples datos relacionados, o claves de diccionario.

Crear tuplas

Sintaxis básica

Escribe valores separados por comas dentro de paréntesis:

Tipos mixtos

Una tupla puede contener elementos de diferentes tipos, incluyendo otras tuplas:

mixed = (1, 'hello', 3.14, True)
print(mixed)
# Output: (1, 'hello', 3.14, True)

Tupla vacía

empty = ()
print(empty)        # Output: ()
print(type(empty))  # Output: <class 'tuple'>

Tupla de un solo elemento

Este es un error común. Sin la coma al final, Python trata los paréntesis como agrupación, no como una tupla:

not_a_tuple = (42)
print(type(not_a_tuple))  # Output: <class 'int'>

real_tuple = (42,)
print(type(real_tuple))   # Output: <class 'tuple'>

La coma al final es lo que la convierte en tupla — inclúyela siempre en tuplas de un solo elemento.

Crear desde un iterable

Usa el constructor integrado tuple() para convertir cualquier iterable en una tupla:

Tupla sin paréntesis (empaquetado)

Python permite crear una tupla simplemente listando valores separados por comas — los paréntesis son opcionales:

packed = 1, 2, 3
print(packed)        # Output: (1, 2, 3)
print(type(packed))  # Output: <class 'tuple'>

Acceder a los elementos de una tupla

Indexación positiva

Los índices comienzan en 0 para el primer elemento:

Indexación negativa

Los índices negativos cuentan desde el final. -1 es el último elemento:

Slicing

Usa [start:stop:step] para extraer una sub-tupla. El índice stop queda excluido:

t = (0, 1, 2, 3, 4)
print(t[1:4])   # Output: (1, 2, 3)
print(t[:3])    # Output: (0, 1, 2)
print(t[2:])    # Output: (2, 3, 4)
print(t[::2])   # Output: (0, 2, 4)

Tuplas anidadas

Accede a los elementos anidados encadenando corchetes de índice:

nested = ((1, 2), (3, 4), (5, 6))
print(nested[1])     # Output: (3, 4)
print(nested[1][0])  # Output: 3

Verificar pertenencia

El operador in comprueba si un valor existe en una tupla:

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # Output: True
print('mango' in fruits)   # Output: False

Para más técnicas de indexación y slicing, consulta Access Tuples.

Inmutabilidad de las tuplas

Una vez creada, los elementos de una tupla no se pueden modificar:

my_tuple = (1, 2, 3)
my_tuple[0] = 99  # TypeError: 'tuple' object does not support item assignment

Si necesitas una versión modificada, construye una nueva tupla a partir de slices y concatenación:

Ten en cuenta que una tupla puede contener objetos mutables como listas. La tupla en sí es inmutable (no puedes cambiar la referencia a la lista), pero la lista dentro aún puede modificarse.

Consulta Update Tuples para una discusión completa de alternativas.

Operaciones con tuplas

Concatenación con +

Unir dos tuplas con + crea una nueva tupla:

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)
# Output: (1, 2, 3, 4)

Repetición con *

Repite el contenido de una tupla con *:

t = (0,) * 3
print(t)
# Output: (0, 0, 0)

Para todas las estrategias de unión, consulta Join Tuples.

Métodos de las tuplas

Las tuplas tienen exactamente dos métodos integrados, porque la inmutabilidad descarta cualquier cosa que modificaría la colección.

count()

Devuelve el número de veces que aparece un valor:

index()

Devuelve el índice de la primera aparición de un valor. Lanza ValueError si el valor no se encuentra:

Consulta Tuple Methods para una referencia completa.

Funciones integradas con tuplas

Las funciones integradas de Python funcionan con cualquier iterable, incluidas las tuplas:

sorted() siempre devuelve una lista, incluso cuando recibe una tupla como entrada. Envuélvela en tuple() si necesitas recuperar una tupla ordenada.

Desempaquetado de tuplas

El desempaquetado asigna cada elemento de una tupla a una variable separada en una sola instrucción:

Desempaquetado extendido con *

Una variable con asterisco absorbe cualquier cantidad de elementos restantes en una lista:

first, *rest = (10, 20, 30, 40)
print(first)  # Output: 10
print(rest)   # Output: [20, 30, 40]

Intercambiar variables

El desempaquetado de tuplas hace que el intercambio de variables sea de una sola línea — sin necesidad de variable temporal:

x, y = 5, 10
x, y = y, x
print(x, y)
# Output: 10 5

Consulta Unpack Tuples para más patrones incluyendo desempaquetado anidado.

Iterar sobre una tupla

Un bucle for visita cada elemento en orden:

fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)
# Output:
# apple
# banana
# cherry

Usa enumerate() cuando también necesites el índice:

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output:
# 0 apple
# 1 banana
# 2 cherry

Consulta Loop Tuples para bucles while, zip() y recorrido de tuplas anidadas.

Construir tuplas a partir de comprensiones

Python no tiene sintaxis de comprensión de tuplas, pero puedes pasar una expresión generadora a tuple() para lograr el mismo resultado:

La expresión x**2 for x in my_list dentro de tuple() es un generador — produce valores de uno en uno sin construir una lista intermedia.

Cuándo usar tuplas

Las tuplas destacan en situaciones específicas:

• Múltiples valores de retorno. Las funciones pueden devolver varios valores de forma limpia como una tupla: return x, y.
• Claves de diccionario. Las listas no pueden ser claves de diccionario porque son mutables; las tuplas sí pueden.
• Integridad de datos. Si una colección no debe cambiar — valores RGB, fila de base de datos, coordenadas geográficas — una tupla lo hace cumplir a nivel del lenguaje.
• Ligera ventaja de rendimiento. La iteración y creación de tuplas son marginalmente más rápidas que las operaciones con listas para los mismos datos.

# Using a tuple as a dictionary key
locations = {}
locations[(48.8566, 2.3522)] = 'Paris'
locations[(51.5074, -0.1278)] = 'London'
print(locations[(48.8566, 2.3522)])
# Output: Paris

Práctica