Neste guia, você aprenderá as semelhanças e diferenças entre tuplas e listas do Python. Você também entenderá quando deve usar uma tupla.
Lista e tuplas são estruturas de dados embutidas em Python. Eles podem ser usados para armazenar uma coleção de elementos.
Desde suporte para indexação e fatiamento até conter tipos de dados heterogêneos, tuplas e listas podem parecer ter funcionalidades semelhantes. Portanto, entender as semelhanças e diferenças entre os dois pode ajudá-lo a decidir qual estrutura de dados usar.
Vamos começar.
👩🏽💻 Você pode iniciar um Python REPL e seguir este tutorial. Você também pode usar o editor Python online do etechpt.com para codificar junto.
últimas postagens
Python Tuple vs List: Quais são as semelhanças?
Vamos começar aprendendo as semelhanças entre listas e tuplas. Para facilitar um melhor aprendizado, apresentamos exemplos de listas e tuplas.
#1. Iteráveis Python
Em Python, as listas são colocadas entre colchetes, enquanto as tuplas são colocadas entre parênteses. Você também pode criar uma tupla como um conjunto de valores separados por vírgulas — sem os parênteses.
Ambos são iteráveis; para que você possa percorrê-los usando um loop for.
A célula de código abaixo mostra como iterar em uma lista.
nums = [2,6,7,10]
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'list'>
2
6
7
10
Conforme explicado abaixo, você também pode iterar por meio de uma tupla usando um loop
nums = (2,6,7,10)
# Note: nums = 2,6,7,10 is a valid tuple as well. If needed, run a quick check!
print(f"Type of nums is {type(nums)}")
for num in nums:
print(num)
# Output
Type of nums is <class 'tuple'>
2
6
7
10
#2. Suporte para criação de outras sequências
A próxima semelhança entre listas e tuplas é que elas podem ser criadas a partir de sequências existentes, como strings.
sample_str = "Coding!"
A célula de código a seguir mostra como list(string) retorna uma lista, cujos itens de lista são os caracteres da string.
list_from_str = list(sample_str) print(list_from_str) # Output ['C', 'o', 'd', 'i', 'n', 'g', '!']
Da mesma forma, uma tupla pode ser criada a partir de uma string ou outra sequência usando tuple(sequence). A célula de código abaixo mostra como você pode fazer isso.
tuple_from_str = tuple(sample_str)
print(tuple_from_str)
# Output
('C', 'o', 'd', 'i', 'n', 'g', '!')
#3. Suporte para indexação e fatiamento
Python suporta indexação zero na qual o primeiro elemento está no índice zero, o segundo no índice um e assim por diante. Python também suporta indexação negativa, onde o último elemento está no índice -1, o penúltimo elemento está no índice -2 e assim por diante.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[1]) # o
O item no índice -2 é o penúltimo item, ‘g’.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g
Você pode usar o fatiamento quando quiser trabalhar com uma pequena seção da lista ou tupla. Lista[start:end] retorna uma fatia da lista começando no início do índice e se estendendo até o final – 1. O valor padrão para um início é 0 e o final é o último elemento no iterável.
Você pode fatiar tuplas usando a mesma sintaxe. Vamos criar fatias da lista e tupla que criamos anteriormente.
list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!'] print(list_from_str[0:5]) ['C', 'o', 'd', 'i', 'n']
Além dos valores inicial e final, você também pode especificar um valor de etapa. tuple(start:end:step) retorna uma fatia da tupla do início ao fim – 1, em etapas de step.
tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[::2])
('C', 'd', 'n', '!')
Aqui, definimos o valor da etapa como 2. Assim, a fatia contém cada segundo elemento.
#4. Coleções de vários tipos de dados
Nos exemplos que consideramos, todos os itens da lista e tuplas eram do mesmo tipo de dados.
No entanto, você pode armazenar valores de diferentes tipos de dados em uma única lista ou tupla.
O trecho de código abaixo da lista_aluno contém o nome de um aluno como uma string, a idade como um número inteiro e as marcas protegidas como flutuantes.
student_list = ["John",22,96.5]
for item in student_list:
print(f"{item} is of type {type(item)}")
# Output
John is of type <class 'str'>
22 is of type <class 'int'>
96.5 is of type <class 'float'>
Podemos criar um exemplo semelhante para uma tupla.
student_tuple = ("Jane",23,99.5)
for item in student_tuple:
print(f"{item} is of type {type(item)}")
# Output
Jane is of type <class 'str'>
23 is of type <class 'int'>
99.5 is of type <class 'float'>
#5. Suporte para teste de associação
Tanto as listas quanto as tuplas permitem que você realize testes de associação para a presença de determinados itens. Se você quiser verificar se um item específico está presente em uma lista ou tupla, você pode usar o operador in.
O item de expressão em iterável será avaliado como True se o iterável contiver o item; senão, Falso.
"Alex" in student_list # False "Jane" in student_tuple # True
Até agora, você aprendeu as semelhanças entre listas e tuplas em Python. Em seguida, vamos aprender as principais diferenças entre as duas estruturas de dados.
Tupla Python vs Lista: Quais são as diferenças?
#1. Mutabilidade de listas e imutabilidade de tuplas em Python
A diferença mais crucial entre uma lista e uma tupla em Python é que uma tupla é imutável. Isso significa que você não pode modificar uma tupla no local.
▶️ Aqui está um exemplo.
tuple1 = ("Java","Python","C++")
tuple1[0] = "Rust"
# Output
----> 2 tuple1[0] = "Rust"
TypeError: 'tuple' object does not support item assignment
Uma lista é uma estrutura de dados mutável, portanto, podemos modificar a lista alterando um item em um índice específico, como na célula de código a seguir.
list1 = ["Java","Python","C++"] list1[0] = "Rust" print(list1) # Output ['Rust', 'Python', 'C++']
#2. Listas de Comprimento Variável vs Tuplas de Comprimento Fixo
A lista Python é uma estrutura de dados de comprimento variável.
Você pode fazer o seguinte:
- Adicionar um item ao final da lista
- Adicionar itens de outra lista ao final da lista atual
- Remover itens em um índice específico da lista
list1 = [2,3,4,5] # add an item to the end list1.append(9) print(list1) # add items from list2 to the end of list1 list2 = [0,7] list1.extend(list2) print(list1) # remove an item from list1 list1.pop(0) print(list1)
▶️ A saída do trecho de código acima.
# Output [2, 3, 4, 5, 9] [2, 3, 4, 5, 9, 0, 7] [3, 4, 5, 9, 0, 7]
Tuplas são estruturas de dados de comprimento fixo. Portanto, você não pode adicionar ou remover elementos de uma tupla existente. Mas você pode redefinir a tupla para conter elementos diferentes.
tuple1 = (2,4,6,8) tuple1 = (1,8,9) print(tuple1) # Output (1, 8, 9)
#3. Tamanho na memória
Agora vamos construir sobre o que aprendemos na seção anterior: a lista é uma estrutura de dados de comprimento variável.
Quando você define a lista inicialmente, um tamanho específico é alocado para ela na memória. Agora, quando você modifica uma lista usando os métodos append() ou extend(), memória adicional deve ser alocada para armazenar os elementos adicionados. Essa alocação quase sempre é feita mais do que o número de itens que você adiciona.
Portanto, é necessário acompanhar o número de itens na lista e o espaço alocado. Além disso, como as listas têm comprimento variável, há um ponteiro que aponta para o endereço dos itens da lista. Como resultado, listas de comprimento k ocupam mais memória do que uma tupla com os mesmos k elementos.
Aqui está uma ilustração simples.
Você pode usar o método getsizeof() do módulo sys integrado em um objeto Python para obter o tamanho de um objeto na memória.
import sys
list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"Size of list:{list_size}")
tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"Size of tuple:{tuple_size}")
Uma lista ocupa mais memória do que uma tupla para o mesmo número e valor de elementos, conforme verificado na saída abaixo.
# Output Size of list:104 Size of tuple:88
Quando você deve usar uma tupla Python?
Pelas diferenças e semelhanças entre listas e tuplas do Python, você sabe que, se precisar de uma coleção mutável, deve usar uma lista.
Mas quando você deve usar uma tupla em vez disso?
Veremos isso nesta seção.
#1. Coleção somente leitura
Sempre que você quiser que uma coleção seja imutável, você deve defini-la como uma tupla. Suponha color = (243,55,103) uma tupla contendo os valores RGB correspondentes a uma tonalidade de cor. Definir a cor como uma tupla garante que ela não possa ser modificada.
Em essência, quando você precisa que uma coleção seja somente leitura: os valores não devem ser modificados durante o programa, você deve considerar o uso de uma tupla. Isso impedirá a modificação não intencional dos valores.
#2. Chaves do dicionário
Por exemplo, você cria um dicionário usando os itens de lista key_list como chaves. Você pode usar o método dict.fromkeys() para criar um dicionário a partir de uma lista.
key_list = list("ABCD")
dict.fromkeys(key_list)
{'A': None, 'B': None, 'C': None, 'D': None}
Suponha que você modifique a lista para conter ‘D’ como o primeiro elemento (índice 0)—antes de criar o dicionário.
Agora, o que acontece com a chave do dicionário ‘A’?
Se você tentar criar um dicionário a partir de key_list e acessar o valor correspondente à chave ‘A’, você encontrará um KeyError.
key_list[0] = 'D' dict.fromkeys(key_list)['A'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-31-c90392acc2cf> in <module>() ----> 1 dict.fromkeys(key_list)['A'] KeyError: 'A'
As chaves de um dicionário devem ser únicas. Então você não pode ter um segundo ‘D’ como chave.
dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A is no longer a key.
Se, em vez disso, você usar uma tupla, essa modificação será impossível e é menos provável que você encontre erros. Portanto, você deve preferir criar um dicionário usando os itens de uma tupla como chaves.
key_tuple = tuple("ABCD")
dict.fromkeys(key_tuple)
{'A': None, 'B': None, 'C': None, 'D': None}
key_tuple[0] = 'D'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-2cecbefa7db2> in <module>()
----> 1 key_tuple[0] = 'D'
TypeError: 'tuple' object does not support item assignment
#3. Argumentos da função
A imutabilidade das tuplas também as torna adequadas para serem passadas como argumentos de função.
Considere a seguinte função find_volume() que retorna o volume de um paralelepípedo dadas as dimensões: comprimento, largura e altura.
def find_volume(dimensions): l,b,h = dimensions return l*b*h
Suponha que essas dimensões estejam disponíveis em uma lista chamada dimensões. A chamada para find_volume() com dimensões como argumento retorna o volume.
dimensions = [2,8,5] find_volume(dimensions) 80
Você sempre pode alterar as dimensões armazenadas em uma lista.
dimensions = [20,8,5] find_volume(dimensions) 800
No entanto, às vezes você precisará que os valores permaneçam constantes e resistam à modificação. É quando você deve considerar armazenar os argumentos como uma tupla e usá-los na chamada da função.
#4. Valores de retorno de funções
Em Python, você encontrará tuplas em valores de retorno de funções. Quando você retorna vários valores de uma função, o Python os retorna implicitamente como uma tupla.
Considere a seguinte função return_even():
def return_even(num): even = [i for i in range(num) if (i%2==0)] return even,len(even)
- Recebe um número num como argumento
- Retorna a lista de números pares no intervalo [0,num) and the length of that list.
Let’s set the value of num 20 and call the function.
num = 20
Calling return_even() returns the two values in a tuple. You can call the type() function with the function call as the verification argument.
type(return_even(num)) # <class 'tuple'>
You can print out the return value to verify that it’s a tuple containing the list of even numbers as the first item and the length of the list as the second item.
print(return_even(num)) ([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]10)
Como há dois itens na tupla, você pode descompactá-los em duas variáveis, conforme mostrado abaixo.
even_nums, count = return_even(num) print(even_nums) print(count) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10
Conclusão
Espero que este tutorial tenha fornecido uma comparação abrangente da tupla do Python vs lista.
Vamos encerrar o tutorial com um resumo rápido:
- Lista e tuplas são estruturas de dados embutidas em Python.
- Semelhanças: iteráveis, suporte para indexação, fatiamento, diferentes tipos de dados e operador para teste de associação.
- Diferença chave: as listas são mutáveis e as tuplas são imutáveis.
- Outras diferenças: Comprimento fixo das tuplas e comprimento variável das listas, tamanho menor na memória das tuplas.
- Quando você deve usar uma tupla? Para coleções imutáveis, chaves de dicionário e argumentos de função.
Em seguida, confira os projetos Python para praticar e aprender. Ou aprenda métodos para remover itens duplicados das listas do Python. Feliz aprendizado! então, boa codificação!👩🏽💻