Em Python, as tuplas representam um tipo de dado essencial, empregado para armazenar sequências de informações. Assemelham-se às listas, contudo, apresentam uma ligeira vantagem em termos de velocidade.
Contudo, certas restrições tornam as listas uma opção mais atrativa em diversas situações. Este artigo visa elucidar tudo o que você precisa saber para começar a trabalhar com tuplas.
O que define uma Tupla?
Conforme mencionado anteriormente, uma tupla figura entre os tipos de dados integrados do Python, utilizados para acomodar agrupamentos de dados. Sua semelhança com as listas do Python reside na maneira como armazena dados em um formato iterável, análogo a um array. Entretanto, ao contrário de uma lista, a tupla é imutável, ou seja, uma vez criada, seus valores não podem ser modificados.
Não é possível acrescentar novos elementos ou remover os existentes. Consequentemente, uma tupla é ideal para armazenar dados estáticos. Ela pode, inclusive, conter dados de diferentes tipos. Nas próximas seções, exploraremos as diversas maneiras de criar tuplas no Python.
Como Criar uma Tupla no Python?
Existem, no mínimo, três formas distintas de criar tuplas no Python. Nesta seção, abordaremos três dos métodos mais comuns, que você provavelmente irá utilizar e encontrar ao analisar o código de outros programadores.
Para reproduzir os exemplos de código a seguir, você necessitará ter o Python instalado. Caso ainda não possua, aqui está um guia útil para instalar o Python. Alternativamente, você pode executar seu código em um ambiente online do Python, como o Google Colab.
#1. Utilizando o Literal de Tupla (Parênteses)
A forma mais usual de encontrar tuplas definidas em Python é encapsulando uma coleção de valores entre parênteses. Esses valores são separados por vírgulas. O exemplo a seguir ilustra esse método:
# Cria uma tupla ao colocar valores entre parênteses valores = (1, 2, 3) # Exibindo a tupla na tela print(valores) # Exibindo o tipo da variável valores print(type(valores))
A execução deste código irá gerar a seguinte saída:
Como se pode observar na saída, a tupla contém os valores que utilizamos para inicializá-la. Além disso, é classificada como tipo
Ao criar tuplas no Python, os parênteses são dispensáveis. Portanto, a instrução valores = 1, 2, 3 é tão válida quanto valores = (1, 2, 3). No entanto, é recomendável usar parênteses para conferir maior clareza ao seu código.
A criação de tuplas com um único elemento no Python apresenta uma peculiaridade. Em vez de simplesmente colocar o elemento entre parênteses, é necessário adicionar uma vírgula à direita. Veja um exemplo para ilustrar:
# Sem vírgula no final, isso não cria uma tupla nao_e_uma_tupla = (1) # Com vírgula no final, isso cria uma tupla uma_tupla = (1,) # Exibindo nao_e_uma_tupla print(nao_e_uma_tupla) # Exibindo o tipo de dados de nao_e_uma_tupla print(type(nao_e_uma_tupla)) # Exibindo uma_tupla print(uma_tupla) # Exibindo o tipo de dados de uma_tupla print(type(uma_tupla))
Ao executar o código acima, você observará que nao_e_uma_tupla é interpretada como um inteiro com valor 1. É fundamental ter isso em mente ao criar tuplas.
#2. Utilizando a Função Construtora
O segundo método para criar tuplas em Python envolve o uso da função construtora de tuplas. Nesse método, você invoca a função, fornecendo um objeto iterável, como uma lista, como argumento. Esse objeto será convertido em uma tupla. Veja um exemplo:
# Criando uma tupla a partir de uma lista de valores valores = tuple([1, 2, 3]) # Exibindo os valores print(valores) # Exibindo o tipo de dados do identificador valores print(type(valores))
Como pode ser observado, a utilização da função resulta no mesmo efeito da utilização do literal. Contudo, a função possibilita criar uma tupla a partir de um valor dinâmico, como uma lista cujos valores são conhecidos somente em tempo de execução. Com o primeiro método, seria necessário conhecer os valores ou identificadores que compõem a sua tupla no momento de escrever o código.
#3. Criando uma Tupla Vazia
No decorrer do desenvolvimento com tuplas, você pode precisar criar tuplas vazias. A criação de tuplas vazias segue o esperado, sendo possível usar tanto o construtor de tupla quanto o literal. Segue um exemplo demonstrando a utilização de ambos os métodos:
# Utilizando o literal de tupla tupla_vazia_1 = () # Utilizando o construtor tupla_vazia_2 = tuple()
Tuplas vazias são úteis ao representar um conjunto vazio de resultados. Veja a seguinte função:
def criar_intervalo(inicio, fim):
return tuple(range(inicio, fim))
Esta função cria uma tupla com valores iniciando em ‘inicio’, até o valor final fornecido. Se for necessário iterar sobre os resultados da função, você pode utilizar uma estrutura semelhante a esta:
meus_valores = criar_intervalo(0, 5)
for valor in meus_valores:
pass
Se você passar 5 e 5 para a função criar_intervalo, o resultado será uma tupla vazia. Ao tentar iterar sobre ela, você terá simplesmente zero iterações, e seu código continuará sem interrupções.
Por outro lado, se tuplas vazias não existissem, e o resultado fosse None, tentar iterar sobre ele geraria um erro. Para evitar que o programa trave, seria necessário implementar uma verificação para o caso em que a função criar_intervalo retorna None ou qualquer outro valor que represente uma tupla vazia.
Isso resultaria em um código confuso. O ideal é evitar casos especiais o máximo possível, o que implica que o valor de retorno de todas as funções deve ter uma interface idêntica, para que o código funcione da forma mais geral possível. Nesse caso, significa retornar uma tupla em todas as situações, ainda que, em algumas vezes, ela esteja vazia.
Como Acessar Elementos
Existem duas formas de acessar os elementos de uma tupla em Python: através do índice e através da desestruturação dos elementos. Inicialmente, examinaremos o acesso a elementos por índice.
Acessando Elementos por Índice
O acesso a elementos por meio do índice assemelha-se ao acesso a elementos de uma lista pelo índice. Isso é realizado utilizando a notação de colchetes. As tuplas empregam um sistema de indexação baseado em zero, onde o primeiro elemento corresponde ao índice 0 e o seguinte ao índice 1, e assim sucessivamente até o último elemento.
O exemplo abaixo demonstra como acessar elementos por índice:
# Criando uma tupla valores = (1, 2, 3, 4) # Acessando o primeiro elemento primeiro_elemento = valores[0] # Acessando o quarto elemento (índice 3) quarto_elemento = valores[3]
Também é possível utilizar a indexação negativa. O elemento com índice -1 corresponde ao último elemento, e o elemento com índice -2 corresponde ao penúltimo elemento.
# Criando a tupla valores = (1, 2, 3, 4) # Acessando o último elemento ultimo_elemento = valores[-1] # Acessando o penúltimo elemento penultimo_elemento = valores[-2]
Adicionalmente, é possível acessar subcoleções de elementos de uma tupla através do fatiamento. Isso é semelhante ao fatiamento de uma lista. A notação é a seguinte:
# Criando a tupla valores = (1, 2, 3, 4, 5, 6, 7) # Obtendo os três primeiros elementos valores[1: 3] # Obtendo todos os outros elementos valores[::2]
Iterando Sobre Elementos
Uma tupla é um objeto iterável em Python. Portanto, é possível iterar sobre seus elementos utilizando um loop ‘for’, conforme demonstrado no exemplo a seguir:
valores = (1, 2, 3, 4)
for valor in valores:
print(valor)
Este método de acesso a elementos é ideal quando você necessita acessar todos os elementos da tupla.
Acessando Elementos por Desestruturação
Para explicar a desestruturação, considere o seguinte cenário, onde estamos tentando obter os diferentes elementos em uma tupla.
# Criando a tupla para registrar as informações de um usuário registro_pessoa = (1, 'John Doe', '[email protected]') # Acessando os diferentes elementos na tupla para utilizar no código id = registro_pessoa[1] nome = registro_pessoa[2] email = registro_pessoa[3]
O Python nos permite usar um método mais conveniente para acessar os valores, conforme ilustrado abaixo:
# Criando a tupla para registrar as informações de um usuário registro_pessoa = (1, 'John Doe', '[email protected]') id, nome, email = registro_pessoa
Isso é chamado de desestruturação. A primeira variável, ‘id’ neste caso, receberá o primeiro valor na tupla e a segunda variável, o segundo elemento, e assim por diante, até o final da tupla. O exemplo acima é equivalente a este:
id, nome, email = (1, 'John Doe', '[email protected]')
Nesse caso, ao invés de armazenar a tupla em uma variável, estamos imediatamente desestruturando-a. Ao combinar isso com o conhecimento de que não é necessário usar parênteses ao criar tuplas, é possível escrever o código assim:
id, nome, email = 1, 'John Doe', '[email protected]'
Ao final desse processo, você terá as variáveis id, nome e email com os valores 1, ‘John Doe’ e ‘[email protected]‘. Esta é uma maneira conveniente e concisa de criar variáveis em Python, e você a encontrará em códigos de produção. É útil saber que, no cerne dessa sintaxe elegante, reside o conceito de tuplas.
Diferenças entre Tupla e Lista
Apesar de ambos serem semelhantes, algumas diferenças cruciais tornam cada um mais adequado para um caso de uso específico. Compreender essas diferenças o ajudará a escolher o tipo de dados mais apropriado e a escrever um código melhor e mais eficiente.
| Aspecto | Tupla | Lista |
| Armazenamento de Memória | Armazenado em memória contígua | Armazenado em diferentes partes da memória |
| Mutabilidade | Imutável (não pode ser alterado) | Mutável (pode ser alterado) |
| Velocidade | Acesso mais rápido | Acesso mais lento |
| Tipo de Dados | Geralmente armazena dados de tipos diferentes | Geralmente armazena dados do mesmo tipo |
| Casos de uso | Usualmente usado para armazenar uma coleção de valores semelhantes, como marcas. | Geralmente usado para armazenar uma coleção de valores semelhantes, como marcas. |
Vantagens de uma Tupla
#1. É mais rápido
Devido à forma como os valores de uma tupla são armazenados na memória contígua, o acesso a eles é mais rápido em comparação com uma lista. Contudo, como não podem ser alteradas depois de criadas, as tuplas nem sempre são a melhor estrutura de dados para armazenar coleções de valores.
Seu caso de uso ideal é o de armazenar uma grande quantidade de dados na memória que não se modificam, mas serão acessados repetidamente durante a execução do programa. Nessa situação, o seu programa se beneficiará bastante do aumento de desempenho proporcionado pelas tuplas.
#2. Retornar múltiplos valores
Você pode usar tuplas para retornar múltiplos valores de uma função e desestruturar o resultado. Por exemplo:
from random import randint
def criar_dois_numeros():
primeiro_num = randint(0, 9)
segundo_num = randint(0, 9)
return primeiro_num, segundo_num
primeiro_num, segundo_num = criar_dois_numeros()
Neste exemplo, temos uma função que cria dois números aleatórios e os retorna em uma tupla. A instrução ‘return primeiro_num, segundo_num’ equivale a escrever ‘return (primeiro_num, segundo_num)’. Isso acontece porque os parênteses são opcionais ao criar tuplas. Para acessar o resultado, estamos o desestruturando.
#3. Os valores são protegidos contra gravação
As tuplas são imutáveis uma vez criadas. Portanto, são ideais para armazenar dados na memória que não se modificam durante a execução do programa. Elas asseguram que você não sobrescreva acidentalmente os dados em outra parte do seu código.
#4. Armazenar múltiplos tipos de dados
As tuplas permitem que você armazene valores de vários tipos de dados. Isso possibilita criar registros de dados, como armazenar os detalhes de um usuário em uma tupla. Você também pode armazenar itens mais complexos, como funções, dicionários, outras tuplas e até mesmo listas.
Métodos comuns de tupla
#1. count()
O objeto tupla contém o método ‘count’, que contabiliza o número de vezes que um elemento ocorre. Por exemplo:
# Criando uma tupla com diversos números valores = (1, 2, 3, 4, 5, 4, 4, 6) # Contabilizando o número de quatros n_quatros = valores.count(4) # Imprimindo o número de quatros print(n_quatros)
A partir deste exemplo, podemos observar que o número 4 ocorre exatamente três vezes na nossa tupla.
#2. index()
O método ‘index’ pode ser usado para encontrar o índice da primeira ocorrência de um valor em uma tupla. Caso o valor não exista, será lançada uma exceção ‘ValueError’. Segue um código para ilustrar o funcionamento do método ‘index’:
# Criando uma tupla com diversos números
valores = (1, 2, 3, 4, 5, 4, 4, 6)
# Buscando o índice de 4
indice_de_quatro = valores.index(4)
print("Índice de quatro:", indice_de_quatro)
# Buscando o índice de 9
indice_de_nove = valores.index(9)
print("Índice de nove:", indice_de_nove)
E quando executamos o código acima, esta é a saída:
Neste caso, o índice de 4 é 3, e o código foi executado sem problemas. Entretanto, ao tentar encontrar o índice de 9, o programa lançou uma exceção. É importante lidar com essas exceções ao escrever programas em Python que utilizam o método ‘index’.
#3. len()
Assim como todos os objetos iteráveis em Python, as tuplas possuem uma propriedade de comprimento, que pode ser acessada ao passar a tupla como argumento para a função ‘len()’.
# Criando uma tupla valores = (1, 2, 3, 4) # Obtendo o comprimento comprimento = len(valores) # Imprimindo a saída print(comprimento)
Este é o resultado da execução do código acima.
#4. min() e max()
Os métodos ‘min’ e ‘max’ operam percorrendo cada elemento de um iterável e verificando se ele é maior ou menor que o anterior. Ao final, ‘max’ retornará o maior elemento do iterável, enquanto ‘min’ retornará o menor.
Com números, a operação é óbvia. Com strings, o Python empregará a ordem alfabética. A menor palavra, retornada por ‘min’, é a primeira palavra se as strings forem escritas em ordem alfabética, enquanto a maior palavra é a última. Se o iterável contiver uma mistura de diferentes tipos de dados, ambas as operações falharão, pois o Python não sabe como comparar tipos de dados diferentes.
Segue um exemplo de código:
# Criando tupla com valores valores = (1, 2, 3, 4, 5) # Obtendo o maior valor maior = max(valores) # Obtendo o menor valor menor = min(valores) # Exibindo os resultados print(maior) print(menor)
#5. sorted()
A função ‘sorted’ em Python recebe um objeto iterável e retorna uma lista com os elementos ordenados. Você pode invocar a função ‘sorted’, passar uma tupla como argumento e obter os elementos da tupla ordenados em uma lista. Para converter a lista ordenada em uma tupla, você pode utilizar a função construtora. Segue um exemplo:
# Criando uma tupla com valores em ordem aleatória valores = (1, 5, 3, 3, 2, 4) # Utilizando 'sorted' para ordenar os valores em uma lista lista_ordenada = sorted(valores) # Convertendo a lista em uma tupla tupla_ordenada = tuple(lista_ordenada) # Imprimindo a saída print(tupla_ordenada)
#6. Adicionando e Multiplicando Tuplas
A operação de adição entre duas tuplas simplesmente as concatena. A operação de multiplicação repete os elementos de uma tupla tantas vezes quanto o valor pelo qual você a multiplicou. Segue um exemplo para ilustrar ambos os casos.
# Criando uma tupla com alguns valores
valores = (1, 2, 3, 4, 5)
# Criando uma nova tupla utilizando adição
adicionados = valores + valores
# Criando uma nova tupla utilizando multiplicação
multiplicados = valores * 2
print("valores + valores =", adicionados)
print("valores * 2 =", multiplicados)
Considerações Finais
Neste artigo, você aprendeu que:
- Tuplas são objetos semelhantes a listas, utilizados para armazenar coleções de valores.
- Ao contrário das listas, elas são imutáveis.
- São mais rápidas e eficientes do que as listas.
- Podem ser construídas utilizando parênteses e separando os valores com vírgulas.
- Também podem ser construídas utilizando a função construtora de tuplas.
- Você pode acessar valores individuais através de um sistema de índice baseado em zero.
- Você também pode desestruturar os valores da tupla.
- Você também pode iterar sobre os valores utilizando um loop ‘for’.
- Os diferentes métodos que podem ser utilizados com uma tupla.
A seguir, você pode conferir mais conteúdo sobre Python, como Métodos de Lista do Python e Métodos de Dicionário do Python.