Qual é a diferença entre listas e tuplas?

Qual é a diferença?

Quais são as vantagens / desvantagens das tuplas / listas?

Além de as tuplas serem imutáveis, há também uma distinção semântica que deve orientar seu uso. As tuplas são estruturas de dados heterogêneas (ou seja, suas entradas têm significados diferentes), enquanto as listas são sequências homogêneas. As tuplas têm estrutura, as listas têm ordem.

O uso dessa distinção torna o código mais explícito e compreensível.

Um exemplo seria pares de número de página e linha para fazer referência a locais em um livro, por exemplo:

my_location = (42, 11)  # page number, line number

Você pode usar isso como uma chave em um dicionário para armazenar anotações em locais. Uma lista, por outro lado, pode ser usada para armazenar vários locais. Naturalmente, pode-se adicionar ou remover locais da lista, por isso faz sentido que as listas sejam mutáveis. Por outro lado, não faz sentido adicionar ou remover itens de um local existente - portanto, as tuplas são imutáveis.

Pode haver situações em que você deseja alterar itens dentro de uma tupla de local existente, por exemplo, ao iterar pelas linhas de uma página. Mas a imutabilidade da tupla obriga a criar uma nova tupla de localização para cada novo valor. Isso parece inconveniente, mas usar dados imutáveis ​​como esse é uma pedra angular de tipos de valor e técnicas de programação funcional, que podem ter vantagens substanciais.

Existem alguns artigos interessantes sobre esse assunto, por exemplo, "Tuplas do Python não são apenas listas constantes" ou "Entendendo as tuplas versus listas no Python" . A documentação oficial do Python também menciona isso

"As tuplas são imutáveis ​​e geralmente contêm uma sequência heterogênea ...".

Em uma linguagem de tipo estaticamente como Haskell, os valores em uma tupla geralmente têm tipos diferentes e o comprimento da tupla deve ser fixo. Em uma lista, todos os valores têm o mesmo tipo e o comprimento não é fixo. Então a diferença é muito óbvia.

Finalmente, há o nome nomeado no Python, o que faz sentido, porque uma tupla já deve ter estrutura. Isso enfatiza a ideia de que as tuplas são uma alternativa leve a classes e instâncias.

Diferença entre lista e tupla

1. Literal

   someTuple = (1,2)
   someList  = [1,2] 

2. Tamanho

   a = tuple(range(1000))
   b = list(range(1000))
   
   a.__sizeof__() # 8024
   b.__sizeof__() # 9088

   Devido ao tamanho menor de uma operação de tupla, ela se torna um pouco mais rápida, mas não há muito o que mencionar até que você tenha um grande número de elementos.

3. Operações permitidas

   b    = [1,2]   
   b[0] = 3       # [3, 2]
   
   a    = (1,2)
   a[0] = 3       # Error

   Isso também significa que você não pode excluir um elemento ou classificar uma tupla. No entanto, você pode adicionar um novo elemento à lista e à tupla, com a única diferença de que, como a tupla é imutável, você não está realmente adicionando um elemento, mas criando uma nova tupla, para que o ID seja alterado

   a     = (1,2)
   b     = [1,2]  
   
   id(a)          # 140230916716520
   id(b)          # 748527696
   
   a   += (3,)    # (1, 2, 3)
   b   += [3]     # [1, 2, 3]
   
   id(a)          # 140230916878160
   id(b)          # 748527696

4. Uso

   Como uma lista é mutável, ela não pode ser usada como chave em um dicionário, enquanto uma tupla pode ser usada.

   a    = (1,2)
   b    = [1,2] 
   
   c = {a: 1}     # OK
   c = {b: 1}     # Error

Se você fosse dar um passeio, poderia observar suas coordenadas a qualquer instante em uma (x,y)tupla.

Se você quiser gravar sua jornada, poderá anexar sua localização a cada poucos segundos a uma lista.

Mas você não poderia fazer o contrário.

A principal diferença é que as tuplas são imutáveis. Isso significa que você não pode alterar os valores em uma tupla depois de criá-lo.

Portanto, se você precisar alterar os valores, use uma Lista.

Benefícios para tuplas:

1. Ligeira melhoria no desempenho.
2. Como uma tupla é imutável, pode ser usada como uma chave em um dicionário.
3. Se você não pode alterá-lo, nem qualquer outra pessoa, ou seja, não precisa se preocupar com nenhuma função da API, etc. alterando sua tupla sem ser solicitado.

Listas são mutáveis; tuplas não são.

Em docs.python.org/2/tutorial/datastructures.html

