Métodos de listas em

Sobre Métodos de listas

Uma list é uma coleção mutável de itens em sequência. Tal como a maioria das coleções (vê os tipos incorporados tuple, dict e set), as listas podem conter referências a qualquer tipo de dados (ou a vários), incluindo outras listas. Em Python, são consideradas uma sequência e podem ser copiadas, no todo ou em parte, através da notação de slice. Tal como qualquer sequência, os elementos dentro das lists podem ser referenciados por um número de 0-based index a partir da esquerda, ou por um número de -1-based index a partir da direita.

As listas suportam tanto operações de sequência comuns como operações de sequência mutáveis, tais como min(<list>)/max(<list>), <list>.index(), <list>.append() e <list>.reverse(). Os itens podem ser percorridos com a construção for item in <list>, e com for index, item in enumerate(<list>) quando precisas tanto do elemento como do índice do elemento.

O Python oferece muitos métodos úteis para trabalhar com listas.

Uma vez que as listas são mutáveis, os métodos de lista alteram o objeto lista original que foi passado ao método. Se não quiseres mutar a lista, tens de fazer uma shallow copy (no mínimo) da list original, através de slice ou de <list>.copy().

Adicionar itens

Podes adicionar itens ao fim de uma lista existente com <list>.append(<item>):

>>> numbers = [1, 2, 3]
>>> numbers.append(9)

>>> numbers
[1, 2, 3, 9]

Em vez de acrescentar ao fim, <list>.insert(<index>, <item>) adiciona o item a um índice específico dentro da lista. <index> é o índice do item antes do qual queres que o novo item apareça. <item> é o elemento a inserir.

Nota: Se <index> for 0, o item é adicionado ao início da lista. Se <index> for maior do que o último índice da lista, o item é adicionado na posição final, o equivalente a usar <list>.append(<item>).

>>> numbers = [1, 2, 3]
>>> numbers.insert(0, -2)

>>> numbers
[-2, 1, 2, 3]

>>> numbers.insert(1, 0)

>>> numbers
[-2, 0, 1, 2, 3]

Um iterable pode ser combinado com uma lista existente (concatenando os dois) através de <list>.extend(<iterable>). <list>.extend(<iterable>) desempacota o iterável fornecido, adicionando os seus elementos, pela mesma ordem, ao fim da lista de destino. Nesta situação, usar <list>.append(<item>) adicionaria o iterável inteiro como um único item.

>>> numbers = [1, 2, 3]
>>> other_numbers = [5, 6, 7]

>>> numbers.extend(other_numbers)

>>> numbers
[1, 2, 3, 5, 6, 7]

>>> numbers.extend([8, 9])

>>> numbers
[1, 2, 3, 5, 6, 7, 8, 9]

Remover itens

Podes usar <list>.remove(<item>) para remover um elemento da lista. <list>.remove(<item>) lança um ValueError se o elemento não estiver presente na lista.

>>> numbers = [1, 2, 3]
>>> numbers.remove(2)

>>> numbers
[1, 3]

# Trying to remove a value that is not in the list throws a ValueError.
>>> numbers.remove(0)
ValueError: list.remove(x): x not in list

Em alternativa, usar o método <list>.pop(<index>) remove e return um elemento, para que o possas usar.

<list>.pop(<index>) recebe um parâmetro opcional: o index do elemento a remover e devolver. Se o argumento opcional <index> não for especificado, o último elemento da lista é removido e devolvido. Se <index> for um número superior ao último índice da lista, é lançado um IndexError.

>>> numbers = [1, 2, 3]
>>> numbers.pop(0)
1

>>> numbers
[2, 3]
>>> numbers.pop()
3

>>> numbers
[2]

