Pitão:qual é a diferença entre (1,2,3) e [1,2,3] e quando devo usar cada um?

StackOverflow https://stackoverflow.com/questions/1983

  •  08-06-2019
  •  | 
  •  

Pergunta

Em muitos lugares, (1,2,3) (uma tupla) e [1,2,3] (uma lista) pode ser usado de forma intercambiável.

Quando devo usar um ou outro e por quê?

Foi útil?

Solução

De Perguntas frequentes sobre Python:

Listas e tuplas, embora semelhantes em muitos aspectos, geralmente são usadas de maneiras fundamentalmente diferentes.As tuplas podem ser consideradas semelhantes aos registros Pascal ou estruturas C;são pequenas coleções de dados relacionados que podem ser de diferentes tipos e operados como um grupo.Por exemplo, uma coordenada cartesiana é representada apropriadamente como uma tupla de dois ou três números.

As listas, por outro lado, são mais parecidas com arrays em outras linguagens.Eles tendem a conter um número variável de objetos, todos do mesmo tipo e operados um por um.

Geralmente, por convenção, você não escolheria uma lista ou tupla apenas com base em sua (im) mutabilidade.Você escolheria uma tupla para pequenas coleções de dados completamente diferentes, nas quais uma classe completa seria muito pesada, e uma lista para coleções de qualquer tamanho razoável, nas quais você tivesse um conjunto homogêneo de dados.

Outras dicas

A lista [1,2,3] é dinâmico e flexível, mas essa flexibilidade tem um custo de velocidade.

A tupla (1,2,3) é fixo (imutável) e, portanto, mais rápido.

Tuplas são uma maneira rápida e flexível de criar composto tipos de dados.Listas são contêineres para, bem, listas de objetos.

Por exemplo, você usaria uma Lista para armazenar uma lista de detalhes dos alunos em uma turma.

Cada detalhe do aluno nessa lista pode ser uma tupla de três contendo o número do rolo, nome e pontuação do teste.

`[(1,'Mark',86),(2,'John',34)...]`

Além disso, como as tuplas são imutáveis, elas podem ser usadas como chaves em dicionários.

A noção de tuplas é altamente expressiva:

  • Pragmaticamente, eles são ótimos para empacotar e desempacotar valores (x,y=coord).

  • Em combinação com dicionários (tabelas hash), permitem formas de mapeamento que, de outra forma, exigiriam muitos níveis de associação.Por exemplo, considere marcar que (x,y) foi encontrado.

    // PHP
if (!isset($found[$x])) {
    $found[$x] = Array();
    $found[$x][$y] = true;
} else if (!isset($found[$x][$y])) {
    $found[$x][$y] = true;
}

# Python
found[(x,y)] = True # parens added for clarity

  • As listas devem ser utilizadas com a expectativa de operações sobre seu conteúdo (daí as diversas menções à imutabilidade).Alguém vai querer estourar, empurrar, emendar, fatiar, pesquisar, inserir antes, inserir depois, etc. com uma lista.

  • As tuplas devem ser uma representação de baixo nível de um objeto, onde são feitas comparações simples ou operações como extrair o enésimo elemento ou n elementos de maneira previsível, como o exemplo de coordenadas dado anteriormente.

  • Por último, as listas não são hasháveis, portanto o tipo de mapeamento feito com dicionários (tabelas hash em Perl, arrays associativos em PHP) deve ser feito com tuplas.

    Aqui está um exemplo simples de tuplas e dicionários, finalmente juntos:

    """
couple is a tuple of two people
doesLike is a dictionary mapping couples to True or False
"""
couple = "john", "jane"
doesLike = dict()
doesLike[couple] = True
doesLike["jane", "john"] = False # unrequited love :'(

[1, 2, 3] é uma lista na qual se pode adicionar ou excluir itens.
(1, 2, 3) é uma tupla na qual, uma vez definida, a modificação não pode ser feita.

Sempre que preciso passar uma coleção de itens para uma função, se quiser que a função não altere os valores passados, uso tuplas.

Caso contrário, se eu quiser ter a função de alterar os valores, eu uso list.

Sempre se você estiver usando bibliotecas externas e precisar passar uma lista de valores para uma função e não tiver certeza sobre a integridade dos dados, use uma tupla.

Como outros mencionaram, listas e tuplas são contêineres que podem ser usados ​​para armazenar objetos python.As listas são extensíveis e seu conteúdo pode mudar de acordo com a atribuição; por outro lado, as tuplas são imutáveis.

Além disso, as listas não podem ser usadas como chaves em um dicionário, ao passo que as tuplas podem.

abra um console e execute python.Experimente isto:

  >>> list = [1, 2, 3]     
  >>> dir(list)
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
    ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
    em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
     '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
    educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
    , '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 
'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Como você pode ver, a última lista da última linha tem os seguintes métodos:'anexar', 'contar', 'estender', 'indexar', 'inserir', 'pop', 'remover', 'reverter', 'classificar'

Agora tente o mesmo para tupla:

>>> tuple = (1, 2, 3)
>>> dir(tuple)
    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
    format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__get
    slice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__
    lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__'
    , '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

Apenas 'contagem' e 'índice' da lista de métodos aparece aqui.

Isso ocorre porque as tuplas são imutáveis ​​e não suportam nenhuma modificação.Em vez disso, são mais simples e rápidos na implementação interna.

  • Uma tupla pode representar uma chave no dicionário, porque é imutável.
  • Use listas se você tiver uma coleção de dados que não precisam de acesso aleatório.

Se você encontrar uma solução que funcione com tuplas, use-as, pois isso força a imutabilidade, o que o leva a um caminho mais funcional.Você quase nunca se arrepende de seguir o caminho funcional/imutável.

[1,2,3] é uma lista.

(1,2,3) é uma tupla e imutável.

(1,2,3) e [1,2,3] podem ser usados ​​indistintamente em condições raras.

Portanto, (1,2,3) é uma tupla e imutável.Quaisquer alterações que você deseja fazer precisam sobrescrever o objeto.

[1,2,3] é uma lista e os elementos podem ser anexados e removidos.

A lista tem mais recursos do que uma tupla.

(1,2,3) é uma tupla enquanto [1,2,3] é uma lista.Uma tupla é um objeto imutável, enquanto uma lista é mutável.

(1,2,3) é uma tupla e [1,2,3] é uma lista.Qualquer um dos dois representa sequências de números, mas observe que as tuplas são imutáveis ​​e a lista são objetos Python mutáveis.

(1,2,3) -Tuple [1,2,3] -list listas são mutáveis ​​nas quais várias operações podem ser realizadas, enquanto as tuplas são imutáveis ​​que não podem ser estendidas. Não podemos adicionar, excluir ou atualizar qualquer elemento de um tuplo uma vez é criado.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top