2.7. Listas

Uma lista é uma sequência mutável e ordenada de valores. Ao contrário das cadeias de caracteres e dos bytes, as listas podem conter valores de qualquer tipo, e é possível alterar, adicionar ou remover itens no próprio objeto.

2.7.1. Criar listas

Parênteses retos criam um literal de lista:

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

O construtor list constrói uma lista a partir de qualquer iterável:

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. Comprimento, indexação e fatiamento

len() devolve o número de itens. A indexação e o fatiamento funcionam da mesma forma que nas cadeias de caracteres – as posições começam em 0, os índices negativos contam a partir do fim, e um fatia fora do intervalo válido é silenciosamente truncada em vez de lançar uma exceção:

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

Os índices positivos contam a partir do início; os índices negativos contam a partir do fim.

A sintaxe de fatiamento é um atalho para um objeto slice que o Python constrói nos bastidores. nums[1:4] é equivalente a nums[slice(1, 4)]. Raramente se constrói um manualmente, mas slice() é ocasionalmente útil para armazenar um fatia como valor a reutilizar:

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. Mutar uma lista

As listas suportam atribuição por índice e por fatia no próprio objeto:

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

Os métodos de lista mais comuns:

• list.append() – adicionar um único item ao final.

• list.extend() – acrescentar todos os itens de um iterável.

• list.insert() – inserir numa posição específica.

• list.remove() – eliminar a primeira ocorrência de um valor.

• list.pop() – remover e devolver um item (o último, por omissão).

• list.clear() – remover todos os itens.

• list.sort() – ordenar no próprio objeto. Passe reverse=True para ordem decrescente.

• list.reverse() – inverter no próprio objeto.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

Estes métodos modificam a lista no próprio objeto e devolvem None. Escrever

nums = nums.sort()    # nums is now None -- common bug

é quase nunca o que se pretende; a nums original foi ordenada, mas a atribuição sobrescreve o nome com o valor de retorno. Ou se chama nums.sort() numa linha própria, ou se usa a função integrada sorted() para obter uma nova lista ordenada sem mutar a original.

2.7.4. Operadores

• + concatena duas listas numa nova lista.

• * repete uma lista.

• in testa a pertença.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. Iterar sobre uma lista

Um ciclo for percorre os itens em ordem:

for n in [10, 20, 30]:
    print(n)

2.7.6. Aliasing e mutação

Uma lista é um único valor em memória; vários nomes podem apontar para a mesma lista. Mutar através de um nome é visível através de todos os outros nomes que apontam para a mesma lista.

a e b apontam ambos para a mesma lista. Mutar através de qualquer dos nomes altera o que todos os outros nomes veem.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

Para fazer uma cópia independente, fatie a lista inteira ou chame o construtor list:

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

Isto copia apenas a lista de nível superior; as listas aninhadas continuam a ser partilhadas entre o original e a cópia.