Tuplas em Python: o guia completo para iniciantes

Se você já começou a explorar o mundo da programação com Python, provavelmente já se deparou com listas, dicionários e outras estruturas de dados essenciais. Mas e as tuplas? Apesar de muitas vezes serem ofuscadas pelas listas, as tuplas são uma ferramenta que pode trazer mais segurança e eficiência para o seu código.

O que faz das tuplas algo tão especial? Sua imutabilidade! Uma vez criadas, elas não podem ser alteradas, o que significa que seus dados permanecem protegidos contra modificações acidentais. Além disso, tuplas são mais rápidas e consomem menos memória do que listas, tornando-as uma escolha ideal para armazenar informações que não precisam ser alteradas.

Neste guia completo para iniciantes, vamos desvendar tudo sobre as tuplas em Python: como criá-las e manipulá-las e em quais situações elas são mais úteis. Se você quer levar seu conhecimento em Python para o próximo nível, vem comigo!

O que são tuplas em Python?

As tuplas em Python são estruturas de dados que funcionam como uma coleção de valores, muito semelhantes às listas, mas com uma característica fundamental: elas são imutáveis. Isso significa que, depois de criar uma tupla, você não pode alterar seus elementos, não é possível adicionar, remover ou modificar os itens contidos nela. Essa imutabilidade traz algumas vantagens, como a garantia de que os dados armazenados permanecerão constantes ao longo da execução do programa, o que pode evitar bugs e erros inesperados.

Exemplo de criação de uma tupla

Para criar uma tupla, basta colocar os valores entre parênteses e separá-los por vírgulas. Por exemplo:

caelum_coordenadas = (-23.588254, -46.632477)
print(type(caelum_coordenadas))  # Isso imprimirá: <class 'tuple'>

A principal diferença entre tuplas e listas é que, enquanto as listas permitem modificações após sua criação, as tuplas não. Se você precisar de uma coleção de dados que não deve ser alterada, a tupla é a escolha certa.

Vale lembrar que, mesmo sendo imutáveis, as tuplas podem conter objetos mutáveis, como listas. Nesse caso, embora a própria tupla não mude (a referência à lista permanece a mesma), o conteúdo dessa lista pode ser alterado.

Considere o seguinte exemplo em que uma tupla contém uma lista:

# Criando uma tupla que inclui uma lista como um dos seus elementos
minha_tupla = (1, 2, [3, 4])
print("Antes da alteração:", minha_tupla)  # Saída: (1, 2, [3, 4])


# Modificando a lista contida na tupla
minha_tupla[2].append(5)
print("Depois da alteração:", minha_tupla)  # Saída: (1, 2, [3, 4, 5])

Explicação: mesmo que a tupla em si seja imutável (ou seja, você não pode substituir a lista inteira ou alterar os outros elementos da tupla), a lista que ela contém é um objeto mutável. Portanto, você pode modificar o conteúdo dessa lista (como adicionar, remover ou alterar seus elementos), sem que a referência da lista na tupla seja alterada. Dessa forma, o “encaixe” da lista dentro da tupla permanece o mesmo, mas o conteúdo interno da lista pode mudar.

Outra curiosidade: ao criar uma tupla com apenas um elemento, é importante colocar uma vírgula após esse elemento. Sem a vírgula, o Python não entenderá que você está criando uma tupla. Por exemplo:

uma_tupla = (42,)  # Correto: uma tupla de um único elemento
nao_e_tupla = (42)  # Incorreto: isso é apenas o número 42 entre parênteses

Como funciona uma tupla em Python ?

Uma tupla em Python é uma coleção ordenada de elementos que, uma vez criada, não pode ser alterada. Isso significa que, diferentemente das listas, você não pode modificar, adicionar ou remover itens de uma tupla depois que ela foi definida. As tuplas são definidas utilizando parênteses e podem conter diferentes tipos de dados, como números, strings e até outras tuplas.

Características principais