As tuplas são imutáveis ​​e geralmente contêm uma sequência heterogênea de elementos que são acessados ​​por descompactação (veja mais adiante nesta seção) ou indexação (ou mesmo por atributo no caso dos nomeados). As listas são mutáveis ​​e seus elementos geralmente são homogêneos e são acessados ​​através da iteração sobre a lista.

Foi mencionado que a diferença é amplamente semântica: as pessoas esperam que uma tupla e uma lista representem informações diferentes. Mas isso vai além de uma diretriz; algumas bibliotecas realmente se comportam de maneira diferente com base no que são transmitidas. Veja o NumPy, por exemplo (copiado de outro post, onde peço mais exemplos):

>>> import numpy as np
>>> a = np.arange(9).reshape(3,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> idx = (1,1)
>>> a[idx]
4
>>> idx = [1,1]
>>> a[idx]
array([[3, 4, 5],
       [3, 4, 5]])

O ponto é que, embora o NumPy possa não fazer parte da biblioteca padrão, é uma importante biblioteca Python, e nas listas e tuplas do NumPy são coisas completamente diferentes.

As listas são para loop, as tuplas são para estruturas, ie "%s %s" %tuple.

As listas são geralmente homogêneas, as tuplas geralmente são heterogêneas.

As listas são de comprimento variável, as tuplas são de comprimento fixo.

Este é um exemplo de lista Python:

my_list = [0,1,2,3,4]
top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"]

Este é um exemplo de tupla do Python:

my_tuple = (a,b,c,d,e)
celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead")

As listas e tuplas de Python são semelhantes, pois ambas são coleções de valores ordenadas. Além da pouca diferença que as listas são criadas usando colchetes "[..., ...]" e tuplas usando parênteses "(..., ...)", a técnica principal "codificada na sintaxe do Python" diferencia entre eles. é que os elementos de uma tupla específica são imutáveis, enquanto as listas são mutáveis ​​(... portanto, somente as tuplas são hasháveis ​​e podem ser usadas como chaves de dicionário / hash!). Isso gera diferenças na maneira como elas podem ou não ser usadas (impostas a priori pela sintaxe) e diferenças na maneira como as pessoas escolhem usá-las (incentivadas como 'melhores práticas', a posteriori, é isso que as inteligentes programadores fazem). as pessoas dão à ordem dos elementos.

Para tuplas, 'ordem' significa nada mais do que apenas uma 'estrutura' específica para armazenar informações. Quais valores encontrados no primeiro campo podem ser facilmente alternados para o segundo campo, pois cada um fornece valores em duas dimensões ou escalas diferentes. Eles fornecem respostas para diferentes tipos de perguntas e são tipicamente da forma: para um determinado objeto / sujeito, quais são seus atributos? O objeto / sujeito permanece constante, os atributos diferem.

Para listas, 'ordem' significa uma sequência ou uma direcionalidade. O segundo elemento DEVE vir depois o primeiro, porque está posicionado em 2º lugar com base em uma escala ou dimensão específica e comum. Os elementos são tomados como um todo e geralmente fornecem respostas para uma única pergunta tipicamente da forma, para um determinado atributo, como esses objetos / assuntos se comparam? O atributo permanece constante, o objeto / assunto é diferente.

Existem inúmeros exemplos de pessoas na cultura popular e programadores que não se adaptam a essas diferenças e há inúmeras que podem usar um garfo de salada no prato principal. No final do dia, está tudo bem e ambos geralmente podem fazer o trabalho.

Para resumir alguns dos detalhes

Semelhanças:

1. Duplicatas - tuplas e listas permitem duplicatas

2. Indexação, seleção e fatiamento - As tuplas e as listas indexam usando valores inteiros encontrados entre colchetes. Portanto, se você deseja os três primeiros valores de uma determinada lista ou tupla, a sintaxe seria a mesma:

   >>> my_list[0:3]
   [0,1,2]
   >>> my_tuple[0:3]
   [a,b,c]

3. Comparação e classificação - Duas tuplas ou duas listas são comparadas pelo primeiro elemento e, se houver um empate, pelo segundo elemento e assim por diante. Nenhuma atenção adicional é dada aos elementos subsequentes depois que os elementos anteriores mostram uma diferença.

   >>> [0,2,0,0,0,0]>[0,0,0,0,0,500]
   True
   >>> (0,2,0,0,0,0)>(0,0,0,0,0,500)
   True

Diferenças: - A priori, por definição

1. Sintaxe - lista use [], tuplas use ()

2. Mutabilidade - Os elementos de uma determinada lista são mutáveis, os elementos de uma determinada tupla NÃO são mutáveis.

   # Lists are mutable:
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son']
   >>> top_rock_list[1]
   'Kashmir'
   >>> top_rock_list[1] = "Stairway to Heaven"
   >>> top_rock_list
   ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son']
   
   # Tuples are NOT mutable:       
   >>> celebrity_tuple
   ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead')
   >>> celebrity_tuple[5]
   'Dead'
   >>> celebrity_tuple[5]="Alive"
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: 'tuple' object does not support item assignment

3. Tabelas de hash (dicionários) - Como as tabelas de hash ( dicionários) exigem que suas chaves sejam laváveis ​​e, portanto, imutáveis, apenas as tuplas podem atuar como chaves de dicionário, não como listas.

   #Lists CAN'T act as keys for hashtables(dictionaries)
   >>> my_dict = {[a,b,c]:"some value"}
   Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
   TypeError: unhashable type: 'list'
   
   #Tuples CAN act as keys for hashtables(dictionaries)
   >>> my_dict = {("John","Wayne"): 90210}
   >>> my_dict
   {('John', 'Wayne'): 90210}

Diferenças - A posteriori, em uso

1. Homo vs. heterogeneidade de elementos - geralmente os objetos de lista são homogêneos e os de tupla são heterogêneos. Ou seja, as listas são usadas para objetos / assuntos do mesmo tipo (como todos os candidatos à presidência, todas as músicas ou todos os corredores), embora não sejam obrigados a isso), enquanto as tuplas são mais para objetos heterogêneos.

