Tuplas em Python: quando e por que usar sequências imutáveis

Iniciante20 min5 exercícios60 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Listas em Python: criar, acessar, modificar e percorrer

0/5 exercícios

Pense em coordenadas de GPS. Uma localização como (40.7128, -74.0060) representa a cidade de Nova York. Se você mudasse sem querer um desses números, a localização apontaria para um lugar completamente diferente. Alguns dados não devem mudar depois de criados.

Datas funcionam do mesmo jeito. 1º de janeiro de 2025 é um fato fixo. Você não gostaria que o código alterasse essa data por acidente para 37 de fevereiro. Quando os dados precisam ficar travados, o Python oferece as tuplas.

Uma tupla é quase idêntica a uma lista, mas com uma diferença crucial: depois de criar uma tupla, você não pode alterá-la. Nada de adicionar, remover ou trocar itens. Neste tutorial, você vai ver por que essa limitação é, na verdade, um superpoder.

Como criar tuplas em Python

Você cria uma tupla colocando itens entre parênteses (), separados por vírgulas. Também dá para criar uma tupla sem parênteses: são as vírgulas que realmente fazem dela uma tupla.

Criando tuplas

# Tuple with parentheses

coordinates = (40.7128, -74.0060)

print(coordinates)

# Tuple without parentheses (commas do the work)

colors = 'red', 'green', 'blue'

print(colors)

# Single-item tuple NEEDS a trailing comma

single = (42,)

print(single) # (42,)

print(type(single)) # <class 'tuple'>

Saída

(40.7128, -74.006)
('red', 'green', 'blue')
(42,)
<class 'tuple'>

Tupla de um item ou expressão entre parênteses

# This is NOT a tuple

not_a_tuple = (42)

print(type(not_a_tuple)) # <class 'int'>

# This IS a tuple

is_a_tuple = (42,)

print(type(is_a_tuple)) # <class 'tuple'>

# Empty tuple

empty = ()

print(empty) # ()

print(len(empty)) # 0

Saída

<class 'int'>
<class 'tuple'>
()
0

Você também pode converter outras sequências em tuplas usando o construtor tuple(). Isso é útil quando você tem uma lista e quer "congelá-la" para que ninguém possa modificá-la.

Usando o construtor tuple()

# Convert a list to a tuple

fruit_list = ['apple', 'banana', 'cherry']

fruit_tuple = tuple(fruit_list)

print(fruit_tuple) # ('apple', 'banana', 'cherry')

# Convert a string to a tuple of characters

letters = tuple('hello')

print(letters) # ('h', 'e', 'l', 'l', 'o')

Saída

('apple', 'banana', 'cherry')
('h', 'e', 'l', 'l', 'o')

Acessando e fatiando elementos de uma tupla

Acessar os itens de uma tupla funciona exatamente como nas listas. Você usa colchetes com um número de índice. Índices positivos contam a partir do início; índices negativos contam a partir do fim.

Indexando tuplas

months = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun')

# Positive indexing

print(months[0]) # Jan

print(months[3]) # Apr

# Negative indexing

print(months[-1]) # Jun

print(months[-2]) # May

# Length

print(len(months)) # 6

Saída

Jan
Apr
Jun
May
6

O fatiamento também funciona do mesmo jeito. Você pode pegar um pedaço de uma tupla com tuple[start:end]. O resultado é uma nova tupla.

Fatiando tuplas

months = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun')

# Slice from index 1 to 4 (not including 4)

print(months[1:4]) # ('Feb', 'Mar', 'Apr')

# First three

print(months[:3]) # ('Jan', 'Feb', 'Mar')

# Last two

print(months[-2:]) # ('May', 'Jun')

# Every other month

print(months[::2]) # ('Jan', 'Mar', 'May')

Saída

('Feb', 'Mar', 'Apr')
('Jan', 'Feb', 'Mar')
('May', 'Jun')
('Jan', 'Mar', 'May')

Mas é aqui que as tuplas se diferenciam das listas. Se você tentar alterar um item, o Python vai gerar um TypeError. Tuplas são imutáveis: não podem ser modificadas depois de criadas.

Tuplas são imutáveis

colors = ('red', 'green', 'blue')

# This works fine - reading

print(colors[0]) # red

# This will CRASH - writing

