Tuplas em Python: Guia Completo com Exemplos

1
2
3
4

ponto = (3, 4)
x, y = ponto              # desempacotamento
print(x + y)              # 7
print(type(("a",)))       # <class 'tuple'>  (a vírgula cria a tupla)

Salve salve Pythonista!

As tuplas são uma das quatro estruturas de dados embutidas do Python, ao lado das listas, dos dicionários e dos sets. À primeira vista, parecem só “listas com parênteses”, mas a imutabilidade muda muita coisa: memória, desempenho, uso como chave de dicionário e até algumas pegadinhas clássicas de prova.

Neste guia você vai ver como criar tuplas (inclusive a de um elemento só), acessar e fatiar, entender de verdade o que é a imutabilidade, desempacotar valores com *resto, comparar tupla e lista com medições reais de memória, usar namedtuple e aplicar tuplas como chave de dicionário. No final há erros comuns com a mensagem real e exercícios resolvidos.

Todos os exemplos foram executados em Python 3.10 (e as mensagens de erro conferidas também no 3.11 e no 3.13).

Então… Bora pro post!

Vá Direto ao Assunto…

• O que é uma tupla em Python
• Como criar uma tupla
• Acessando itens: índice, fatiamento e métodos
• Imutabilidade: o que não dá para fazer com uma tupla
• Desempacotamento de tuplas e o *resto
• Tupla vs lista: diferenças, memória e quando usar
• namedtuple: tuplas com nomes
• Tupla como chave de dicionário
• Erros comuns
• Exercícios resolvidos

O que é uma tupla em Python

Uma tupla é uma sequência de valores separados por vírgula, normalmente entre parênteses. Ela tem três características:

• Ordenada: os itens mantêm a posição em que foram colocados, e você acessa cada um pelo índice.
• Imutável: depois de criada, não é possível adicionar, remover ou substituir itens.
• Heterogênea e com repetição: aceita tipos diferentes e valores duplicados.

A documentação oficial descreve as tuplas na seção Tuplas e sequências do tutorial e na referência de tipos de sequência.

Como criar uma tupla

Existem várias formas de criar tuplas:

1
2
3
4
5
6
7
8
9
10

vazia = ()
cores = ("vermelho", "verde", "azul")
mista = (1, "dois", 3.0, True)
sem_parenteses = 10, 20, 30
de_lista = tuple([1, 2, 3])
de_string = tuple("abc")

print(vazia, cores, mista)
print(sem_parenteses, type(sem_parenteses))
print(de_lista, de_string)

Saída:

1
2
3

() ('vermelho', 'verde', 'azul') (1, 'dois', 3.0, True)
(10, 20, 30) <class 'tuple'>
(1, 2, 3) ('a', 'b', 'c')

Repare na linha 4: 10, 20, 30 sem parênteses também é uma tupla. Isso revela um detalhe importante: quem cria a tupla é a vírgula, não os parênteses. Os parênteses só agrupam (e são obrigatórios na tupla vazia e quando a tupla está dentro de outra expressão, como numa chamada de função). A função tuple() converte qualquer iterável (lista, string, range) em tupla.

Tupla com um único elemento: a vírgula obrigatória

Essa é a pegadinha número um sobre tuplas:

1
2
3
4
5
6
7

nao_e_tupla = ("Python")
e_tupla = ("Python",)
tambem = "Python",

print(type(nao_e_tupla), type(e_tupla), type(tambem))
print(len(e_tupla))
print((5) * 2, (5,) * 2)

Saída:

1
2
3

<class 'str'> <class 'tuple'> <class 'tuple'>
1
10 (5, 5)

Sem a vírgula, ("Python") é só uma string entre parênteses, e (5) * 2 é uma multiplicação comum que dá 10. Com a vírgula, (5,) * 2 repete a tupla e dá (5, 5). Sempre que precisar de uma tupla de um item, escreva (item,).

Acessando itens: índice, fatiamento e métodos

Por ser uma sequência, a tupla aceita tudo que é “de leitura” numa lista: índice positivo e negativo, fatiamento, len(), in, concatenação e repetição.

1
2
3
4
5
6
7
8
9

estados = ("BA", "SP", "RJ", "MG", "RS")

print(estados[0], estados[-1])
print(estados[1:3])
print(estados[::-1])
print(len(estados), "SP" in estados)
print(estados.index("RJ"), (1, 2, 1, 1).count(1))
print((1, 2) + (3,), ("ha",) * 3)
print(min((4, 1, 9)), max((4, 1, 9)), sum((4, 1, 9)), sorted((4, 1, 9)))