• Imutabilidade: assim que a tupla é criada, seus elementos ficam fixos. Essa característica garante que os dados nela contidos permaneçam inalterados durante a execução do programa.
• Diversidade de tipos: você pode armazenar itens de tipos variados na mesma tupla, o que permite agrupar dados heterogêneos de maneira organizada.
• Indexação: como em listas, os elementos de uma tupla podem ser acessados através de índices. Por exemplo, minha_tupla[0] retorna o primeiro elemento.
• Tamanho fixo: o tamanho da tupla é definido no momento da criação e não pode ser modificado posteriormente.

Como criar uma tupla em Python?

Uma tupla é como uma caixinha onde você pode guardar alguns itens, mas, depois de fechada, você não consegue mais mexer no que está dentro. Em Python, essa caixinha é criada usando parênteses.

Criando uma tupla com vários itens

Se você quer colocar vários itens na sua caixinha, separe-os por vírgulas dentro dos parênteses. Por exemplo:

# Criando uma tupla com dois números
coordenadas = (10.0, 20.0)
print(coordenadas)  # Isso vai mostrar: (10.0, 20.0)

Aqui, a tupla coordenadas guarda dois valores: 10.0 e 20.0.

Criando uma tupla com um único item

Agora, se você quiser criar uma caixinha que guarde só um item, precisa ter um cuidado especial: colocar uma vírgula depois do único item. Se você não colocar a vírgula, o Python vai pensar que você não está criando uma caixinha, mas apenas usando parênteses para agrupar um número.

Veja o exemplo:

# Criando uma tupla com um único item - correto!
tupla_unica = (5,)
print(tupla_unica)  # Saída: (5,)

# Exemplo de erro: sem a vírgula, Python entende que é só o número 5
tupla_errada = (5)
print(type(tupla_errada))  # Saída: <class 'int'>, ou seja, é um número inteiro, não uma tupla.

1. Tuplas vazias:

tupla_vazia = ()

2. Tupla com um único elemento: ao criar uma tupla com apenas um elemento, é necessário colocar uma vírgula depois dele, para que o Python o reconheça como tupla.

tupla_um_elemento = (42,)

3. Tupla com múltiplos elementos: basta separar os elementos por vírgulas dentro dos parênteses.

minha_tupla = (1, "dois", 3.0)

Para que utilizar tuplas?

As tuplas são bastante úteis em várias situações, por exemplo:

• Armazenar dados constantes: quando você precisa guardar informações que não devem ser alteradas, como configurações ou coordenadas geográficas;
• Retornar múltiplos valores de uma função: funções podem retornar tuplas para entregar diversos valores ao mesmo tempo;
• Desempacotamento de dados: facilita a atribuição de múltiplas variáveis de uma só vez, com base nos valores contidos na tupla;
• Chaves de dicionários: devido à sua imutabilidade, as tuplas podem ser usadas como chaves em dicionários, ao contrário das listas.

Acessando elementos de uma tupla

Acessar os elementos de uma tupla é muito parecido com fazer isso em uma lista. Você utiliza colchetes [] para indicar o índice do elemento que deseja recuperar. Lembre-se de que os índices começam em 0, ou seja, o primeiro elemento está na posição 0, o segundo na posição 1 e assim por diante.

Exemplos

Acessando o primeiro elemento de uma tupla numérica:

minha_tupla = (1, 2, 3)
print(minha_tupla[0])  # Saída: 1

1. Aqui, minha_tupla[0] retorna o primeiro elemento, que é 1.

Acessando elementos de uma tupla com strings:

minha_tupla = ('a', 'b', 'c', 'd')

print(minha_tupla[1])   # Saída: 'b'

print(minha_tupla[-1])  # Saída: 'd' (último elemento)

2. No primeiro print, minha_tupla[1] acessa o segundo elemento, ‘b’.
   No segundo print, minha_tupla[-1] utiliza um índice negativo para acessar o último elemento da tupla, que é ‘d’.

Indexação positiva: use índices a partir de 0 para acessar os elementos (0, 1, 2, …).