# colors[0] = 'yellow' # TypeError: 'tuple' object does not support item assignment

# Uncomment the line above and run it to see the error!

Saída

red

Empacotamento e desempacotamento de tuplas

Empacotar (packing) é criar uma tupla atribuindo vários valores a uma única variável. Desempacotar (unpacking) é o contrário: tirar os valores de uma tupla e colocá-los em variáveis separadas. O desempacotamento é um dos recursos mais úteis do Python.

Empacotamento e desempacotamento

# Packing - multiple values into one tuple

person = 'Alice', 25, 'Engineer'

print(person) # ('Alice', 25, 'Engineer')

# Unpacking - one tuple into multiple variables

name, age, job = person

print(name) # Alice

print(age) # 25

print(job) # Engineer

Saída

('Alice', 25, 'Engineer')
Alice
25
Engineer

O número de variáveis à esquerda precisa ser igual ao número de itens da tupla. Se não for, o Python gera um ValueError.

Um uso clássico do desempacotamento é trocar os valores de duas variáveis sem precisar de uma variável temporária. A maioria das outras linguagens precisa de três linhas para isso; o Python faz em uma.

Trocando variáveis com desempacotamento de tupla

a = 10

b = 20

print(f'Before: a={a}, b={b}')

# Swap using tuple unpacking

a, b = b, a

print(f'After: a={a}, b={b}')

Saída

Before: a=10, b=20
After:  a=20, b=10

Você também pode usar um asterisco * para capturar os itens que sobram no desempacotamento. Isso se chama desempacotamento estendido, e ele devolve uma lista com os itens restantes.

Desempacotamento estendido com o operador asterisco

scores = (95, 87, 72, 68, 91)

# Grab the first, last, and everything in between

first, *middle, last = scores

print(first) # 95

print(middle) # [87, 72, 68]

print(last) # 91

Saída

95
[87, 72, 68]
91

Desempacotando tuplas em um laço for

students = [

('Alice', 95),

('Bob', 87),

('Charlie', 72),

]

for name, score in students:

print(f'{name} scored {score}')

Saída

Alice scored 95
Bob scored 87
Charlie scored 72

Tuplas ou listas: quando usar cada uma

Se tuplas são só listas que não podem ser alteradas, por que usá-las? Há três bons motivos: segurança, desempenho e chaves de dicionário.

Segurança: quando os dados não devem mudar, uma tupla impede alterações acidentais. Coordenadas de GPS, valores de cor RGB, registros de banco de dados: tudo isso são fatos fixos. Uma tupla deixa sua intenção clara.

Desempenho: tuplas são um pouco mais rápidas que listas e usam menos memória. Em coleções pequenas, isso quase não faz diferença, mas a diferença se acumula quando há milhões de registros.

Chaves de dicionário: tuplas podem ser usadas como chaves de dicionário porque são imutáveis. Listas não podem. Isso vai ser importante quando você estudar dicionários.

Use uma lista quando...

# Data that changes over time
shopping = ['milk', 'eggs']
shopping.append('bread')

# Collections you sort or filter
scores = [85, 92, 78]
scores.sort()

Use uma tupla quando...

# Fixed data that shouldn't change
coords = (40.7128, -74.0060)
rgb_red = (255, 0, 0)

# Returning multiple values
def get_name_age():
    return 'Alice', 25

Por dentro: por que as tuplas são mais rápidas que as listas

Como as tuplas são imutáveis, o Python pode fazer otimizações nos bastidores. O tamanho de uma tupla é fixado na criação, então o Python a guarda em um único bloco compacto. Uma lista carrega informações extras de controle para poder crescer, e muitas vezes reserva espaço de sobra para novos itens.

Comparando o uso de memória

import sys

# Compare memory usage

my_list = [1, 2, 3, 4, 5]

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

print(f'List size: {sys.getsizeof(my_list)} bytes')

print(f'Tuple size: {sys.getsizeof(my_tuple)} bytes')

Saída

List size:  52 bytes
Tuple size: 40 bytes

As tuplas também aceitam todas as operações que não modificam a sequência. Você pode usar count() para contar ocorrências, index() para encontrar a posição de um valor, in para verificar se um valor está na tupla e + para concatenar.

Métodos e operações de tuplas

numbers = (1, 2, 3, 2, 4, 2)

