Python Tuplas

Você já conhece as listas: uma fila de valores que pode crescer, encolher e mudar. Só que alguns grupos de valores nunca deveriam mudar: os sete dias da semana, os meses do ano, a data em que a Ana nasceu, a localização da padaria no mapa. Para esses casos o Python tem a tupla (em inglês, tuple): uma sequência de valores, na ordem, que depois de criada não muda mais.

A ideia: uma lista escrita a caneta

Pense na lista de compras da Ana, escrita a lápis: ela apaga um item, acrescenta outro, troca a ordem. Isso é uma lista do Python. Agora pense no calendário pendurado na cozinha, impresso: os dias da semana estão lá, sempre os mesmos sete, sempre na mesma ordem. Ninguém apaga a "quarta-feira". Isso é uma tupla.

As duas guardam vários valores em ordem e você lê os itens do mesmo jeito. A diferença é só uma: a lista pode ser alterada, a tupla não. Em Python se diz que a lista é mutável (pode mudar) e a tupla é imutável (não pode mudar).

1. Criando uma tupla

dias = ("seg", "ter", "qua", "qui", "sex", "sáb", "dom")
print(dias)
print(type(dias))
print(len(dias))

dias

O nome da variável que vai guardar a tupla.

( … )

Os parênteses envolvem os itens. Na lista são colchetes; na tupla, parênteses.

"seg", "ter", …

Os itens, separados por vírgula. Podem ser de qualquer tipo: textos, números, até outras tuplas.

type(dias)

Mostra o tipo do valor (aula Descobrindo o Tipo). Para uma tupla, o tipo se chama tuple.

len(dias)

Quantos itens a tupla tem.

$ python3 dias.py
('seg', 'ter', 'qua', 'qui', 'sex', 'sáb', 'dom')
<class 'tuple'>
7

Repare que o print mostra a tupla com parênteses e com aspas simples, mesmo que você tenha escrito aspas duplas. É só o jeito de o Python mostrar textos dentro de uma tupla ou lista; o valor é o mesmo.

2. Lendo os itens: igual à lista

Tudo o que serve para ler uma lista serve para ler uma tupla: índice começando do zero, índice negativo contando do fim, fatias, in e o laço for.

dias = ("seg", "ter", "qua", "qui", "sex", "sáb", "dom")
print(dias[0])
print(dias[-1])
print(dias[1:5])
print("sáb" in dias)
for dia in dias:
    print("Hoje é", dia)

$ python3 acessar.py
seg
dom
('ter', 'qua', 'qui', 'sex')
True
Hoje é seg
Hoje é ter
Hoje é qua
Hoje é qui
Hoje é sex
Hoje é sáb
Hoje é dom

Se índices e fatias ainda são novidade, a aula Acessando Itens explica cada um com calma: lá é com listas, mas funciona igualzinho.

3. Tuplas guardam coisas que andam juntas

O uso mais comum da tupla não é guardar uma fila comprida de coisas iguais, e sim juntar poucos valores que formam uma coisa só: a latitude e a longitude de um lugar, o dia, o mês e o ano de uma data.

padaria = (-5.0892, -42.8019)
print("Latitude:", padaria[0])
print("Longitude:", padaria[1])
aniversario = (12, 3, 1990)
print(f"Nasci em {aniversario[0]}/{aniversario[1]}/{aniversario[2]}")

$ python3 coordenada.py
Latitude: -5.0892
Longitude: -42.8019
Nasci em 12/3/1990

Uma coordenada sempre tem dois números; uma data, três. Não faz sentido "acrescentar um item" a uma data. A tupla deixa isso claro para quem lê o código: esses valores andam juntos e ficam como estão. Na próxima aula, Desempacotamento, você vai ver um jeito mais bonito de tirar cada valor da tupla em vez de usar [0], [1], [2].

4. A tupla de um item só: a vírgula é que manda

Aqui está a pegadinha mais famosa das tuplas. Quem faz a tupla não são os parênteses, é a vírgula. Os parênteses também servem para outra coisa em Python: agrupar contas, como em (2 + 3) * 4. Então, quando há um item só, o Python precisa de uma pista para saber que você quer uma tupla.

sem_virgula = ("arroz")
com_virgula = ("arroz",)
print(sem_virgula, type(sem_virgula))
print(com_virgula, type(com_virgula))
numero = (5)
tupla = (5,)
print(numero, type(numero))
print(tupla, type(tupla))

