Tupla Python vs Lista: Semelhanças e Diferenças, Explicadas

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 Geekflare para codificar.

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. list[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 start ao end - 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. Portanto, 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 student_list 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 .

A expressão item in iterable é avaliada como True se o iterable contiver o item ; senão, False .

 "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. Portanto, 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 dimensions . A chamada para find_volume() com dimensions 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
• Ele retorna a lista de números pares no intervalo [0,num) e o comprimento dessa lista.

Vamos definir o valor de num 20 e chamar a função.

 num = 20

Chamar return_even() retorna os dois valores em uma tupla. Você pode chamar a função type() com a chamada de função como argumento de verificação.

 type(return_even(num)) # <class 'tuple'>

Você pode imprimir o valor de retorno para verificar se é uma tupla contendo a lista de números pares como o primeiro item e o comprimento da lista como o segundo 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!