Métodos de Lista

As listas Python são sequências mutáveis e ordenadas. Por serem mutáveis, o tipo lista disponibiliza onze métodos integrados que permitem adicionar, remover, pesquisar e reordenar itens no local — sem necessidade de importações. Esta página cobre todos os métodos com exemplos executáveis, armadilhas comuns e orientação sobre quando escolher um em vez de outro.

Capítulos relacionados: Listas Python · Ordenar Listas · Compreensão de Lista · Copiar Listas

Referência rápida

Adicionando itens

append()

append(x) adiciona um único item x ao final da lista. É uma operação O(1) amortizado e é a forma idiomática de construir uma lista item por item.

append() sempre adiciona o argumento como um único elemento, mesmo que esse argumento seja em si uma lista:

fruits = ["banana", "orange"]
fruits.append(["apple", "mango"])
print(fruits)  # ['banana', 'orange', ['apple', 'mango']]
print(len(fruits))  # 3 — the nested list counts as one element

Para mesclar todos os itens de outra lista, use extend().

extend()

extend(iterable) acrescenta cada item do iterável fornecido ao final da lista. O iterável pode ser uma lista, tupla, conjunto, string ou qualquer outro iterável.

extend() é equivalente a fruits += more_fruits. Use-o quando já tiver uma coleção de itens para mesclar; use append() para um único item.

insert()

insert(i, x) insere o item x antes da posição i. Todos os itens existentes no índice i e além deslocam uma posição para a direita.

• insert(0, x) adiciona ao início (mas é O(n) porque todos os itens se deslocam).
• Se i for maior ou igual ao comprimento da lista, o item é adicionado ao final — nenhum erro é levantado.

Removendo itens

remove()

remove(x) percorre a lista da esquerda para a direita e exclui o primeiro elemento igual a x. Se x não for encontrado, levanta um ValueError.

Protegendo contra ValueError:

fruits = ["banana", "orange"]
item = "mango"
if item in fruits:
    fruits.remove(item)
else:
    print(f"{item} not in list")
# mango not in list

pop()

pop(i) remove o item no índice i e o retorna. O valor de retorno é a principal diferença em relação a remove().

pop() chamado sem argumento remove e retorna o último item — um padrão comum de pilha:

stack = ["a", "b", "c"]
last = stack.pop()
print(stack)  # ['a', 'b']
print(last)   # c

clear()

clear() remove todos os elementos da lista, deixando-a vazia. É equivalente a del lst[:], mas mais legível.

fruits = ["banana", "apple", "orange"]
fruits.clear()
print(fruits)  # []

Use clear() quando quiser esvaziar uma lista que outras variáveis também possam referenciar — fruits = [] apenas ligaria o nome novamente, enquanto clear() esvazia o objeto subjacente.

Pesquisando itens

index()

index(x) retorna o índice inteiro da primeira ocorrência de x. Aceita argumentos opcionais start e end para limitar a pesquisa a uma fatia.

Pesquisando dentro de um intervalo:

items = ["a", "b", "c", "b", "d"]
print(items.index("b"))       # 1  — first occurrence
print(items.index("b", 2))    # 3  — first occurrence at index >= 2

index() levanta ValueError se o item estiver ausente. Use in para verificar primeiro quando a ausência for possível:

if "mango" in fruits:
    pos = fruits.index("mango")

count()

count(x) retorna o número de vezes que x aparece na lista.

Ao contrário de index(), count() nunca levanta um erro para um valor ausente — retorna 0.

Ordenando itens

sort()

sort() ordena a lista no local em ordem crescente por padrão. Aceita dois argumentos de palavra-chave opcionais:

• reverse=True — ordena em ordem decrescente.
• key=<callable> — uma função aplicada a cada elemento antes da comparação.

Ordenando em ordem decrescente:

numbers = [3, 1, 4, 1, 5]
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 1, 1]

Ordenando strings sem distinção de maiúsculas e minúsculas com key:

words = ["banana", "Apple", "cherry", "date"]
words.sort(key=str.lower)
print(words)  # ['Apple', 'banana', 'cherry', 'date']

sort() modifica a lista e retorna None. Se precisar de uma cópia ordenada sem alterar o original, use a função integrada sorted():

original = [3, 1, 4]
result = sorted(original)
print(original)  # [3, 1, 4]  — unchanged
print(result)    # [1, 3, 4]

Consulte Ordenar Listas para um guia detalhado incluindo comparadores personalizados e ordenação de objetos.

reverse()

reverse() inverte a lista no local. Assim como sort(), retorna None.

Para obter uma cópia invertida sem modificar o original, use reversed() (retorna um iterador) ou fatiamento:

fruits = ["banana", "apple", "orange"]
print(list(reversed(fruits)))  # ['orange', 'apple', 'banana']
print(fruits[::-1])            # ['orange', 'apple', 'banana']
print(fruits)                  # ['banana', 'apple', 'orange']  — unchanged

Copiando

copy()

copy() retorna uma cópia superficial da lista — um novo objeto de lista contendo as mesmas referências de itens.

original = ["banana", "apple", "orange"]
clone = original.copy()
clone.append("mango")

print(original)  # ['banana', 'apple', 'orange']  — unchanged
print(clone)     # ['banana', 'apple', 'orange', 'mango']

"Superficial" significa que objetos aninhados (como uma lista dentro de uma lista) não são duplicados — tanto o original quanto a cópia refletirão alterações nesses objetos aninhados. Para uma duplicata totalmente independente, use copy.deepcopy() da biblioteca padrão. Consulte Copiar Listas para uma explicação detalhada de cópias superficiais versus profundas.

Armadilhas comuns

Todos os métodos que modificam a lista retornam None. Um erro comum é atribuir o resultado de sort(), reverse(), append(), etc.:

# Wrong — result is None, not a sorted list
numbers = [3, 1, 2]
numbers = numbers.sort()
print(numbers)  # None

# Correct — sort() mutates in place
numbers = [3, 1, 2]
numbers.sort()
print(numbers)  # [1, 2, 3]

remove() e index() levantam ValueError para itens ausentes. Sempre verifique com in primeiro, ou capture a exceção, quando o item puder não estar presente.

append() versus extend() para listas. Usar append(outra_lista) aninha a lista como um único elemento; extend(outra_lista) mescla seus itens.

Prática