# count() - how many times a value appears

print(numbers.count(2)) # 3

# index() - position of first occurrence

print(numbers.index(3)) # 2

# in - membership check

print(4 in numbers) # True

# Concatenation creates a NEW tuple

combined = (1, 2) + (3, 4)

print(combined) # (1, 2, 3, 4)

Saída

3
2
True
(1, 2, 3, 4)

Exercícios práticos

Hora de praticar! Estes exercícios cobrem a criação de tuplas, o desempacotamento e a imutabilidade.

Exercício 1: crie uma tupla e acesse seus elementos

Escreva o código

Crie uma tupla chamada seasons contendo as quatro estações do ano como strings: 'Spring', 'Summer', 'Fall', 'Winter'.

Depois exiba a primeira e a última estação, cada uma em sua própria linha.

Saída esperada:

Spring
Winter

# Create the seasons tuple

# Print the first season

# Print the last season

Exercício 2: preveja a saída: tupla de um item só

Preveja a saída

Leia este código com atenção. O que ele vai exibir? Pense no que faz algo ser uma tupla, e não um número comum entre parênteses.

a = (5)
b = (5,)
print(type(a).__name__)
print(type(b).__name__)

Escreva duas instruções print() que produzam exatamente a mesma saída.

# Predict the output and write the matching print statements

print("?")

Exercício 3: desempacote uma tupla

Escreva o código

Você recebe uma tupla que representa o registro de um aluno. Desempacote-a em três variáveis: name, age e grade.

Depois exiba cada variável em sua própria linha.

Saída esperada:

Emma
16
A

student = ('Emma', 16, 'A')

# Unpack the tuple into name, age, grade

# Print each variable

Exercício 4: corrija o bug: modificar uma tupla

Corrija o erro

Este código tenta trocar uma cor dentro de uma tupla, mas tuplas são imutáveis. Corrija-o para que o programa exiba as cores atualizadas sem alterar a tupla original. Em vez disso, crie uma nova tupla.

Saída esperada:

('red', 'yellow', 'blue')

colors = ('red', 'green', 'blue')

colors[1] = 'yellow'

print(colors)

Exercício 5: percorra e desempacote as notas dos alunos

Escreva o código

Você tem uma lista de tuplas, em que cada tupla contém o nome de um aluno e a nota dele. Percorra a lista, desempacote cada tupla e exiba o resultado de cada aluno neste formato:

Alice: 92
Bob: 85
Charlie: 78

students = [

('Alice', 92),

('Bob', 85),

('Charlie', 78),

]

# Loop through and print each student's result

Resumo: o que você aprendeu sobre tuplas em Python

Aqui está uma recapitulação de tudo o que você já sabe sobre tuplas:

Conceito	O que faz	Exemplo
Criar uma tupla	Guarda itens fixos	`point = (3, 4)`
Vírgula no final	Cria uma tupla de um item	`solo = (42,)`
Indexação	Acessa por posição	`point[0]`, `point[-1]`
Fatiamento	Pega um pedaço	`months[1:4]`
Desempacotamento	Extrai para variáveis	`x, y = point`
Desempacotamento estendido	Captura os itens extras com `*`	`first, *rest = items`
`count()`	Conta ocorrências	`t.count(2)`
`index()`	Encontra a posição	`t.index(3)`
Imutabilidade	Não pode ser modificada depois de criada	Gera `TypeError`

As tuplas são perfeitas para coleções fixas de dados: coordenadas, cores, registros e valores de retorno de funções. A imutabilidade deixa seu código mais seguro e suas intenções mais claras.

O que vem a seguir?

No próximo tutorial, Dicionários em Python, você vai aprender a guardar dados como pares de chave e valor. Em vez de acessar os itens pela posição, você vai acessá-los pelo nome.

Os dicionários são uma das estruturas de dados mais poderosas do Python. Junto com listas e tuplas, eles permitem modelar quase qualquer dado do mundo real.

Como criar tuplas em Python

Acessando e fatiando elementos de uma tupla

Empacotamento e desempacotamento de tuplas

Tuplas ou listas: quando usar cada uma

Por dentro: por que as tuplas são mais rápidas que as listas

Exercícios práticos

Resumo: o que você aprendeu sobre tuplas em Python

O que vem a seguir?

Tutoriais relacionados