Saída:

1
2
3
4
5
6
7

BA RS
('SP', 'RJ')
('RS', 'MG', 'RJ', 'SP', 'BA')
5 True
2 3
(1, 2, 3) ('ha', 'ha', 'ha')
1 9 14 [1, 4, 9]

Alguns pontos para fixar:

• O fatiamento funciona igual ao das listas (o fim é exclusivo) e devolve uma nova tupla. Se quiser revisar a sintaxe, veja o post sobre fatiamento (slicing) de listas.
• A tupla tem só dois métodos: index(), que devolve a posição da primeira ocorrência, e count(), que conta quantas vezes um valor aparece.
• sorted() aceita uma tupla, mas devolve uma lista (repare nos colchetes na última linha).
• Para percorrer, use for item in tupla: como em qualquer sequência (mais sobre isso no post de loops com for).

Imutabilidade: o que não dá para fazer com uma tupla

Imutável significa que as posições da tupla sempre apontam para os mesmos objetos. Qualquer tentativa de trocar, adicionar ou remover gera erro:

1
2

cores = ("vermelho", "verde", "azul")
cores[0] = "preto"

1

TypeError: 'tuple' object does not support item assignment

E cores.append("preto") gera AttributeError: 'tuple' object has no attribute 'append', porque o método nem existe.

Se você precisa de uma versão modificada, crie uma tupla nova:

1
2
3
4
5
6
7
8
9

cores = ("vermelho", "verde", "azul")

cores = cores + ("preto",)        # concatena e reatribui
print(cores)

temporaria = list(cores)           # converte para lista
temporaria.remove("verde")
cores = tuple(temporaria)          # volta para tupla
print(cores)

Saída:

1
2

('vermelho', 'verde', 'azul', 'preto')
('vermelho', 'azul', 'preto')

Note que o nome cores passou a apontar para outra tupla; a original não foi alterada. Se você vive convertendo para lista e de volta, provavelmente o dado deveria ser uma lista desde o início.

A pegadinha da lista dentro da tupla

A imutabilidade é “rasa”. A tupla garante que cada posição aponta sempre para o mesmo objeto, mas não impede que esse objeto, se for mutável, seja alterado por dentro:

1
2
3

aluno = ("Ana", [7.0, 8.5])
aluno[1].append(10.0)      # altera a LISTA, não a tupla
print(aluno)

Saída:

1

('Ana', [7.0, 8.5, 10.0])

Funcionou, porque a posição 1 continua sendo a mesma lista. Já aluno[1] = [0] falha com TypeError, porque tentaria colocar outro objeto na posição.

E agora a versão mais cruel, que aparece em entrevistas:

1
2
3
4
5
6

t = (1, [2, 3])
try:
    t[1] += [4]
except TypeError as erro:
    print("TypeError:", erro)
print(t)

Saída:

1
2

TypeError: 'tuple' object does not support item assignment
(1, [2, 3, 4])

Deu erro e alterou a lista. O += faz duas coisas: primeiro estende a lista no lugar (isso funciona) e depois tenta atribuir o resultado de volta em t[1] (isso falha). Moral: evite colocar objetos mutáveis dentro de tuplas; se precisar, use t[1].append(4) ou t[1].extend([4]), que não tentam reatribuir.

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Desempacotamento de tuplas e o *resto

Desempacotar é distribuir os itens de uma tupla em variáveis, numa linha só. É um dos recursos mais usados do Python:

1
2
3
4
5
6
7
8
9

nome, idade, cidade = ("Bia", 25, "Recife")
print(nome, idade, cidade)

a, b = 1, 2
a, b = b, a                 # troca sem variável auxiliar
print(a, b)

nome, _, cidade = ("Bia", 25, "Recife")   # _ = valor que não interessa
print(nome, cidade)

Saída:

1
2
3

Bia 25 Recife
2 1
Bia Recife

A troca a, b = b, a funciona porque o lado direito monta a tupla (2, 1) antes da atribuição, que então é desempacotada.

Quando o número de itens varia, use o asterisco para capturar “o resto” (PEP 3132):

1
2
3
4
5
6
7
8
9
10
11

primeiro, *resto = (10, 20, 30, 40)
print(primeiro, resto)

*inicio, ultimo = (10, 20, 30, 40)
print(inicio, ultimo)