$ python3 um_item.py
arroz <class 'str'>
('arroz',) <class 'tuple'>
5 <class 'int'>
(5,) <class 'tuple'>

("arroz")

Parênteses em volta de um texto, só isso. O Python trata como se fosse "arroz" sozinho: o tipo é str (texto).

("arroz",)

Com a vírgula depois do item, agora sim é uma tupla de um item. O próprio Python, ao mostrar, escreve a vírgula: ('arroz',).

(5)

É só o número 5 entre parênteses, como numa conta: tipo int.

(5,)

Uma tupla com um item, o número 5.

No modo interativo dá para ver isso rapidinho. Cada linha com >>> é o que a Ana digitou; a linha de baixo é a resposta do Python:

$ python3
Python 3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> (5)
5
>>> (5,)
(5,)
>>> type((5,))
<class 'tuple'>
>>> 5,
(5,)
>>> exit()

A última linha mostra que, com a vírgula, nem os parênteses são necessários: 5, já é uma tupla.

frutas = ("manga")
print(frutas, type(frutas))

frutas = ("manga",)
print(frutas, type(frutas))

5. Sem parênteses e vazia

Como é a vírgula que faz a tupla, você pode criar uma sem parênteses nenhum. E para uma tupla vazia, sem itens, há duas formas: () ou tuple().

ponto = 3, 4
print(ponto)
print(type(ponto))
um = "café",
print(um)
vazia = ()
tambem_vazia = tuple()
print(vazia, len(vazia))
print(tambem_vazia, len(tambem_vazia))

$ python3 sem_parenteses.py
(3, 4)
<class 'tuple'>
('café',)
() 0
() 0

6. A tupla não muda

Agora a característica principal. A Ana resolve escrever o nome completo do primeiro dia e tenta trocar o item, como faria numa lista:

dias = ("seg", "ter", "qua", "qui", "sex", "sáb", "dom")
dias[0] = "segunda"
print(dias)

$ python3 mudar.py
Traceback (most recent call last):
  File "/home/ana/mudar.py", line 2, in <module>
    dias[0] = "segunda"
    ~~~~^^^
TypeError: 'tuple' object does not support item assignment

É a primeira vez que este erro aparece no guia; vamos ler linha por linha:

Traceback (most recent call last):

"Rastro (a chamada mais recente por último)". O Python avisa que deu erro e vai mostrar onde.

File "/home/ana/mudar.py", line 2, in <module>

O erro está no arquivo mudar.py, na linha 2, no corpo principal do programa (<module>).

dias[0] = "segunda"

A linha que deu problema.

~~~~^^^

Os tils e acentos circunflexos apontam o pedaço exato: dias[0], o lugar onde você tentou guardar um valor.

TypeError: 'tuple' object does not support item assignment

"Erro de tipo: um objeto do tipo tupla não aceita atribuição de item". Em português claro: você não pode trocar um item de uma tupla. O print da linha 3 nem chegou a rodar: o programa parou no erro.

Pela mesma razão, a tupla não tem append(), remove(), sort() nem nenhum outro método que mude a lista no lugar. Se você tentar:

dias = ("seg", "ter", "qua")
dias.append("qui")

$ python3 append.py
Traceback (most recent call last):
  File "/home/ana/append.py", line 2, in <module>
    dias.append("qui")
    ^^^^^^^^^^^
AttributeError: 'tuple' object has no attribute 'append'

AttributeError quer dizer "erro de atributo": a tupla não tem nada chamado append. Não é que o append falhou; ele nem existe para tuplas.

Então para que serve algo que não muda?

• Segurança: se um valor não deveria mudar (os dias da semana, uma data), guardá-lo numa tupla impede que um pedaço do programa o altere por engano. Se alguém tentar, o Python reclama na hora, em vez de deixar o erro escondido.
• Clareza: quem lê (12, 3, 1990) entende que é um registro fixo, não uma fila que vai crescer.
• Chave de dicionário: só valores que não mudam podem ser chave de um dicionário. Uma tupla pode; uma lista não. Você vai ver isso em Dicionários.

7. Os dois métodos da tupla: count() e index()

Como a tupla não muda, sobram só dois métodos, os dois de consulta. E as funções que só leem (min, max, sum, sorted) funcionam normalmente.

