Tuple é um tipo de dados embutido em Python que é usado para armazenar uma coleção de dados. É semelhante a uma lista, mas é um pouco mais rápido.
No entanto, suas limitações tornam as listas mais desejáveis em algumas situações. Neste artigo, explicarei tudo o que você precisa saber para começar a usar tuplas.
últimas postagens
O que é uma Tupla?
Como mencionado anteriormente, uma tupla é um dos tipos de dados integrados em Python usados para armazenar coleções de dados. É semelhante a uma lista do Python, pois armazena dados em um formato iterável semelhante a uma matriz. Ao contrário de uma lista, no entanto, uma tupla é imutável. Ou seja, uma vez criado, seus valores não podem ser alterados.
Elementos adicionais não podem ser adicionados e elementos existentes não podem ser removidos. Uma tupla, portanto, é ideal ao armazenar dados que não mudam. Pode até ser uma coleção de dados de diferentes tipos. Na próxima seção, discutiremos as diferentes formas de criar tuplas em Python.
Como criar uma tupla em Python?
Existem pelo menos três maneiras de criar tuplas em Python. Nesta seção, abordaremos três dos métodos mais comuns que você provavelmente usará e verá ao ler o código de outras pessoas.
Para executar os exemplos de código a seguir, você precisará ter o Python instalado. Se você ainda não tem o Python instalado, aqui está um guia útil para instalar o Python. Como alternativa, você pode executar seu código em um tempo de execução online do Python, como o Google Colab.
#1. Usando o Tuple Literal (Parênteses)
A maneira mais comum de ver tuplas definidas em Python é colocando uma coleção de valores entre parênteses. Esses valores são separados por vírgulas. O exemplo a seguir ilustra esse método:
# Creates a tuple by placing values between parentheses values = (1, 2, 3) # Printing out the tuple to the screen print(values) # Printing out the type of values variable print(type(values))
A execução desse código produzirá o seguinte:
Como você pode ver na saída, a tupla contém os valores com os quais a inicializamos. Também é do tipo
Quando você cria tuplas em Python, os parênteses não são necessários. Portanto, esses valores = 1, 2, 3 são tão válidos quanto esses valores = (1, 2, 3). É, no entanto, recomendado que você use parênteses para tornar seu código mais compreensível.
Criar tuplas com um elemento em Python é um pouco complicado. Em vez de apenas colocar um elemento entre parênteses, você também precisa adicionar uma vírgula à direita. Aqui está um exemplo para ilustrar:
# Without trailing comma, this won't create a tuple not_a_tuple = (1) # With trailing comma, this will create a tuple a_tuple = (1,) # Printing not_a_tuple print(not_a_tuple) # Printing not_a_tuple's data type print(type(not_a_tuple)) # Printing a_tuple print(a_tuple) # Printing a_tuple's data type print(type(a_tuple))
Executando o código acima, você verá que not_a_tuple se torna um int de valor 1. É importante ter isso em mente ao criar tuplas.
#2. Usando a Função Construtor
O segundo método para criar tuplas em Python usa a função construtora de tuplas. Nesse método, você chama a função, passando um objeto iterável como uma lista como argumento. Isso será convertido em uma tupla. Aqui está um exemplo:
# Creating tuple from a list of values values = tuple([1, 2, 3]) # Printing out the values print(values) # Printing out the data type of the values identifier print(type(values))
Como você pode ver, usar a função alcança o mesmo resultado que usar o literal. No entanto, a função permite criar uma tupla com base em um valor dinâmico, como uma lista cujos valores são conhecidos apenas em tempo de execução. Com o primeiro método, você teria que saber os valores ou identificadores que compõem sua tupla ao escrever o código.
#3. Criando uma Tupla Vazia
Conforme você trabalha com tuplas em seu código, pode ser necessário criar tuplas vazias. As tuplas vazias são criadas conforme o esperado. Você pode usar o construtor de tupla ou o literal to ao criá-los. Aqui está um exemplo demonstrando como usar qualquer um dos métodos:
# Using the tuple literal empty_tuple_1 = () # Using the constructor empty_tuple_2 = tuple()
Tuplas vazias são úteis ao representar um conjunto vazio de resultados. Considere a seguinte função:
def create_range(start, end):
return tuple(range(start, end))
Esta função cria uma tupla com valores desde o início, até o valor final que você passa. Se você quiser iterar sobre os resultados da função, você deve usar algo assim:
my_values = create_range(0, 5)
for value in my_values:
pass
Se você fornecer 5 e 5 para a função create_range, o resultado será uma tupla vazia. E se você tentasse iterar sobre ele, teria apenas zero iterações e seu código continuaria normalmente.
Por outro lado, se não houvesse tuplas vazias e, em vez disso, você obtivesse o valor None, tentar iterá-lo geraria um erro. Para evitar travar o programa, você teria que implementar um teste para o caso extremo em que a função create_range retorna None ou qualquer outro valor que represente uma tupla vazia.
Isso levaria a um código confuso. Idealmente, você gostaria de evitar casos especiais tanto quanto possível. Isso significa que o valor de retorno de todas as funções deve ter uma interface idêntica para que seu código funcione no caso geral tanto quanto possível. Nesse caso, isso significa retornar uma tupla o tempo todo, embora, às vezes, ela esteja vazia.
Como Acessar Elementos
Existem duas maneiras de acessar os elementos de uma tupla em Python. O primeiro método é por índice e o segundo é desestruturando os elementos. Primeiro, examinaremos como acessar elementos por índice.
Acessando Elementos por Índice
Acessar elementos pelo índice é semelhante a como você acessaria elementos de lista por índice. Isso é feito usando a notação de colchetes. As tuplas usam um sistema de indexação baseado em zero, o que significa que o primeiro elemento é o índice 0 e o seguinte é o índice 1 até o último elemento.
O exemplo abaixo demonstra como acessar elementos por índice:
# Creating a tuple values = (1, 2, 3, 4) # Accessing the first element first_element = values[0] # Accessing the fourth element(index 3) fourth_element = values[3]
Você também pode usar indexação negativa. O elemento com índice -1 é o último elemento, e o elemento com índice -2 é o penúltimo elemento.
# Creating the tuple values = (1, 2, 3, 4) # Accessing the last element last_element = values[-1] # Accessing the second from last element second_from_last_element = values[-2]
Além disso, você também pode acessar subcoleções de elementos de uma tupla dividindo-a. Isso é semelhante a como você dividiria uma lista. A notação é a seguinte
# Creating the tuple values = (1, 2, 3, 4, 5, 6, 7) # Getting the first three elements values[1: 3] # Getting every other element values[::2]
Iterando Sobre Elementos
Uma tupla é um objeto iterável em Python. Portanto, você pode iterar sobre seus elementos usando um loop for, conforme mostrado no exemplo a seguir:
values = (1, 2, 3, 4)
for value in values:
print(value)
Esse método de acessar elementos é ideal quando você deseja acessar todos os elementos da tupla.
Acessando elementos por desestruturação
Para explicar a desestruturação, considere o seguinte cenário em que estamos tentando obter os diferentes elementos em uma tupla.
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') # Accessing the different elements in the tuple to use in our code id = person_record[1] name = person_record[2] email = person_record[3]
Python nos permite usar um método mais conveniente para acessar os valores, conforme ilustrado abaixo:
# Creating the tuple to record a user's information person_record = (1, 'John Doe', '[email protected]') id, name, email = person_record
Isso se chama desestruturação. Essa é a primeira variável, id neste caso, será atribuído o primeiro valor na tupla e a segunda variável ao segundo elemento. Isso continua até o final da tupla. O exemplo acima é equivalente a este:
id, name, email = (1, 'John Doe', '[email protected]')
Nesse caso, ao invés de armazenar a tupla em uma variável, estamos imediatamente desestruturando-a. Quando você combina isso com o conhecimento de que não precisa usar parênteses ao criar tuplas, pode escrever o código assim.
id, name, email = 1, 'John Doe', '[email protected]'
Ao final de tudo isso, você terá as variáveis id, name e email com os valores 1, ‘John Doe’ e ‘[email protected]‘. Esta é uma maneira conveniente e sucinta de criar variáveis em Python que você verá no código de produção. Ajuda saber que no centro dessa elegante sintaxe está o conceito de tuplas.
Diferenças entre tupla e lista
Embora os dois sejam semelhantes, algumas diferenças importantes tornam cada um mais adequado para um caso de uso específico. Entender essas diferenças ajudará você a decidir sobre o melhor tipo de dados a ser usado e a escrever um código melhor e mais eficiente.
AspectTupleListMemory StorageArmazenado em memória contíguaArmazenar em diferentes partes da memóriaMutabilityImutable (não pode ser alterado)Mutable (pode ser alterado)SpeedAccess é mais rápidoAccess é mais lentoTipo de dadosGeralmente armazena dados de tipos diferentesGeralmente armazena dados do mesmo tipoCasos de usoUsualmente 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 aos valores é mais rápido em comparação com uma lista. No entanto, como uma vez criadas, elas não podem ser alteradas, as tuplas nem sempre são a melhor estrutura de dados a ser usada para armazenar coleções de valores.
Seu caso de uso ideal é armazenar muitos dados na memória que não mudam, mas serão acessados várias vezes durante a execução do programa. Nesse caso, seu programa se beneficiará imensamente com o aumento de desempenho das tuplas.
#2. Retornar vários valores
Você pode usar tuplas para retornar vários valores de uma função e desestruturar o resultado. Por exemplo:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
Neste exemplo, temos uma função que cria dois números aleatórios e os retorna em uma tupla. A instrução return first_num, second_num é equivalente a escrever return (first_num, second_num). Isso ocorre porque os parênteses são opcionais ao criar tuplas. Para acessar o resultado, estamos desestruturando-o.
#3. Os valores são protegidos contra gravação
As tuplas são imutáveis uma vez criadas. São, portanto, ideais para armazenar dados na memória que não mudam durante a execução do programa. Eles garantem que você não sobrescreva acidentalmente os dados em outro lugar do seu código.
#4. Armazenar vários tipos de dados
As tuplas permitem que você armazene valores de vários tipos de dados. Isso permite que você crie registros de dados, como armazenar os detalhes de um usuário em uma tupla. Você também pode armazenar itens mais complicados, como funções, dicionários, outras tuplas e até listas.
Métodos comuns de tupla
#1. contar()
O objeto tupla contém o método count, que conta o número de vezes que um elemento ocorre. Por exemplo:
# Creating a tuple with several numbers values = (1, 2, 3, 4, 5, 4, 4, 6) # Counting the number of fours n_fours = values.count(4) # Prining out the number of fours print(n_fours)
A partir deste exemplo, podemos ver que o número 4 ocorre exatamente três vezes em nossa tupla.
#2. índice()
O método index pode ser usado para encontrar o índice da primeira ocorrência de um valor em uma tupla. Se o valor não existir, uma exceção ValueError será lançada. Aqui está um código para ilustrar como o método index funciona:
# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
E quando executamos o código acima, esta é a saída:
Nesse caso, o índice de 4 é 3 e o código foi executado sem problemas. Mas na hora de encontrar o índice 9, o programa abriu uma exceção. É importante lidar com essas exceções ao escrever programas Python que usam o método index.
#3. len()
Como todos os objetos iteráveis em Python, as tuplas têm uma propriedade de comprimento que você pode acessar quando passa a tupla como um argumento para a função len().
# Creating a tuple values = (1, 2, 3, 4) # Getting the length length = len(values) # Print the output print(length)
Este é o resultado da execução do código acima.
#4. min() e max()
Os métodos min e max funcionam percorrendo cada elemento em um iterável e comparando se é maior ou menor que o anterior. No 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 usará 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 palavra. Se o iterável contiver uma mistura de diferentes tipos de dados, ambas as operações falharão porque o Python não sabe como comparar diferentes tipos de dados.
Aqui está um exemplo de código:
# Creating tuple with values values = (1, 2, 3, 4, 5) # Getting the largest value largest = max(values) # Getting the smallest value smallest = min(values) # Output the results print(largest) print(smallest)
#5. ordenado()
A função classificada em Python recebe um objeto iterável e retorna uma lista dos elementos classificados. Você pode chamar a função classificada, passar uma tupla como um argumento e obter os elementos da tupla classificados em uma lista. Para converter a lista classificada em uma tupla, você pode usar a função construtora. Aqui está um exemplo:
# Creating a tuple with values in random order values = (1, 5, 3, 3, 2, 4) # Using sorted to sort the values into a list sorted_list = sorted(values) # Converting the list into a tuple sorted_tuple = tuple(sorted_list) # Printing the output print(sorted_tuple)
#6. Adicionando e Multiplicando Tuplas
A operação de adição em duas tuplas simplesmente as concatena. A operação de multiplicação repete os elementos de uma tupla tantas vezes quanto o valor com o qual você multiplicou. Aqui está um exemplo para ilustrar os dois exemplos.
# Create a tuple with some values
values = (1, 2, 3, 4, 5)
# Create a new tuple using addition
added = values + values
# Create a new tuple using multiplication
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Palavras Finais
Neste artigo, você aprendeu que:
- Tuplas são objetos semelhantes a listas usados para armazenar coleções de valores.
- Ao contrário das listas, elas são imutáveis.
- Eles são mais rápidos e mais eficientes do que as listas.
- Eles podem ser construídos usando parênteses e separando os valores com vírgulas.
- Eles também podem ser construídos usando a função construtora de tuplas.
- Você pode acessar valores individuais usando um sistema de índice baseado em zero.
- Você também pode desestruturar valores da tupla.
- Você também pode iterar sobre valores usando um loop for.
- Os diferentes métodos que você pode usar com uma tupla.
A seguir, você pode conferir mais conteúdo sobre Python, como Python List Methods e Python Dictionary Methods.