cabeca, *meio, cauda = (1, 2, 3, 4, 5)
print(cabeca, meio, cauda)

x, *vazio = (1,)
print(x, vazio)

Saída:

1
2
3
4

10 [20, 30, 40]
[10, 20, 30] 40
1 [2, 3, 4] 5
1 []

Dois detalhes: a variável com * recebe sempre uma lista (mesmo vazia), e só pode haver um asterisco por atribuição.

Funções que retornam várias variáveis

Quando uma função faz return a, b, ela está devolvendo uma tupla, que você desempacota na chamada:

1
2
3
4
5
6
7
8

def min_max(numeros):
    return min(numeros), max(numeros)

resultado = min_max([4, 8, 1, 9])
print(resultado, type(resultado))

menor, maior = min_max([4, 8, 1, 9])
print(menor, maior)

Saída:

1
2

(1, 9) <class 'tuple'>
1 9

O desempacotamento também aparece o tempo todo em loops: for chave, valor in dicionario.items(): e for i, item in enumerate(lista): recebem tuplas a cada volta. Veja mais sobre retorno de valores no post de funções em Python.

Tupla vs lista: diferenças, memória e quando usar

Vamos medir a memória com sys.getsizeof(), que devolve o tamanho do objeto em bytes (só da estrutura, sem contar os itens apontados):

1
2
3
4
5
6
7
8
9
10

import sys

print(sys.getsizeof([1, 2, 3, 4, 5]), sys.getsizeof((1, 2, 3, 4, 5)))
print(sys.getsizeof([]), sys.getsizeof(()))
print(sys.getsizeof(list(range(1000))), sys.getsizeof(tuple(range(1000))))

crescendo = []
for i in range(5):
    crescendo.append(i)
print(sys.getsizeof(crescendo))

Saída (Python 3.10, 64 bits; os mesmos números no 3.11 e no 3.13):

1
2
3
4

104 80
56 40
8056 8040
120

A tupla de 5 itens ocupa 80 bytes contra 104 da lista. A diferença fixa vem do cabeçalho extra da lista, que precisa guardar a capacidade alocada para poder crescer. E repare na última linha: a lista montada com append ocupa 120 bytes, porque o Python reserva espaço extra a cada crescimento para os próximos append ficarem rápidos. A tupla nunca cresce, então nunca reserva sobra.

Há também ganho de tempo na criação. Uma tupla literal só com constantes é montada uma vez na compilação, enquanto a lista é construída a cada execução. Medindo com python3 -m timeit na minha máquina (Python 3.10):

1
2
3
4

$ python3 -m timeit "(1, 2, 3, 4, 5)"
50000000 loops, best of 5: 7.34 nsec per loop
$ python3 -m timeit "[1, 2, 3, 4, 5]"
10000000 loops, best of 5: 33.6 nsec per loop

Os números absolutos mudam de máquina para máquina, mas a ordem de grandeza se mantém. Na prática, porém, a escolha entre tupla e lista deve ser pelo significado do dado, não por nanossegundos:

Regra de bolso: se faz sentido dizer “o primeiro campo é o nome e o segundo é a idade”, use tupla; se faz sentido dizer “uma lista de nomes”, use lista. Para as operações de lista, veja o post sobre manipulação de listas no Python.

Entender quando usar tupla ou lista é o tipo de decisão que fica automática com prática de verdade - e é isso que você treina, do básico ao avançado, na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

namedtuple: tuplas com nomes

Com ponto[0] e ponto[1], o leitor precisa lembrar o que é cada posição. A namedtuple, do módulo collections, resolve isso dando nome aos campos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from collections import namedtuple

Ponto = namedtuple("Ponto", ["x", "y"])
p = Ponto(3, 4)

print(p)
print(p.x, p[1])            # por nome ou por índice
x, y = p                    # desempacota como tupla comum
print(x + y)

p2 = p._replace(x=10)       # "altera" criando uma nova
print(p2, p)
print(p._asdict())
print(isinstance(p, tuple))

Saída:

1
2
3
4
5
6

Ponto(x=3, y=4)
3 4
7
Ponto(x=10, y=4) Ponto(x=3, y=4)
{'x': 3, 'y': 4}
True

A namedtuple continua sendo uma tupla (imutável, leve, desempacotável), só que mais legível. Tentar p.x = 10 gera AttributeError: can't set attribute. Você também pode definir valores padrão com defaults:

1
2

Aluno = namedtuple("Aluno", "nome curso nota", defaults=[0.0])
print(Aluno("Ana", "Python"))

