Unir Tuplas en Python

Las tuplas de Python son secuencias inmutables — una vez creadas no puedes agregar, eliminar ni modificar sus elementos. Unir tuplas significa crear una nueva tupla que combina el contenido de dos o más tuplas existentes. Debido a que las tuplas son inmutables, cada operación de unión devuelve una tupla nueva en lugar de modificar las originales.

Esta página cubre las principales formas de unir tuplas en Python:

• Operador + — concatenar dos o más tuplas
• Operador * — repetir una tupla un número fijo de veces
• Constructor tuple() — construir una tupla a partir de cualquier iterable, útil al combinar secuencias que no son tuplas

Unir Tuplas con el Operador +

El operador + concatena dos tuplas en una sola tupla nueva. Los elementos del operando izquierdo van primero, seguidos de los del operando derecho. Ninguna de las tuplas originales cambia.

Salida:

(1, 2, 3, 4, 5, 6)

Unir Tres o Más Tuplas

Encadena el operador + para combinar cualquier número de tuplas en una sola expresión:

Salida:

(1, 2, 3, 4, 5, 6, 7, 8, 9)

Unir Tuplas con Tipos Mixtos

Las tuplas pueden contener valores de distintos tipos, y + funciona de la misma manera sin importar eso:

t1 = (1, "hello", True)
t2 = (3.14, None)
result = t1 + t2
print(result)

Salida:

(1, 'hello', True, 3.14, None)

Precaución: Ambos Operandos Deben Ser Tuplas

No puedes usar + para concatenar una tupla con una lista u otro tipo — Python lanza un TypeError. Convierte primero la otra secuencia a tupla:

my_tuple = (1, 2, 3)
my_list = [4, 5, 6]

# This raises TypeError:
# result = my_tuple + my_list

# Correct — convert the list to a tuple first:
result = my_tuple + tuple(my_list)
print(result)

Salida:

(1, 2, 3, 4, 5, 6)

Precaución: Sintaxis de Tupla de un Solo Elemento

Una tupla con un elemento requiere una coma al final. Sin ella, Python interpreta los paréntesis como agrupación, no como una tupla literal:

not_a_tuple = (42)    # int, not tuple
singleton   = (42,)   # tuple with one element

result = singleton + (1, 2)
print(result)

Salida:

(42, 1, 2)

Repetir una Tupla con el Operador *

El operador * repite una tupla un número determinado de veces y devuelve una nueva tupla. Esto es útil cuando necesitas una secuencia pre-llenada con un patrón repetido.

t = ("a", "b")
result = t * 3
print(result)

Salida:

('a', 'b', 'a', 'b', 'a', 'b')

El entero puede aparecer en cualquiera de los lados: t * 3 y 3 * t producen el mismo resultado. Multiplicar por 0 o un número negativo devuelve una tupla vacía.

t = (1, 2, 3)
print(t * 0)   # ()
print(t * 1)   # (1, 2, 3)

Salida:

()
(1, 2, 3)

Construir una Tupla Combinada con tuple()

El constructor integrado tuple() convierte cualquier iterable en una tupla. Puedes usarlo para construir una tupla combinada a partir de una lista ensamblada mediante adiciones sucesivas, lo cual es más eficiente que llamadas repetidas a + dentro de un bucle.

parts = [1, 2, 3]
parts += [4, 5, 6]        # build up a list first
combined = tuple(parts)   # convert to tuple once
print(combined)

Salida:

(1, 2, 3, 4, 5, 6)

Por Qué Evitar + Dentro de un Bucle

Cada llamada a + crea un nuevo objeto tupla y copia todos los elementos. Al unir muchas tuplas, esto implica O(n²) copias. El patrón eficiente es reunir todos los elementos en una lista y convertirla una sola vez al final:

tuples = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Inefficient — creates a new tuple on each iteration
result = ()
for t in tuples:
    result = result + t   # many intermediate copies

# Efficient — build a list, convert once
result = tuple(item for t in tuples for item in t)
print(result)

Salida:

(1, 2, 3, 4, 5, 6, 7, 8)

Unir vs. Anidar Tuplas

Es fácil anidar tuplas accidentalmente en lugar de unirlas. El operador + aplana un nivel; envolver tuplas en una nueva tupla crea una estructura anidada.

t1 = (1, 2)
t2 = (3, 4)

joined = t1 + t2      # flat: all four elements at the same level
nested = (t1, t2)     # two-element tuple of tuples

print("joined:", joined)
print("nested:", nested)

Salida:

joined: (1, 2, 3, 4)
nested: ((1, 2), (3, 4))

Usa + cuando quieras un resultado plano. Usa (t1, t2) cuando intencionalmente quieras una tupla de tuplas (por ejemplo, una tabla de filas).

Elegir el Enfoque Correcto

Temas Relacionados

• Python Tuples — crear, indexar y dividir tuplas
• Access Tuples — indexar y dividir elementos de una tupla
• Update Tuples — alternativas para modificar tuplas inmutables
• Unpack Tuples — asignar elementos de una tupla a variables
• Loop Tuples — iterar sobre elementos de una tupla
• Tuple Methods — referencia de count() e index()
• Join Lists — combinar listas con +, extend() y más

Práctica