Dominando Tuplas em Python: Criação, Acesso e Operações Avançadas
Tuplas em Python
Descubra o poder das tuplas em Python — sequências imutáveis que oferecem velocidade, segurança e versatilidade para dados heterogêneos. Este guia abrange da sintaxe básica a operações avançadas, garantindo que você entenda quando escolher tuplas em vez de listas.
Vídeo: Listas e Tuplas em Python
Uma tupla se comporta como uma lista, mas é imutável após criada. Diferente de listas, você não pode alterar seus elementos, tornando tuplas ideais para conjuntos de dados fixos.
Criando uma Tupla
Tuplas são definidas colocando valores separados por vírgula dentro de parênteses (). Embora parênteses sejam opcionais, eles melhoram a legibilidade.
Tuplas podem conter qualquer número de itens e misturar tipos de dados — inteiros, floats, strings, listas, outras tuplas, etc.
# Diferentes tipos de tuplas
# Tupla vazia
my_tuple = ()
print(my_tuple)
# Tupla com inteiros
my_tuple = (1, 2, 3)
print(my_tuple)
# Tipos de dados mistos
my_tuple = (1, "Olá", 3.4)
print(my_tuple)
# Tupla aninhada
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)
Saída
() (1, 2, 3) (1, 'Olá', 3.4) ('mouse', [8, 4, 6], (1, 2, 3))
Tuplas também podem ser criadas sem parênteses — técnica conhecida como tuple packing (empacotamento de tupla).
my_tuple = 3, 4.6, "dog"
print(my_tuple)
# Desempacotamento de tupla
a, b, c = my_tuple
print(a)
print(b)
print(c)
Saída
(3, 4.6, 'dog') 3 4.6 dog
Quando uma tupla contém um único elemento, uma vírgula final é obrigatória para distingui-la de um valor simples.
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Tupla de um elemento
my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parênteses opcionais
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'>
Saída
<class 'str'> <class 'tuple'> <class 'tuple'>
Acessando Elementos da Tupla
Tuplas suportam vários métodos para acesso a elementos:
1. Indexação
Use o operador de índice [] com índices baseados em zero. Acesso fora do intervalo levanta IndexError; índices não-inteiros levantam TypeError.
# Exemplo de indexação
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0]) # 'p'
print(my_tuple[5]) # 't'
# Indexação aninhada
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(n_tuple[0][3]) # 's'
print(n_tuple[1][1]) # 4
Saída
p t s 4
2. Indexação Negativa
Índices negativos contam do final: -1 é o último elemento.
# Indexação negativa
my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
print(my_tuple[-1]) # 't'
print(my_tuple[-6]) # 'p'
Saída
t p
3. Fatiamento (Slicing)
Use sintaxe início:fim para extrair sub-tuplas.
# Exemplo de fatiamento
my_tuple = ('p','r','o','g','r','a','m','i','z')
print(my_tuple[1:4]) # ('r', 'o', 'g')
print(my_tuple[:-7]) # ('p', 'r')
print(my_tuple[7:]) # ('i', 'z')
print(my_tuple[:]) # tupla completa
Saída
('r', 'o', 'g') ('p', 'r') ('i', 'z') ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

Modificando uma Tupla
Tuplas são imutáveis. Atribuição direta a um elemento levanta TypeError:
# Tentativa de modificação
my_tuple = (4, 2, 3, [6, 5])
# my_tuple[1] = 9 # TypeError
No entanto, se um elemento for mutável (ex.: lista), seu estado interno pode mudar:
my_tuple[3][0] = 9
print(my_tuple) # (4, 2, 3, [9, 5])
Tuplas podem ser reatribuídas a um novo valor inteiramente:
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)
Use + para concatenação e * para repetição; ambos retornam nova tupla.
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)
print(("Repetir",) * 3) # ('Repetir', 'Repetir', 'Repetir')
Saída
(1, 2, 3, 4, 5, 6) ('Repetir', 'Repetir', 'Repetir')
Deletando uma Tupla
Itens individuais não podem ser removidos. A tupla inteira pode ser deletada com del:
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# del my_tuple[3] # TypeError
del my_tuple
# print(my_tuple) # NameError
Saída
Traceback (most recent call last): File "<string>", line 12, in <module> NameError: name 'my_tuple' is not defined
Métodos de Tupla
Tuplas expõem apenas dois métodos built-in: count() e index().
my_tuple = ('a', 'p', 'p', 'l', 'e')
print(my_tuple.count('p')) # 2
print(my_tuple.index('l')) # 3
Saída
2 3
Outras Operações com Tuplas
1. Teste de Pertinência
Verifique existência com a palavra-chave in.
my_tuple = ('a', 'p', 'p', 'l', 'e')
print('a' in my_tuple)
print('b' in my_tuple)
print('g' not in my_tuple)
Saída
True False True
2. Iteração
Percorra tuplas com for:
for name in ('John', 'Kate'):
print("Olá", name)
Saída
Olá John Olá Kate
3. Vantagens Sobre Listas
- Ideais para dados heterogêneos; listas geralmente são homogêneas.
- Imutabilidade fornece vantagem de performance em iteração.
- Tuplas contendo apenas elementos imutáveis podem servir como chaves de dicionário.
- Dados protegidos contra escrita são garantidos, prevenindo modificação acidental.
python
- Dominando Tipos de Dados em Python: Guia Prático
- Dominando Operadores em Python: Guia Completo
- Dominando a Declaração Pass em Python: Guia Prático
- Dominando Argumentos de Funções em Python: Parâmetros Posicionais, Nomeados e Padrão
- Dominando Dicionários em Python: Criação, Manipulação e Técnicas Avançadas
- Dominando Iteradores em Python: Como Funcionam e Como Criar os Seus
- Closures em Python Explicados: Como Funções Aninhadas Capturam Variáveis
- Dominando datetime do Python: Guia Prático de Datas, Horários e Fusos Horários
- Visão Geral do Python: Linguagem de Alto Nível, Legível, Interativa e Orientada a Objetos
- Números em Python: Entender Tipos de Dados Numéricos Imutáveis