Saída:

1

Aluno(nome='Ana', curso='Python', nota=0.0)

Se você usa type hints, a versão moderna é typing.NamedTuple, com sintaxe de classe:

1
2
3
4
5
6
7
8
9
10

from typing import NamedTuple

class Produto(NamedTuple):
    nome: str
    preco: float
    estoque: int = 0

cafe = Produto("Café", 18.9)
print(cafe)
print(cafe.preco * 2)

Saída:

1
2

Produto(nome='Café', preco=18.9, estoque=0)
37.8

Precisa de campos que mudam? Aí o caminho são as dataclasses. O post sobre o pacote collections mostra outras estruturas do mesmo módulo.

Tupla como chave de dicionário

Chaves de dicionário (e itens de set) precisam ser hashable: o Python calcula um número a partir do valor para encontrá-lo rápido, e esse número não pode mudar. Listas mudam, então não servem. Tuplas de valores imutáveis servem, o que as torna perfeitas para chaves compostas:

1
2
3
4
5
6
7
8
9
10
11

distancias = {("SP", "RJ"): 430, ("SP", "BH"): 586}
print(distancias[("SP", "RJ")])
print(distancias["SP", "BH"])       # os parênteses são opcionais

tabuleiro = {}
tabuleiro[(0, 0)] = "X"
tabuleiro[1, 1] = "O"
print(tabuleiro)

visitados = {(0, 0), (0, 1), (0, 0)}
print(visitados, len(visitados))

Saída:

1
2
3
4

430
586
{(0, 0): 'X', (1, 1): 'O'}
{(0, 1), (0, 0)} 2

Coordenadas de jogo, pares origem-destino, cache de resultados por combinação de parâmetros: tudo isso fica natural com tuplas como chave. O set visitados descartou o (0, 0) repetido, como explicamos no post de sets. Mas atenção: basta um item mutável para a tupla deixar de ser hashable, como você vai ver nos erros comuns logo abaixo.

Outro bônus: tuplas se comparam item a item, da esquerda para a direita. Por isso sorted() numa lista de tuplas ordena pelo primeiro campo e desempata pelo segundo, e key=lambda a: (-a[1], a[0]) ordena por nota decrescente e nome crescente numa linha só (veja funções lambda).

Erros comuns

Estes são os erros que mais aparecem com tuplas, com a última linha real do traceback.

Tentar alterar um item (TypeError)

1
2

cores = ("azul", "verde")
cores[0] = "preto"

1

TypeError: 'tuple' object does not support item assignment

Correção: tuplas são imutáveis. Crie uma nova (cores = ("preto",) + cores[1:]) ou, se o dado precisa mudar com frequência, use uma lista.

Esquecer a vírgula na tupla de um elemento (TypeError)

1
2

numero = (5)
print(numero[0])

1

TypeError: 'int' object is not subscriptable

Correção: (5) é o inteiro 5. Escreva numero = (5,).

Quantidade errada de variáveis no desempacotamento (ValueError)

1

a, b = (1, 2, 3)

1

ValueError: too many values to unpack (expected 2)

O inverso, a, b, c = (1, 2), gera ValueError: not enough values to unpack (expected 3, got 2). Correção: use o mesmo número de variáveis e itens, ou capture o excedente com a, *b = (1, 2, 3).

Usar tupla com lista dentro como chave (TypeError)

1

rotas = {("SP", ["RJ", "BH"]): 2}

1

TypeError: unhashable type: 'list'

Correção: converta a parte mutável em tupla: {("SP", ("RJ", "BH")): 2}.

Chamar métodos de lista numa tupla (AttributeError)

1
2

numeros = (3, 1, 2)
numeros.sort()

1

AttributeError: 'tuple' object has no attribute 'sort'

Correção: use sorted(numeros), que devolve uma lista nova, ou tuple(sorted(numeros)) se quiser continuar com uma tupla.

Exercícios resolvidos

Tente resolver cada exercício antes de abrir a solução. Todos os códigos foram executados e as saídas conferidas.

Exercício 1. Dada a tupla notas = (7.5, 8.0, 6.5, 9.0), calcule e imprima a média com duas casas decimais.

1
2
3

notas = (7.5, 8.0, 6.5, 9.0)
media = sum(notas) / len(notas)
print(f"Média: {media:.2f}")

Exercício 2. Escreva uma função estatisticas(numeros) que retorne o menor valor, o maior e a média, e desempacote o resultado em três variáveis para a lista [12, 5, 30, 17].