# This will throw an error because there is only index 0.
>>> numbers.pop(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

Podes remover todos os itens de uma list com <list>.clear(). Não recebe nenhum parâmetro.

>>> numbers = [1, 2, 3]
>>> numbers.clear()

>>> numbers
[]

Inverter e reordenar

A ordem dos elementos de uma lista pode ser invertida no próprio local com <list>.reverse(). Isto modifica a lista original.

>>> numbers = [1, 2, 3]
>>> numbers.reverse()

>>> numbers
[3, 2, 1]

Uma lista pode ser reordenada no próprio local com a ajuda de <list>.sort(). A ordem de ordenação predefinida é ascendente a partir da esquerda. A documentação do Python oferece dicas e técnicas adicionais para ordenar.

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]

# The default sort order is *ascending*.
>>> names.sort()

>>> names
["Bruce", "Natasha", "Thor", "Tony"]

Para ordenar uma lista por ordem descendente, passa um argumento reverse=True ao método:

>>> names = ["Tony", "Natasha", "Thor", "Bruce"]
>>> names.sort(reverse=True)

>>> names
["Tony", "Thor", "Natasha", "Bruce"]

Nos casos em que mutar a list original não é desejável, podes usar as funções incorporadas sorted() e reversed(). sorted(<list>) devolve uma cópia ordenada e recebe os mesmos parâmetros que <list>.sort(). reversed(<list>) devolve um iterador que produz os itens da lista por ordem inversa. Os Iterators serão abordados em detalhe noutro exercício.

Ocorrências de um item numa lista

Podes descobrir o número de ocorrências de um elemento numa lista com a ajuda de <list>.count(<item>). Esta função devolve o número total de vezes que <item> aparece como elemento da lista.

>>> items = [1, 4, 7, 8, 2, 9, 2, 1, 1, 0, 4, 3]

>>> items.count(1)
3

Encontrar o índice dos itens

<list>.index(<item>) devolve o número de índice da primeira ocorrência de um item passado como argumento. Se não houver nenhuma ocorrência, é levantado um ValueError. A indexação é 0-based a partir da esquerda, o que significa que a posição do primeiro item é o índice 0. A indexação a partir da direita também é suportada, começando no índice -1.

>>> items = [7, 4, 1, 0, 2, 5]
>>> items.index(4)
1

>>> items.index(10)
ValueError: 10 is not in list

Indicar os índices start e end faz com que a pesquisa decorra numa secção específica da lista:

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]
>>> names.index("Tina")
0

>>> names.index("Tina", 2, 5)
3

Se não precisares da posição exata de um elemento, o operador incorporado in é mais eficiente para verificar se algo pertence à lista.

>>> names = ["Tina", "Leo", "Thomas", "Tina", "Emily", "Justin"]

>>> "Thomas" in names
True

Fazer cópias

Lembra-te de que, em Python, as variáveis são nomes que apontam para objetos subjacentes. Ao longo da vida de um programa, os nomes podem ser ligados ou religados a objetos diferentes. Atribuir um objeto list a um novo nome de variável não copia o objeto nem nenhum dos dados por ele referenciados. O novo nome e o antigo nome vão apontar ambos para o mesmo objeto list. Além disso, as listas são um objeto do tipo contentor: para poupar espaço, os contentores guardam apenas referências aos itens membros, não os próprios itens. Esta "otimização" pode ter consequências indesejadas para os incautos.

<list>.copy() cria um novo objeto list, mas não cria novos objetos para os elementos da lista referenciados: a cópia é "superficial". Uma shallow copy costuma ser suficiente quando queres adicionar ou remover itens de um dos objetos list sem modificar o outro. Mas se houver alguma possibilidade de os elementos subjacentes de uma list serem mutados acidentalmente (mutando assim todas as cópias superficiais relacionadas), deves usar copy.deepcopy() do módulo copy para criar uma cópia completa ou "profunda" de todas as referências e objetos.

Para uma explicação detalhada do comportamento de nomes, valores, listas e listas aninhadas, dá uma vista de olhos a este excelente artigo de blogue do Ned Batchelder, Names and values: making a game board. Shallow vs Deep Copying of Python Objects também oferece um bom resumo das considerações sobre cópias.