Listas em Python: como criar, indexar, adicionar, ordenar e iterar

Listas são sequências ordenadas e mutáveis

A lista é o tipo de coleção mais usado em Python. Se você está mantendo um conjunto ordenado de valores que pode mudar — adicionar, remover, ordenar, atualizar — uma lista é quase sempre a escolha certa.

Crie uma com colchetes:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

Listas podem conter qualquer coisa, até outras listas. Na prática, a maioria das listas acaba contendo um tipo só de coisa — uma lista de usuários, uma lista de números — porque é o que é mais fácil de raciocinar.

Indexação

Cada item tem uma posição, começando em 0. Acesse com colchetes:

fruits = ["apple", "banana", "cherry"]

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry' — negative indexes count from the end
print(fruits[-2])   # 'banana'

Pedir um índice que não existe gera IndexError. Se você pode estar fora de alcance, ou confira o tamanho antes ou envolva o acesso num try.

Fatiamento

Fatiamento te dá um intervalo de itens. A sintaxe é lista[start:stop:step], igual a strings:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2] — from the start
print(nums[7:])       # [7, 8, 9] — to the end
print(nums[::2])      # [0, 2, 4, 6, 8] — every other item
print(nums[::-1])     # reversed copy

Duas coisas para fixar:

• Fatiamento sempre retorna uma nova lista. Modificar a fatia não afeta a original.
• O índice stop é exclusivo — nums[2:5] dá os índices 2, 3 e 4, não 5.

Como adicionar, estender e inserir itens

Os três métodos de "adicionar a uma lista" fazem coisas diferentes, e misturar eles é fonte comum de bug:

items = ["a", "b", "c"]

items.append("d")       # add ONE item to the end
items.insert(0, "z")    # insert ONE item at a specific index
items.extend(["e", "f"])  # add EACH item from another iterable

print(items)

• append(x) adiciona x como um único elemento — mesmo que x seja uma lista. items.append([1, 2]) adiciona a lista em si como uma entrada.
• extend(iteravel) adiciona cada item do iterável. items.extend([1, 2]) adiciona duas entradas.
• insert(i, x) insere num índice específico, deslocando tudo que está em i ou depois uma posição para a direita.

+= com uma lista à direita funciona como extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

E para remover:

items = ["a", "b", "c", "b", "d"]

items.remove("b")       # removes the first occurrence of "b"
print(items)

last = items.pop()      # removes and returns the last item
print(last, items)

second = items.pop(0)   # remove and return the item at index 0
print(second, items)

Se você tentar remove() algo que não está na lista, o Python gera ValueError. Se precisa de "remover se presente", ou cheque in antes ou use um try.

Você também pode deletar por índice com del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

Tamanho, pertinência, contagem

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4 — index of the first 23

in é o jeito legível de checar se uma lista contém um valor. Se você vai fazer essa pergunta muitas vezes sobre uma lista grande, use um set — pertinência em set é O(1) onde pertinência em lista é O(n).

Ordenando

Duas formas, e a escolha importa:

nums = [5, 2, 9, 1, 7]

# In place — modifies the list, returns None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# Returns a new sorted list, leaves the original alone.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

As duas aceitam reverse=True para ordem decrescente:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

E uma função key para ordenação customizada:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

key é aplicada a cada item, e o resultado é o que é comparado. Casos comuns: ordenar por tamanho, por um atributo específico ou pela forma minúscula de uma string.

Invertendo

Três sabores, dependendo do que você precisa:

items = [1, 2, 3, 4]

# In place — modifies the list, returns None.
items.reverse()
print(items)

# Slicing — returns a new reversed list.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed() — returns a lazy iterator.
for n in reversed([1, 2, 3, 4]):
    print(n)

Use in place quando não precisa da original. Use fatiamento quando quer uma cópia nova. Use reversed() quando só precisa iterar em ordem inversa sem materializar uma lista nova.

A armadilha da referência compartilhada

Listas são mutáveis, e variáveis são referências. Isso significa que duas variáveis podem apontar para a mesma lista:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4] — a changed too!

b = a não copiou a lista; deu a b um segundo nome para a mesma lista. Se você quer uma cópia, peça uma:

a = [1, 2, 3]
b = a.copy()   # or list(a), or a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

Isso morde todo programador Python pelo menos uma vez. Lembre: = entre duas listas não copia.

Percorrendo e construindo

Você já conhece o padrão básico da página do laço for:

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

Isso é legível e sempre vai estar bem. Quando estiver à vontade, o equivalente com list comprehension faz a mesma coisa em uma linha:

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

Vamos cobrir comprehensions em detalhe duas páginas à frente.

Folha de cola rápida

Métodos que vale conhecer, num relance:

• append(x) — adiciona ao fim
• extend(iter) — adiciona cada item de um iterável
• insert(i, x) — insere no índice i
• pop() / pop(i) — remove e retorna
• remove(x) — remove a primeira ocorrência de x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x) — posição do primeiro x
• count(x) — número de x's
• copy() — cópia rasa

Próxima

Listas são o cavalo de batalha. A seguir vamos olhar tuplas — a prima imutável — e quando pegar uma tupla em vez é a escolha melhor.