notas = (7, 9, 7, 10, 7, 8)
print(notas.count(7))
print(notas.index(10))
print(notas.index(7))
print(min(notas), max(notas), sum(notas))
print(sorted(notas))

$ python3 metodos.py
3
3
0
7 10 48
[7, 7, 7, 8, 9, 10]

notas.count(7)

"Contar": quantas vezes o 7 aparece. Três vezes.

notas.index(10)

"Índice": em que posição está o 10. Na posição 3 (lembre: começa do 0).

notas.index(7)

Quando o item aparece mais de uma vez, index devolve a posição da primeira vez: 0.

min, max, sum

Menor, maior e soma. Funcionam com tuplas porque só leem os itens.

sorted(notas)

Devolve os itens em ordem, mas numa lista nova (repare nos colchetes). A tupla notas continua como estava.

8. Convertendo: tupla ⇄ lista

E se você realmente precisar mudar? Converta a tupla em lista com list(), mude a lista, e converta de volta com tuple():

cores = ("vermelho", "verde", "azul")
lista = list(cores)
lista.append("amarelo")
cores = tuple(lista)
print(cores)

$ python3 converter.py
('vermelho', 'verde', 'azul', 'amarelo')

1. list(cores) cria uma lista nova com os mesmos itens da tupla.
2. A lista aceita append: agora ela tem quatro cores.
3. tuple(lista) cria uma tupla nova com os itens da lista, e a variável cores passa a guardá-la.

Outro jeito de "aumentar" uma tupla é juntar duas com +. O resultado é uma tupla nova; as originais ficam como estavam. O * repete:

manha = ("café", "pão")
tarde = ("bolo",)
lanches = manha + tarde
print(lanches)
print(manha)
print(("oi",) * 3)

$ python3 juntar.py
('café', 'pão', 'bolo')
('café', 'pão')
('oi', 'oi', 'oi')

dias = ("seg", "ter", "qua")
dias[0] = "segunda"
print(dias)

dias = ("seg", "ter", "qua")
lista = list(dias)
lista[0] = "segunda"
dias = tuple(lista)
print(dias)

Formas diferentes de criar a mesma tupla

Lista ou tupla?

Quando dá errado

compras = ("arroz")
print(len(compras))
for item in compras:
    print(item)

$ python3 len_int.py
5
a
r
r
o
z

dias = ("seg", "ter", "qua", "qui", "sex", "sáb", "dom")
print(dias[7])

$ python3 fora.py
Traceback (most recent call last):
  File "/home/ana/fora.py", line 2, in <module>
    print(dias[7])
          ~~~~^^^
IndexError: tuple index out of range

notas = (7, 9, 7, 10, 7, 8)
print(notas.index(5))

$ python3 index_erro.py
Traceback (most recent call last):
  File "/home/ana/index_erro.py", line 2, in <module>
    print(notas.index(5))
          ~~~~~~~~~~~^^^
ValueError: tuple.index(x): x not in tuple

manha = ("café", "pão")
lanches = manha + "bolo"

$ python3 juntar_erro.py
Traceback (most recent call last):
  File "/home/ana/juntar_erro.py", line 2, in <module>
    lanches = manha + "bolo"
              ~~~~~~^~~~~~~~
TypeError: can only concatenate tuple (not "str") to tuple

Referência rápida

Exercícios

Missão final: o boletim do bimestre

notas = (8, 10, 6, 10, 9)
print("Notas 10:", "?")
print("Maior nota:", "?")
print("Primeira nota:", "?")

notas = (8, 10, 6, 10, 9)
print("Notas 10:", notas.count(10))
print("Maior nota:", max(notas))
print("Primeira nota:", notas[0])

Resumo

• A tupla é uma sequência em ordem, escrita com parênteses: ("seg", "ter"). O tipo dela é tuple.
• Lê-se igual à lista: t[0], t[-1], fatias, len, in, for.
• Quem faz a tupla é a vírgula: (5) é o número 5; (5,) é uma tupla.
• A tupla é imutável: trocar um item dá TypeError, e não existem append, remove nem sort.
• Os únicos métodos são count() e index().
• Para mudar, converta: list(t), mude, tuple(lista). Ou junte com +, que cria uma tupla nova.
• Use tupla para valores fixos ou que formam uma coisa só (data, coordenada); use lista para o que vai mudar.