2. Looping vs. Estruturas - Embora ambos permitam loop (para x em my_list ...), realmente faz sentido fazê-lo para uma lista. As tuplas são mais apropriadas para estruturar e apresentar informações (% s% s que residem em% s é% s e atualmente% s% ("John", "Wayne", 90210, "Ator", "Morto"))

Os valores da lista podem ser alterados a qualquer momento, mas os valores das tuplas não podem ser alterados.

As vantagens e desvantagens dependem do uso. Se você possui esses dados que nunca deseja alterar, deve usar a tupla, caso contrário, a lista é a melhor opção.

Diferença entre lista e tupla

Tuplas e listas são tipos de sequência aparentemente semelhantes no Python.

1. Sintaxe literal

   Usamos parênteses ( ) para construir tuplas e colchetes [ ]para obter uma nova lista. Além disso, podemos usar a chamada do tipo apropriado para obter a estrutura necessária - tupla ou lista.

   someTuple = (4,6)
   someList  = [2,6] 

2. Mutabilidade

   Tuplas são imutáveis, enquanto listas são mutáveis. Este ponto é a base para os seguintes.

3. Uso de memória

   Devido à mutabilidade, você precisa de mais memória para listas e menos memória para tuplas.

4. Estendendo

   Você pode adicionar um novo elemento às tuplas e às listas com a única diferença de que o ID da tupla será alterado (ou seja, teremos um novo objeto).

5. Hashing

   Tuplas são hashable e listas não são. Isso significa que você pode usar uma tupla como chave em um dicionário. A lista não pode ser usada como chave em um dicionário, enquanto uma tupla pode ser usada

   tup      = (1,2)
   list_    = [1,2] 
   
   c = {tup   : 1}     # ok
   c = {list_ : 1}     # error

6. Semântica

   Este ponto é mais sobre as melhores práticas. Você deve usar tuplas como estruturas de dados heterogêneas, enquanto listas são sequências homogêneas.

As listas devem ser sequências homogêneas, enquanto as tuplas são estruturas de dados heterogêneas.

Como as pessoas já responderam aqui que tuples são imutáveis ​​enquantolists são mutáveis, mas há um aspecto importante do uso de tuplas que devemos lembrar

Se tuplecontiver um listou umdictionary interior, esses podem ser alterados mesmo que otuple próprio seja imutável.

Por exemplo, vamos supor que temos uma tupla que contém uma lista e um dicionário como

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

podemos mudar o conteúdo da lista como

my_tuple[3][0] = 400
my_tuple[3][1] = 500

o que faz com que a nova tupla pareça

(10, 20, 30, [400, 500], {'a': 10})

também podemos alterar o dicionário dentro da tupla como

my_tuple[4]['a'] = 500

o que fará com que a tupla geral pareça

(10, 20, 30, [400, 500], {'a': 500})

Isso acontece porque list edictionary são os objetos e esses objetos não estão mudando, mas o conteúdo está apontando para.

