Qual é a diferença entre listas e tuplas?

1020

Qual é a diferença?

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

Lucas Gabriel Sánchez
fonte
13
Os outros responderam abaixo, mas eu gostaria de salientar que, imho, python tem nomes de tipos de dados totalmente não intuitivos. Acho que nenhum outro idioma possui tuplas (com esse nome) e, o que é pior, como uma palavra, eu não consigo nem traduzi-lo no meu idioma. Alguém sabe de onde vem a "tupla"? Holandês?
Rook
98
Tuplas são um termo básico em matemática, derivado do latim (consulte a Wikipedia).
nikow
129
par -> triplo -> quádruplo -> quintuplo -> sextuplo -> hum, como é chamado, ah sod, 7-tupla -> 8-tupla -> ... daí 'tupla' como um nome genérico.
John Fouhy
31
@JohnFouhy Faz mais de seis anos depois, mas: ... heptuple, octuple, tuple-with-non-elements, decuple, undecuple, dodecuple ...: D
Augusta
18
@MegaWidget Pensei que tínhamos estabelecido que um não-duplo era um list. ; D
Augusta

Respostas:

1017

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.

Nikow
fonte
11
+1, especialmente no seu segundo link, com um ótimo exemplo. Adore esta citação: "Esta tupla funciona como um registro ou estrutura leve."
22909 Baltimark
105
"listas são sequências homogêneas" - eu sou novo no Python, mas as listas não são heterogêneas? Em docs.python.org/py3k/tutorial/introduction.html : "Os itens da lista nem todos precisam do mesmo tipo". Mas talvez você esteja falando sobre o conceito formal, e não o Python.
Matthew Cornell
13
Um bom sinônimo semântico para "tupla" pode ser "registro". É uma coleção de itens de dados relacionados em uma sequência específica. Na verdade, eu sinto que collections.namedtupleseria melhor chamado collections.record. Não faria sentido trocar, digamos, o nome e o endereço em um registro do cliente; de fato, isso geralmente seria um erro, que a imutabilidade da tupla impede que você cometa.
Kindall
4
@nikow: Em relação What would you do with such a list?, sempre tremo quando as pessoas usam a falta de fantasia como argumento. O uso de listas de tipos mistos funciona muito bem, por exemplo, para algumas estruturas hierárquicas de dados, nas quais cada lista é composta de listas filho e elementos de valor.
Sebastian Mach
18
Não é enganoso dizer que as tuplas são heterogêneas e as listas são homogêneas? Por exemplo, uma lista pode ter misturas de diferentes tipos de dados, ou seja, l = [1, 2, 'a']. Eu não entendo do que você está falando.
Celeritas
362

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
Nikita
fonte
Então, o que acontece quando tento redimensionar o tamanho da lista para valores grandes? Será que vai mudar o endereço de memória (que eu acredito que deve mudar o id). Ou isso me causará um erro?
WanderingMind
17
@WanderingMind: o endereço de memória em que os valores da lista estão armazenados não é o mesmo que o endereço de memória em que o próprio objeto da lista está armazenado.
Tom
2
Hmmm ... todo o código deste post, exceto a primeira caixa abaixo, 3. Permitted operationmostra primeiro a maiúscula. Eu sei que é comum mostrar sucesso e erro, mas isso mexeu com minha cabeça por alguns momentos.
dmckee --- gatinho ex-moderador
1
Conforme mostrado no ponto 3, uma única lista de elementos pode ser one_item_list = [a], masone_tuple = (a,) é a tupla correspondente. Observe a vírgula após o nome da variável. Mas também observe two_tuple = (a, b). Isso me assustou mais de uma vez (ainda lá no Python 3).
Mjkrause
1
@Cheng Porque a classificação da tupla seria modificada, ou seja, alteraria seus itens. Tuplas não suportam isso. A maneira mais simples de obter uma tupla classificada em python étuple(sorted(the_unsorted_tuple))
ApproachingDarknessFish
204

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.

dan-gph
fonte
37
Este exemplo parece apenas uma convenção. As pessoas poderiam argumentar: "Ainda posso usar [x, y] para anotar coordenadas, se eu quiser". Portanto, esta resposta é considerada incompleta a menos que mais uma frase: "Leia @nikow 's post para que você não deve usar a lista de coordenadas de loja"
RayLuo
71
@ Iceberg, minha resposta tem como objetivo ajudar a desenvolver a intuição. Não é para explorar todas as nuances do tópico.
Dan-gph
8
Bom exemplo +1. Ele enfatiza a natureza complementar dos elementos da tupla (aqui as coordenadas), razão pela qual a modificação de qualquer um deles não é permitida - porque altera o significado de toda a tupla (aqui, a posição de um ponto).
Hao Wang
77

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.
Dave Webb
fonte
14
Observe que uma tupla só é imutável se todos os seus elementos forem . Você poderia dizer o mesmo para todas as coleções imutáveis, como frozensetos vários dict / tree / etc congelados de terceiros. tipos, mas nenhum deles permite adicionar elementos mutáveis. (E, claro, uma tupla só é Hashable se todos os seus elementos são, que é alças na forma EAFP o habitual, por isso d[1, [2]]irá aumentar TypeError: unhashable type: 'list'.)
abarnert
1
Uma tupla só pode ser usada como chave em um dicionário se todos os seus elementos forem imutáveis. Veja aqui
Will Dereham
31

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.