1
2
3
4
5

def estatisticas(numeros):
    return min(numeros), max(numeros), sum(numeros) / len(numeros)

menor, maior, media = estatisticas([12, 5, 30, 17])
print(menor, maior, media)

Exercício 3. Dado ranking = ("Ana", "Bia", "Caio", "Davi", "Eva"), separe em uma linha a campeã, a vice e os demais colocados.

1
2
3
4
5

ranking = ("Ana", "Bia", "Caio", "Davi", "Eva")
campeao, vice, *demais = ranking
print("Campeã:", campeao)
print("Vice:", vice)
print("Demais:", demais)

1
2
3

Campeã: Ana
Vice: Bia
Demais: ['Caio', 'Davi', 'Eva']

Exercício 4. Gere, a partir de frutas = ("maçã", "banana", "uva", "banana"), uma nova tupla sem nenhuma "banana".

1
2
3

frutas = ("maçã", "banana", "uva", "banana")
sem_banana = tuple(fruta for fruta in frutas if fruta != "banana")
print(sem_banana)

Exercício 5. Dada a lista de coordenadas [(0, 0), (1, 2), (0, 0), (3, 1), (1, 2), (0, 0)], conte quantas vezes cada ponto aparece usando um dicionário e mostre o ponto mais visitado.

1
2
3
4
5
6

pontos = [(0, 0), (1, 2), (0, 0), (3, 1), (1, 2), (0, 0)]
contagem = {}
for ponto in pontos:
    contagem[ponto] = contagem.get(ponto, 0) + 1
print(contagem)
print(max(contagem, key=contagem.get))

1
2

{(0, 0): 3, (1, 2): 2, (3, 1): 1}
(0, 0)

Exercício 6. Crie uma namedtuple chamada Livro com os campos titulo, autor e ano, monte uma estante com quatro livros e imprima, em ordem alfabética de título, apenas os publicados depois de 2000.

1
2
3
4
5
6
7
8
9
10
11
12

from collections import namedtuple

Livro = namedtuple("Livro", ["titulo", "autor", "ano"])
estante = [
    Livro("Aprendendo Python", "Ana Souza", 2015),
    Livro("Dom Casmurro", "Machado de Assis", 1899),
    Livro("Python na Prática", "Carlos Lima", 2015),
    Livro("Algoritmos Essenciais", "Paulo Mendes", 1999),
]
recentes = sorted((l for l in estante if l.ano > 2000), key=lambda l: l.titulo)
for livro in recentes:
    print(f"{livro.titulo} ({livro.ano}) - {livro.autor}")

1
2

Aprendendo Python (2015) - Ana Souza
Python na Prática (2015) - Carlos Lima

Exercício 7 (questão de prova). Qual é a saída do código abaixo?

1
2
3

t = (1, 2, [3, 4])
t[2].append(5)
print(t)

a) TypeError: 'tuple' object does not support item assignment
b) (1, 2, [3, 4, 5])
c) (1, 2, [3, 4])
d) (1, 2, [3, 4], 5)

Exercício 8 (questão de prova). Qual das instruções abaixo cria uma tupla com um único elemento?

a) t = (1)
b) t = [1]
c) t = (1,)
d) t = tuple(1)

1
2

print(type((1)), type((1,)))
tuple(1)

1
2

<class 'int'> <class 'tuple'>
TypeError: 'int' object is not iterable

Quer mais prática? Veja a nossa lista de exercícios de Python. E, se quiser aprender com projetos guiados, do básico ao avançado, conheça o nosso curso de Python completo, a Jornada Python.

Conclusão

Neste guia de Tuplas em Python, você aprendeu:

✅ Criação - Com parênteses, sem parênteses e com tuple()
✅ Um elemento - A vírgula é obrigatória: (5,)
✅ Imutabilidade - E a pegadinha da lista dentro da tupla
✅ Desempacotamento - Inclusive com *resto
✅ Tupla vs lista - Memória medida e quando usar cada uma
✅ namedtuple - Campos com nome e continua sendo tupla
✅ Chave de dicionário - Chaves compostas com tuplas imutáveis

Principais lições:

• Tupla para registros fixos, lista para coleções que mudam
• Quem cria a tupla é a vírgula, não o parêntese
• Imutável não quer dizer que os objetos dentro dela sejam imutáveis
• return a, b devolve uma tupla

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Vinícius Ramos em 19/06/2026

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•