Actualizar Tuplas en Python

Las tuplas de Python son secuencias inmutables — una vez creadas, su estructura no puede cambiar. No es posible agregar, eliminar ni reasignar elementos directamente. A pesar de esto, siempre puedes producir una nueva tupla modificada a partir de una existente. Esta página cubre todas las técnicas prácticas: conversión a lista, concatenación, slicing, reemplazo de todas las ocurrencias de un valor y más. También explica el problema más común — los objetos mutables anidados dentro de una tupla.

Por Qué las Tuplas Son Inmutables

La garantía de inmutabilidad de Python es intencional. Las tuplas pueden usarse como claves de diccionario o miembros de conjuntos precisamente porque su identidad nunca cambia. Intentar modificar una tupla en su lugar lanza un TypeError:

Intentar una asignación directa lanza TypeError

t = (1, 2, 3, 4, 5)
t[2] = 6  # TypeError: 'tuple' object does not support item assignment

Cada técnica presentada a continuación crea una tupla completamente nueva en lugar de modificar la original.

Conversión a Lista

El enfoque más legible para cambios complejos: convertir a lista, realizar todas las ediciones y luego convertir de nuevo.

Convertir una tupla a lista, actualizarla y convertirla de nuevo

Salida:

(1, 2, 6, 4, 5)

Usa este enfoque cuando necesites realizar varios cambios a la vez — por ejemplo, ordenar, filtrar o aplicar una transformación a todos los elementos — porque las listas admiten todas las operaciones de mutación.

Reemplazar un Valor con Slicing y Concatenación

Para intercambiar un único elemento, puedes dividir la tupla alrededor del índice objetivo y concatenar el nuevo valor. No se necesita conversión a lista.

Reemplazar un elemento usando slice + concatenación

t = (1, 2, 3, 4, 5)

# Replace the element at index 2 (value 3) with 6
t = t[:2] + (6,) + t[3:]

print(t)

Salida:

(1, 2, 6, 4, 5)

El slice t[:2] da (1, 2), el literal (6,) es el reemplazo (nota la coma al final — eso lo convierte en una tupla), y t[3:] da (4, 5). La concatenación une los tres en una nueva tupla.

Reemplazar Todas las Ocurrencias de un Valor

Usa una expresión generadora dentro de tuple() para sustituir cada ocurrencia de un valor por otro.

Reemplazar todas las ocurrencias de un valor en una tupla

t = (1, 2, 2, 3, 2)

# Replace every 2 with 5
t = tuple(5 if x == 2 else x for x in t)

print(t)

Salida:

(1, 5, 5, 3, 5)

Esto es más conciso que el enfoque de conversión a lista cuando el único objetivo es una sustitución de valor.

Agregar Elementos

Agregar al Final

Usa el operador + para agregar elementos. El lado derecho también debe ser una tupla — de ahí la coma al final en (4,).

Agregar un elemento a una tupla

t = (1, 2, 3)
t = t + (4,)
print(t)

Salida:

(1, 2, 3, 4)

La abreviatura de asignación aumentada += funciona de la misma manera:

Usar += para extender una tupla

t = (1, 2, 3)
t += (4, 5)
print(t)

Salida:

(1, 2, 3, 4, 5)

Nota: += no modifica el objeto tupla original — Python reasigna el nombre de la variable a una tupla recién creada. Si otra variable aún hace referencia a la original, permanece sin cambios.

Agregar al Principio

Agregar un elemento al inicio de una tupla

t = (1, 2, 3)
t = (0,) + t
print(t)

Salida:

(0, 1, 2, 3)

Insertar en el Medio

No existe un insert() directo para tuplas. Combina dos slices alrededor de la posición deseada:

Insertar un elemento en una posición específica

t = (1, 2, 4, 5)

# Insert 3 at index 2
t = t[:2] + (3,) + t[2:]

print(t)

Salida:

(1, 2, 3, 4, 5)

Eliminar Elementos

Eliminar por Índice

Divide alrededor del índice que deseas eliminar:

Eliminar el elemento en el índice 2

t = (1, 2, 3, 4, 5)

# Remove the element at index 2 (value 3)
t = t[:2] + t[3:]

print(t)

Salida:

(1, 2, 4, 5)

Eliminar por Valor

Usa una expresión generadora para filtrar los valores coincidentes:

Eliminar todas las ocurrencias de un valor específico

t = ('apple', 'banana', 'cherry', 'banana')

t = tuple(x for x in t if x != 'banana')

print(t)

Salida:

('apple', 'cherry')

Esto elimina cada ocurrencia del valor en un solo paso. Si solo deseas eliminar la primera ocurrencia, convierte a lista, llama a .remove() y vuelve a convertir.

Usar Desempaquetado de Tuplas

Desempaquetar una tupla en variables con nombre te permite reconstruirla con posiciones específicas cambiadas. Esto es más útil cuando la tupla es pequeña y deseas nombrar las partes para mayor claridad.

Reconstruir una tupla desempaquetando y reasignando variables específicas

t = (1, 2, 3, 4, 5)
a, b, c, d, e = t

# Replace the third element
t = (a, b, 6, d, e)

print(t)

Salida:

(1, 2, 6, 4, 5)

Evita este enfoque para tuplas grandes — terminas escribiendo una variable por elemento, lo cual es verboso y propenso a errores.

Precaución: Objetos Mutables Dentro de una Tupla

La inmutabilidad de una tupla se aplica solo a las referencias que contiene, no a los objetos a los que apuntan esas referencias. Si una tupla contiene un objeto mutable — como una lista — puedes modificar la lista, y el cambio es visible a través de la tupla.

Modificar una lista anidada dentro de una tupla

t = ([1, 2], [3, 4])

# The tuple itself is immutable, but its elements (lists) are not
t[0].append(5)

print(t)

Salida:

([1, 2, 5], [3, 4])

La tupla sigue conteniendo las mismas dos referencias de lista — esa parte es inmutable. Pero el objeto lista al que apunta t[0] ha sido mutado. Esta es una fuente común de confusión cuando las tuplas se usan como claves de diccionario; solo las tuplas completamente inmutables (que no contienen listas, dicts u otros objetos mutables) son hashables.

Elegir el Enfoque Correcto

Para obtener más información sobre el trabajo con tuplas, consulta Access Tuples, Unpack Tuples, Loop Tuples y Tuple Methods.

Práctica