Atualizar Tuplas em Python

As tuplas em Python são sequências imutáveis — uma vez criadas, sua estrutura não pode ser alterada. Você não pode adicionar, remover ou reatribuir elementos diretamente. Apesar disso, sempre é possível produzir uma nova tupla modificada a partir de uma existente. Esta página aborda todas as técnicas práticas: converter para lista, concatenação, fatiamento, substituir todas as ocorrências de um valor e muito mais. Ela também explica o principal problema a evitar — objetos mutáveis aninhados dentro de uma tupla.

Por que as Tuplas são Imutáveis

A garantia de imutabilidade do Python é intencional. As tuplas podem ser usadas como chaves de dicionário ou membros de conjunto precisamente porque sua identidade nunca muda. Tentar modificar uma tupla no lugar levanta um TypeError:

Tentar atribuição direta levanta TypeError

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

Cada técnica abaixo cria uma tupla completamente nova em vez de modificar a original.

Convertendo para uma Lista

A abordagem mais legível para alterações complexas: converter para uma lista, fazer todas as edições e depois converter de volta.

Converter uma tupla para lista, atualizá-la e converter de volta

Saída:

(1, 2, 6, 4, 5)

Use essa abordagem quando precisar fazer várias alterações de uma vez — por exemplo, ordenar, filtrar ou aplicar uma transformação em todos os elementos — porque as listas suportam todas as operações de mutação.

Substituindo um Valor com Fatiamento e Concatenação

Para trocar um único elemento, você pode fatiar a tupla em torno do índice alvo e concatenar o novo valor. Nenhuma conversão para lista é necessária.

Substituir um elemento usando fatiamento + concatenação

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

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

print(t)

Saída:

(1, 2, 6, 4, 5)

O fatia t[:2] retorna (1, 2), o literal (6,) é a substituição (note a vírgula no final — ela o torna uma tupla) e t[3:] retorna (4, 5). A concatenação une os três em uma nova tupla.

Substituindo Todas as Ocorrências de um Valor

Use uma expressão geradora dentro de tuple() para trocar cada ocorrência de um valor por outro.

Substituir todas as ocorrências de um valor em uma 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)

Saída:

(1, 5, 5, 3, 5)

Isso é mais conciso que a abordagem de conversão para lista quando o único objetivo é uma substituição de valor.

Adicionando Elementos

Acrescentando ao Final

Use o operador + para acrescentar elementos. O lado direito também deve ser uma tupla — daí a vírgula no final em (4,).

Acrescentar um elemento a uma tupla

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

Saída:

(1, 2, 3, 4)

A forma abreviada de atribuição aumentada += funciona da mesma forma:

Usar += para estender uma tupla

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

Saída:

(1, 2, 3, 4, 5)

Nota: += não modifica o objeto tuple original — Python reassocia o nome da variável a uma tupla recém-criada. Se outra variável ainda referenciar o original, ele permanece inalterado.

Acrescentando ao Início

Acrescentar um elemento ao início de uma tupla

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

Saída:

(0, 1, 2, 3)

Inserindo no Meio

Não existe insert() direto para tuplas. Combine dois fatiamentos em torno da posição desejada:

Inserir um elemento em uma posição específica

t = (1, 2, 4, 5)

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

print(t)

Saída:

(1, 2, 3, 4, 5)

Removendo Elementos

Remover por Índice

Faça um fatiamento em torno do índice que deseja remover:

Remover o elemento no índice 2

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

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

print(t)

Saída:

(1, 2, 4, 5)

Remover por Valor

Use uma expressão geradora para filtrar os valores correspondentes:

Remover todas as ocorrências de um valor específico

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

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

print(t)

Saída:

('apple', 'cherry')

Isso remove todas as ocorrências do valor em uma passagem. Se você deseja remover apenas a primeira ocorrência, converta para uma lista, chame .remove() e converta de volta.

Usando Desempacotamento de Tuplas

Desempacotar uma tupla em variáveis nomeadas permite reconstruí-la com posições específicas alteradas. Isso é mais útil quando a tupla é pequena e você quer renomear as partes para maior clareza.

Reconstruir uma tupla desempacotando e reatribuindo variáveis 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)

Saída:

(1, 2, 6, 4, 5)

Evite essa abordagem para tuplas grandes — você acaba escrevendo uma variável por elemento, o que é verboso e propenso a erros.

Problema: Objetos Mutáveis Dentro de uma Tupla

A imutabilidade de uma tupla se aplica apenas às referências que ela contém, não aos objetos para os quais essas referências apontam. Se uma tupla contém um objeto mutável — como uma lista — você pode modificar a lista, e a alteração é visível através da tupla.

Modificar uma lista aninhada dentro de uma tupla

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

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

print(t)

Saída:

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

A tupla ainda contém as mesmas duas referências de lista — essa parte é imutável. Mas o objeto lista para o qual t[0] aponta foi mutado. Essa é uma fonte comum de confusão quando tuplas são usadas como chaves de dicionário; apenas tuplas completamente imutáveis (que não contêm listas, dicts ou outros objetos mutáveis) são hasháveis.

Escolhendo a Abordagem Correta

Para mais informações sobre como trabalhar com tuplas, consulte Access Tuples, Unpack Tuples, Loop Tuples e Tuple Methods.

Prática