Portanto, os tuplerestos são imutáveis, sem exceção

O PEP 484 - Type Hints diz que os tipos de elementos de a tuplepodem ser digitados individualmente; para que você possa dizer Tuple[str, int, float]; mas list, com Listtipagem classe pode tomar apenas um parâmetro do tipo:List[str] que pistas de que a diferença de 2 realmente é que o primeiro é heterogêneo, enquanto o segundo intrinsecamente homogêneo.

Além disso, a biblioteca padrão usa principalmente a tupla como valor de retorno de tais funções padrão em que o C retornaria a struct.

Como as pessoas já mencionaram as diferenças, escreverei sobre o porquê das tuplas.

Por que as tuplas são preferidas?

Otimização de alocação para pequenas tuplas

Para reduzir a fragmentação da memória e acelerar as alocações, o Python reutiliza tuplas antigas. Se uma tupla não for mais necessária e tiver menos de 20 itens em vez de excluí-la permanentemente, o Python a moverá para uma lista gratuita.

Uma lista gratuita é dividida em 20 grupos, onde cada grupo representa uma lista de tuplas de comprimento n entre 0 e 20. Cada grupo pode armazenar até 2.000 tuplas. O primeiro grupo (zero) contém apenas 1 elemento e representa uma tupla vazia.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

No exemplo acima, podemos ver que aeb têm o mesmo ID. Isso porque imediatamente ocupamos uma tupla destruída que estava na lista gratuita.

Otimização de alocação para listas

Como as listas podem ser modificadas, o Python não usa a mesma otimização que nas tuplas. No entanto, as listas Python também têm uma lista grátis, mas são usadas apenas para objetos vazios. Se uma lista vazia for excluída ou coletada pelo GC, ela poderá ser reutilizada posteriormente.

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Fonte: https://rushter.com/blog/python-lists-and-tuples/

Por que as tuplas são eficientes que as listas? -> https://stackoverflow.com/a/22140115

Uma cotação de direção da documentação em 5.3. Tuplas e Sequências :

Embora as tuplas possam parecer semelhantes às listas, elas geralmente são usadas em diferentes situações e para diferentes propósitos. As tuplas são imutáveis e geralmente contêm uma sequência heterogênea de elementos que são acessados ​​por descompactação (veja mais adiante nesta seção) ou indexação (ou mesmo por atributo no caso dos nomeados). As listas são mutáveis e seus elementos geralmente são homogêneos e são acessados ​​através da iteração sobre a lista.

Primeiro de tudo, ambos são objetos não escalares (também conhecidos como objetos compostos) no Python.

• Tuplas, sequência ordenada de elementos (que pode conter qualquer objeto sem problema de alias)
  • Imutável (tupla, int, float, str)
  • Concatenação usando +(nova tupla será criada, é claro)
  • Indexação
  • Fatiamento
  • Singleton em (3,) # -> (3)vez de(3) # -> 3
• Lista (matriz em outros idiomas), sequência ordenada de valores
  • Mutável
  • Singleton [3]
  • Clonagem new_array = origin_array[:]
  • A compreensão da lista [x**2 for x in range(1,7)]fornece [1,4,9,16,25,36](não legível)

A lista de uso também pode causar um erro de alias (dois caminhos distintos apontando para o mesmo objeto).

As listas são mutáveis ​​e as tuplas são imutáveis. Apenas considere este exemplo.

a = ["1", "2", "ra", "sa"]    #list
b = ("1", "2", "ra", "sa")    #tuple

Agora altere os valores do índice da lista e da tupla.

a[2] = 1000
print a     #output : ['1', '2', 1000, 'sa']
b[2] = 1000
print b     #output : TypeError: 'tuple' object does not support item assignment.

Portanto, provou que o código a seguir é inválido na tupla, porque tentamos atualizar uma tupla, o que não é permitido.

A lista é mutável e as tuplas são imutáveis. A principal diferença entre mutável e imutável é o uso de memória quando você está tentando anexar um item.

Quando você cria uma variável, alguma memória fixa é atribuída à variável. Se for uma lista, mais memória é atribuída do que realmente usada. Por exemplo, se a atribuição de memória atual for 100 bytes, quando você quiser acrescentar o 101º byte, talvez outros 100 bytes sejam atribuídos (no total 200 bytes neste caso).

No entanto, se você souber que não adiciona frequentemente novos elementos, use tuplas. Tuplas atribui exatamente o tamanho da memória necessária e, portanto, economiza memória, especialmente quando você usa grandes blocos de memória.