tuplas - tupla python 3




Qual a diferença entre listas e tuplas? (12)

Diferença entre lista e tupla

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

  1. Sintaxe literal

    Nós 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

    As tuplas são imutáveis, enquanto as 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 a ambas as tuplas e listas, com a única diferença de que o id da tupla será alterado (ou seja, teremos um novo objeto).

  5. Hashing

    As tuplas são hasháveis ​​e as 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 uma 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 as listas são seqüências homogêneas.

Qual é a diferença?

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


A diferença básica que eu encontrei é que as listas são mutáveis ​​onde as tuplas são imutáveis. As tuplas são boas para cálculos nos quais elas não precisam ser alteradas.


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á-la.

Então, se você precisar alterar os valores, use uma Lista.

Benefícios para as tuplas:

  1. Melhoria no desempenho.
  2. Como uma tupla é imutável, ela pode ser usada como uma chave em um dicionário.
  3. Se você não pode alterá-lo, ninguém pode, o que quer dizer que você não precisa se preocupar com quaisquer funções da API, etc., mudando sua tupla sem ser solicitado.

Além das 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 seqüências homogêneas. Tuplas tem estrutura, listas tem ordem.

Usar essa distinção torna o código mais explícito e compreensível.

Um exemplo seria pares de números de página e linha para locais de referência 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 notas em locais. Por outro lado, uma lista poderia ser usada para armazenar vários locais. Naturalmente, pode-se querer adicionar ou remover locais da lista, então 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 em uma tupla de local existente, por exemplo, ao percorrer as linhas de uma página. Mas a imutabilidade da tupla força você a criar uma nova tupla de localização para cada novo valor. Isso parece inconveniente diante disso, 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, "As tuplas do Python não são apenas listas constantes" ou "Entendendo tuplas x 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 estaticamente tipificada 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 namedtuple em Python, o que faz sentido porque uma tupla já deve ter estrutura. Isso sublinha a ideia de que as tuplas são uma alternativa leve a classes e instâncias.


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 de í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.

Daí provou o seguinte código é inválido com tuple, porque tentamos atualizar uma tupla, o que não é permitido.


As listas são mutáveis; tuplas não são.

De 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 ​​via desempacotamento (veja mais adiante nesta seção) ou indexação (ou até mesmo por atributo no caso de exemplos nomeados). As listas são mutáveis ​​e seus elementos geralmente são homogêneos e são acessados ​​pela iteração da lista.


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

Se a tuple contiver uma list ou um dictionary dentro dela, elas podem ser alteradas mesmo se a própria tuple for 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 se pareça

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

nós também podemos mudar 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 a list e o dictionary são os objetos e esses objetos não estão mudando, mas o conteúdo está apontando.

Então a tuple permanece imutável sem qualquer exceção


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 muito para 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 alterar o id da tupla adicionando elemento

    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 uma 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

Foi mencionado que a diferença é em grande parte 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 passadas. Tome 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 é, enquanto o NumPy pode não ser parte da biblioteca padrão, é uma grande biblioteca Python, e dentro das listas NumPy e tuplas são coisas completamente diferentes.


O PEP 484 - Type Hints diz que os tipos de elementos de uma tuple podem ser digitados individualmente; para que você possa dizer Tuple[str, int, float] ; mas uma list , com a classe de tipagem List pode ter apenas um parâmetro de tipo: List[str] , que sugere que a diferença dos dois é realmente que o primeiro é heterogêneo, enquanto o segundo é intrinsecamente homogêneo.

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


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

  • Tuplas, sequência ordenada de elementos (que podem conter qualquer objeto sem problema de aliasing)
    • Imutável (tuple, int, float, str)
    • Concatenação usando + (nova tupla será criada, é claro)
    • Indexação
    • Fatiamento
    • Singleton (3,) # -> (3) vez de (3) # -> 3
  • List (Array em outras linguagens), sequência ordenada de valores
    • Mutável
    • Solteirão [3]
    • Clonagem new_array = origin_array[:]
    • A compreensão da lista [x**2 for x in range(1,7)] dá-lhe [1,4,9,16,25,36] (Não legível)

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


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

Se você quisesse gravar sua jornada, poderia acrescentar sua localização a cada poucos segundos a uma lista.

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







tuples