Unir Tuplas em Python

As tuplas em Python são sequências imutáveis — uma vez criadas, não é possível adicionar, remover ou alterar seus elementos. Unir tuplas significa criar uma nova tupla que combina o conteúdo de duas ou mais tuplas existentes. Como as tuplas são imutáveis, toda operação de junção retorna uma tupla nova em vez de modificar as originais.

Esta página aborda as principais formas de unir tuplas em Python:

• Operador + — concatena duas ou mais tuplas
• Operador * — repete uma tupla um número fixo de vezes
• Construtor tuple() — cria uma tupla a partir de qualquer iterável, útil ao combinar sequências que não são tuplas

Unindo Tuplas com o Operador +

O operador + concatena duas tuplas em uma única tupla nova. Os elementos do operando da esquerda vêm primeiro, seguidos pelos do operando da direita. Nenhuma das tuplas originais é alterada.

Saída:

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

Unindo Três ou Mais Tuplas

Encadeie o operador + para unir qualquer número de tuplas em uma única expressão:

Saída:

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

Unindo Tuplas com Tipos Mistos

As tuplas podem conter valores de diferentes tipos, e o + funciona da mesma forma independentemente disso:

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

Saída:

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

Atenção: Ambos os Operandos Devem Ser Tuplas

Não é possível usar + para concatenar uma tupla com uma lista ou qualquer outro tipo — Python lança um TypeError. Converta a outra sequência para uma tupla antes:

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)

Saída:

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

Atenção: Sintaxe de Tupla com Um Único Elemento

Uma tupla com um único elemento exige uma vírgula ao final. Sem ela, Python interpreta os parênteses como agrupamento, não como um literal de tupla:

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

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

Saída:

(42, 1, 2)

Repetindo uma Tupla com o Operador *

O operador * repete uma tupla um determinado número de vezes e retorna uma nova tupla. Isso é útil quando você precisa de uma sequência pré-preenchida com um padrão repetido.

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

Saída:

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

O inteiro pode aparecer em qualquer lado: t * 3 e 3 * t produzem o mesmo resultado. Multiplicar por 0 ou por um número negativo retorna uma tupla vazia.

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

Saída:

()
(1, 2, 3)

Construindo uma Tupla Combinada com tuple()

O construtor embutido tuple() converte qualquer iterável em uma tupla. Você pode usá-lo para criar uma tupla combinada a partir de uma lista que foi montada com adições sucessivas, o que é mais eficiente do que chamadas repetidas de + dentro de um loop.

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

Saída:

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

Por Que Evitar + Dentro de um Loop

Cada chamada de + cria um novo objeto tupla e copia todos os elementos. Ao unir muitas tuplas, isso resulta em O(n²) cópias. O padrão eficiente é coletar todos os elementos em uma lista e convertê-la uma única vez ao 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)

Saída:

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

Unir vs. Aninhar Tuplas

É fácil aninhar tuplas acidentalmente em vez de uni-las. O operador + nivela em um nível; envolver tuplas em uma nova tupla cria uma estrutura aninhada.

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)

Saída:

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

Use + quando quiser um resultado plano. Use (t1, t2) quando quiser intencionalmente uma tupla de tuplas (por exemplo, uma tabela de linhas).

Escolhendo a Abordagem Correta

Tópicos Relacionados

• Python Tuples — criando, indexando e fatiando tuplas
• Access Tuples — indexação e fatiamento de elementos de tuplas
• Update Tuples — alternativas para modificar tuplas imutáveis
• Unpack Tuples — atribuindo elementos de tuplas a variáveis
• Loop Tuples — iterando sobre elementos de tuplas
• Tuple Methods — referência dos métodos count() e index()
• Join Lists — unindo listas com +, extend() e mais

Prática