Tuplas em Python: Um Guia Completo

Uma tupla é uma sequência ordenada e imutável em Python. Ela pode conter itens de qualquer tipo — inteiros, strings, floats, outras tuplas — e esses itens mantêm sua posição permanentemente após a criação da tupla. Esta página cobre tudo o que você precisa para trabalhar com tuplas: como criá-las, lê-las, combiná-las e saber quando escolhê-las em vez de uma lista Python.

O Que É uma Tupla em Python?

Uma tupla é escrita como uma sequência separada por vírgulas dentro de parênteses:

Três propriedades fundamentais definem as tuplas:

• Ordenada — os itens têm uma posição fixa (índice 0, 1, 2, …).
• Imutável — não é possível alterar, adicionar ou remover itens após a criação.
• Permite duplicatas — o mesmo valor pode aparecer mais de uma vez.

Tuplas vs. Listas

Tanto as tuplas quanto as listas armazenam sequências ordenadas, mas a mutabilidade delas difere fundamentalmente:

Use uma tupla quando os dados não devem mudar — constantes de configuração, valores de retorno de funções que carregam múltiplas informações relacionadas ou chaves de dicionário.

Criando Tuplas

Sintaxe básica

Liste valores separados por vírgulas dentro de parênteses:

Tipos mistos

Uma tupla pode conter itens de tipos diferentes, inclusive outras tuplas:

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

Tupla vazia

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

Tupla com um único elemento

Este é um erro comum. Sem a vírgula no final, Python trata os parênteses como agrupamento, não como uma tupla:

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

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

A vírgula no final é o que torna uma tupla — sempre inclua-a em tuplas com um único elemento.

Criando a partir de um iterável

Use o construtor embutido tuple() para converter qualquer iterável em uma tupla:

Tupla sem parênteses (empacotamento)

Python permite criar uma tupla simplesmente listando valores separados por vírgulas — os parênteses são opcionais:

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

Acessando Elementos da Tupla

Indexação positiva

Os índices começam em 0 para o primeiro elemento:

Indexação negativa

Índices negativos contam a partir do final. -1 é o último elemento:

Fatiamento

Use [start:stop:step] para extrair uma sub-tupla. O índice stop é excluído:

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 aninhadas

Acesse elementos aninhados encadeando colchetes de índice:

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

Verificando pertencimento

O operador in verifica se um valor existe em uma tupla:

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

Para mais técnicas de indexação e fatiamento, consulte Acessar Tuplas.

Imutabilidade de Tuplas

Uma vez criada, os itens de uma tupla não podem ser alterados:

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

Se você precisar de uma versão modificada, construa uma nova tupla a partir de fatias e concatenação:

Observe que uma tupla pode conter objetos mutáveis como listas. A própria tupla é imutável (você não pode trocar a referência da lista), mas a lista dentro ainda pode ser modificada.

Consulte Atualizar Tuplas para uma discussão completa sobre alternativas.

Operações com Tuplas

Concatenação com +

Juntar duas tuplas com + cria uma nova tupla:

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

Repetição com *

Repita o conteúdo de uma tupla com *:

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

Para todas as estratégias de junção, consulte Juntar Tuplas.

Métodos de Tuplas

As tuplas têm exatamente dois métodos embutidos, pois a imutabilidade exclui qualquer coisa que modificaria a coleção.

count()

Retorna o número de vezes que um valor aparece:

index()

Retorna o índice da primeira ocorrência de um valor. Lança ValueError se o valor não for encontrado:

Consulte Métodos de Tuplas para uma referência completa.

Funções Embutidas com Tuplas

As funções embutidas do Python funcionam em qualquer iterável, incluindo tuplas:

sorted() sempre retorna uma lista, mesmo quando recebe uma tupla como entrada. Envolva com tuple() se precisar de uma tupla ordenada de volta.

Desempacotamento de Tuplas

O desempacotamento atribui cada elemento de uma tupla a uma variável separada em uma única instrução:

Desempacotamento estendido com *

Uma variável com asterisco absorve qualquer número de elementos restantes em uma lista:

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

Trocando variáveis

O desempacotamento de tuplas torna a troca de variáveis uma operação de uma linha — sem necessidade de variável temporária:

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

Consulte Desempacotar Tuplas para mais padrões, incluindo desempacotamento aninhado.

Iterando sobre uma Tupla

Um laço for visita cada elemento na ordem:

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

Use enumerate() quando você também precisar do índice:

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

Consulte Iterar sobre Tuplas para laços while, zip() e percurso de tuplas aninhadas.

Construindo Tuplas com Compreensões

Python não possui sintaxe de compreensão de tupla, mas você pode passar uma expressão geradora para tuple() para obter o mesmo resultado:

A expressão x**2 for x in my_list dentro de tuple() é um gerador — ele produz valores um de cada vez sem construir uma lista intermediária.

Quando Usar Tuplas

As tuplas se destacam em situações específicas:

• Múltiplos valores de retorno. Funções podem retornar vários valores de forma limpa como uma tupla: return x, y.
• Chaves de dicionário. Listas não podem ser chaves de dicionário porque são mutáveis; tuplas podem.
• Integridade dos dados. Se uma coleção não deve mudar — valores RGB, linha de banco de dados, coordenadas geográficas — uma tupla impõe isso no nível da linguagem.
• Leve vantagem de desempenho. A iteração e criação de tuplas são marginalmente mais rápidas do que operações com listas para os mesmos dados.

# 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ática