Indexação negativa: use índices negativos para acessar os elementos a partir do fim da tupla (-1, -2, -3, …).

Assim, a indexação permite que você pegue qualquer elemento da tupla de forma rápida e simples, seja a partir do início ou do final. Essa é uma das vantagens das tuplas (e listas) em Python!

Imutabilidade das tuplas

A imutabilidade é uma das características mais marcantes das tuplas em Python. Em termos simples, quando dizemos que uma tupla é imutável, estamos afirmando que, depois de criada, seus elementos não podem ser alterados. Isso quer dizer que você não pode adicionar, remover ou modificar nenhum item dentro dela.

O que isso significa na prática?

Pense no seguinte cenário: você tem uma caixinha com alguns objetos dentro e, uma vez fechada, não é possível trocar nada do que está lá. É exatamente assim que funcionam as tuplas. Por exemplo, considere o código abaixo:

minha_tupla = (1, 2, 3)
minha_tupla[0] = 10  # Isso causará um TypeError

Nesse exemplo, estamos tentando alterar o primeiro elemento da tupla de 1 para 10. Como as tuplas são imutáveis, o Python não permite essa modificação e lança um erro do tipo TypeError.

Diferença entre tuplas e listas

A principal diferença entre tuplas e listas é justamente a mutabilidade:

• Listas: são mutáveis, o que significa que você pode modificar, adicionar ou remover elementos após a criação.

minha_lista = [1, 2, 3]
minha_lista[0] = 10  # Isso funciona perfeitamente
print(minha_lista)   # Saída: [10, 2, 3]

• Tuplas: são imutáveis. Uma vez que os dados estão armazenados, eles permanecem fixos. Essa característica garante que os dados não sejam alterados acidentalmente, oferecendo uma camada extra de segurança e, em alguns casos, melhor desempenho e menor uso de memória.

Por que usar tuplas?

Devido à sua imutabilidade, as tuplas são ideais para armazenar informações que não devem mudar, como configurações, coordenadas geográficas ou quaisquer dados que precisem ser protegidos de alterações inesperadas durante a execução do programa. Além disso, como os dados em uma tupla são fixos, o Python pode otimizar algumas operações, tornando o acesso e a iteração mais rápidos quando comparados a listas em certos contextos.

Métodos úteis para trabalhar com tuplas

Apesar de serem imutáveis, as tuplas contam com alguns métodos que podem facilitar o trabalho com elas. Vamos ver dois dos métodos mais úteis:

Método count()

O método count() serve para contar quantas vezes um determinado elemento aparece em uma tupla. Por exemplo:

tupla_exemplo = (1, 2, 3, 1, 1)
print(tupla_exemplo.count(1))  # Saída: 3

Nesse exemplo, o método verifica quantas vezes o número 1 aparece na tupla, que é exatamente três vezes.

Método index()

O método index() retorna o índice da primeira ocorrência de um elemento que você procurar na tupla. Lembre-se de que, se o elemento não existir na tupla, o Python lançará um erro. Veja este exemplo:

tupla_exemplo = (1, 2, 3)
print(tupla_exemplo.index(2))  # Saída: 1

Aqui, o método retorna 1 porque o número 2 está na posição de índice 1 (lembrando que a contagem começa em 0).

Esses métodos são bastante úteis para extrair informações de tuplas, mesmo sem a possibilidade de modificar seus elementos. Enquanto o count() ajuda a verificar quantas vezes um valor aparece, o index() permite localizar a posição de um elemento específico dentro da tupla.

Quando usar tuplas em vez de listas?

Agora que você já entende o que são tuplas e suas características, é importante saber quando elas são mais vantajosas do que listas.

Vantagens das tuplas em relação às listas

• Imutabilidade: se os dados não devem ser alterados após a criação, as tuplas são a melhor escolha. Isso garante maior segurança e evita modificações acidentais.
• Melhor desempenho: tuplas são mais rápidas e consomem menos memória do que listas, o que pode ser importante ao lidar com grandes volumes de dados.
• Uso como chave em dicionários: como são imutáveis, tuplas podem ser usadas como chaves em dicionários, enquanto listas não podem.
• Mais seguras em código crítico: se um conjunto de valores precisa permanecer constante, como configurações ou coordenadas, tuplas garantem que ninguém altere os dados acidentalmente.