duffymo
fonte
1
Eu realmente acho que você também deve considerar as implicações semânticas (veja minha resposta abaixo).
nikow
Dificilmente parece valer a pena o esforço agora, mas obrigado pelo alerta.
31410 duffymo
Seis meses depois, e é isso que você pode contribuir? Eu dei essa resposta na época porque, nas quatro horas que se passaram entre minha resposta original e o comentário, outros haviam compensado a diferença. A resposta estava incorreta? Na verdade não, embora tenha sido aprimorado pelo nikow. Então, o que um link realmente adicionaria?
Duffymo 01/09/09
4
É engraçado ver como outras respostas aqui têm a mesma qualidade, mas somente isso é odiado por causa de um comentarista dizendo "-1". E há outra resposta que tem apenas 0,5 vezes a qualidade, mas apenas 0,1 vezes os votos negativos.
Sebastian Mach
2
Duffymo @ Acho que esta resposta é a mais clara e concisa nesta página. Ele nomeia a única diferença realmente importante entre tuplas e listas e não fala sem parar sobre esse flagrante flagrante falso homogêneo versus heterogêneo.
antred 20/10/2015
20

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.

Shep
fonte
2
Esta não é realmente uma resposta útil. A diferença é que type(a_list) != type(a_tuple), portanto, qualquer pedaço de código da biblioteca ramificação com base em type(x)se comportará de forma diferente
Eric
1
bom ponto, editei o post: isso realmente indica que as diretrizes semânticas estão codificadas em algumas bibliotecas.
Shep
1
Talvez seja melhor usar exemplos do stdlib / builtins do que de bibliotecas de terceiros. Existem vários locais onde você pode usar um único valor ou uma tupla de valores, e uma lista ou outra sequência é considerada um valor único. Por exemplo, '%d %d' % [2, 3]é a TypeError, porque você está tentando passar uma lista para a primeira %de não está passando nenhum valor para a segunda %d. (No entanto, existem contra-exemplos a esta também, como max...)
abarnert
isso é interessante, eu não sabia que havia exemplos disso na biblioteca padrão do python. Um número de lugares que você diz?
Shep
18

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.

Srinivas Reddy Thatiparthy
fonte
16

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"))

Inspiração
fonte
Eu gosto do exemplo hashtable / hashable para explicar um motivo de imutabilidade - você pode usar uma tupla (registro / estrutura / coordenada / vetor / ponto) como uma chave complexa em um ditado.
Dave X
9

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.

azulado
fonte
7

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.

iNet
fonte
1
Meu voto aqui para a discussão explícita de extensão e hash, que eu não percebi nas muito boas respostas existentes.
dmckee --- gatinho ex-moderador
6

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

pquers
fonte
26
Nesse ponto, essa resposta não adiciona nada à discussão, pois há muitas outras respostas melhores.
Jonathon Reinhart 25/11
5

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

Daksh
fonte
Esta postagem seria melhorada se você explicasse que "essas podem ser alteradas mesmo que a tupla seja imutável". é porque esses objetos mantêm sua identidade enquanto (portanto, a tupla não mudou porque ainda contém os mesmos objetos ...).
dmckee --- gatinho ex-moderador
3

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.

Antti Haapala
fonte
3

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

Pygirl
fonte
2

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.

Albus Dumbledore
fonte
1

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).

Lorem Ipsum Dolor
fonte
0

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.

Rahul Sawriya
fonte
-1

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.

Tony
fonte
2
Embora parte disso seja tecnicamente verdade, essa não é realmente a diferença crucial entre tipos mutáveis ​​e imutáveis. A maior diferença é que tipos mutáveis ​​podem ser alterados após a construção, enquanto tipos imutáveis ​​não podem.
Roger Ventilador
1
Esse também não é o porquê. Memória e mutabilidade não têm nada a ver uma com a outra. Isso é simplesmente um detalhe de implementação específico para listas. A memória também não é atribuída a variáveis, é atribuída aos objetos. Variáveis ​​são apenas referências a esses objetos.
Roger Ventilador