Exemplos práticos de uso de tuplas

Armazenando coordenadas geográficas

As coordenadas de um local (latitude e longitude) nunca devem ser alteradas, então faz sentido armazená-las em uma tupla:

coordenadas = (10.0, 20.0)
print(coordenadas)  # Saída: (10.0, 20.0)

Retornando múltiplos valores de uma função

Tuplas são muito úteis para retornar múltiplos valores de uma função:

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


resultado = min_max([1, 2, 3, 4, 5])
print(resultado)  # Saída: (1, 5)

Aqui, a função retorna tanto o menor quanto o maior valor da lista, agrupados em uma tupla.

Use tuplas quando precisar de uma estrutura de dados rápida, imutável e segura. Elas são ideais para representar informações fixas, como coordenadas, configurações e retornos de funções.

Usos práticos de tuplas em projetos Python

As tuplas são muito úteis em projetos Python, especialmente quando precisamos agrupar dados relacionados, retornar múltiplos valores de funções ou desempacotamento de tuplas. Vejamos os exemplos para você conseguir colocar em prática: 

Exemplo de agrupamento de dados relacionados:

Se você precisa armazenar informações sobre um produto (nome, preço e quantidade em estoque),em vez de usar várias variáveis separadas, podemos agrupar tudo em uma tupla:

produto = ("Notebook", 3500.00, 5)
print(produto[0])  # Saída: Notebook
print(produto[1])  # Saída: 3500.00
print(produto[2])  # Saída: 5

Exemplo de retorno de múltiplos valores de uma função:

Se quisermos obter o mínimo e o máximo de uma lista de números, podemos retornar: 

def min_max(valores):
    return min(valores), max(valores)
resultado = min_max([10, 20, 5, 8, 30])
print(resultado)  # Saída: (5, 30)


# Podemos desempacotar os valores diretamente
menor, maior = min_max([10, 20, 5, 8, 30])
print(menor)  # Saída: 5
print(maior)  # Saída: 30

Exemplo de desempacotamento de tuplas

Uma das funcionalidades mais poderosas das tuplas é o desempacotamento, que permite atribuir seus valores a várias variáveis de uma só vez.

minha_tupla = (1, 2, 3)
a, b, c = minha_tupla
print(a)  # Saída: 1
print(b)  # Saída: 2
print(c)  # Saída: 3

Exemplo de retorno múltiplo:

def min_max_valores(valores):
    return min(valores), max(valores)
minimo, maximo = min_max_valores([1, 2, 3, 4, 5])
print(minimo)  # Saída: 1
print(maximo)  # Saída: 5

Exemplo de uso com coordenadas geográficas:

coordenadas = {
    (23.5, 45.2): "Localização 1",
    (56.2, 12.5): "Localização 2"
}
print(coordenadas[(23.5, 45.2)])  # Saída: Localização 1

Aprenda Python de forma prática e gratuita!

Agora que você já entendeu como as tuplas funcionam em Python, que tal dar um passo adiante e mergulhar ainda mais nessa linguagem poderosa? No curso Python para Iniciantes: do Zero ao Primeiro Projeto, você vai aprender os conceitos essenciais enquanto constrói um web app interativo do zero.

Curso 100% gratuito
Sem pré-requisitos – do zero mesmo!
Aprenda Python na prática em menos de 2 horas
Desenvolva um projeto real usando Streamlit, Pandas e Plotly

Não perca tempo com teoria sem aplicação! Venha aprender programando e dê o primeiro passo na sua jornada como desenvolvedor.

Curso Gratuito

Seu primeiro projeto Python – curso grátis com certificado!

Vá do zero ao primeiro projeto em apenas 2 horas com o curso Python para Iniciantes.

Comece agora