Python Métodos de Lista

Esta é a página de consulta rápida dos métodos de lista: as funções que toda lista (list) já traz e que você chama com um ponto, como em compras.append("café"). São só 11, para adicionar, remover, procurar, ordenar e copiar. No fim estão também as operações com listas que não são métodos (len, in, +, índices, fatias, del). A explicação passo a passo começa na aula Listas.

Como ler as tabelas

Exemplo é o que você digitaria depois do >>> do modo interativo, uma linha depois da outra; Resultado é o que o Python 3.14.4 respondeu no computador da Ana.
Muitos métodos de lista não devolvem nada (devolvem None, que o modo interativo não mostra): eles mudam a própria lista. Por isso vários exemplos terminam com o nome da lista sozinho, para mostrar como ela ficou.
Quando o exemplo dá erro, o resultado mostra a última linha da mensagem do Python (em inglês).

A diferença para as strings: a lista muda

Os métodos de string devolvem um texto novo e deixam o original igual. Os de lista fazem o contrário: mudam a própria lista e devolvem None ("nada"). Por isso nunca escreva compras = compras.sort():

$ python3 -q
>>> compras = ["pão", "leite", "café"]
>>> compras = compras.sort()
>>> print(compras)
None
>>> compras[0]
Traceback (most recent call last):
  File "<python-input-3>", line 1, in <module>
    compras[0]
    ~~~~~~~^^^
TypeError: 'NoneType' object is not subscriptable
>>> exit()

O sort() ordenou a lista e devolveu None, e a atribuição guardou esse None em compras: a lista se perdeu. A última linha, TypeError: 'NoneType' object is not subscriptable, quer dizer "o valor None não aceita [ ]". O certo é só compras.sort(), sem o compras =. O mesmo vale para append, extend, insert, remove, clear e reverse.

Os 11 métodos, de relance

Método	O que faz	Muda a lista?	Devolve
`append(x)`	põe `x` no fim	sim	`None`
`extend(itens)`	põe cada um dos itens no fim	sim	`None`
`insert(i, x)`	põe `x` na posição `i`	sim	`None`
`remove(x)`	tira o primeiro `x`	sim	`None`
`pop()` / `pop(i)`	tira o último item / o da posição `i`	sim	o item tirado
`clear()`	esvazia a lista	sim	`None`
`index(x)`	acha a posição do primeiro `x`	não	um número
`count(x)`	conta quantas vezes `x` aparece	não	um número
`sort()`	ordena	sim	`None`
`reverse()`	inverte a ordem	sim	`None`
`copy()`	faz uma cópia	não	uma lista nova

Adicionar

Método	O que faz	Exemplo	Resultado	Aula
`append(x)`	Acrescenta um item no fim (append = "anexar").	`compras = ["pão", "leite"]` `compras.append("café")` `compras`	`['pão', 'leite', 'café']`	Adicionando Itens
	uma lista vira um item só (uma lista dentro da lista)	`compras.append(["ovo", "sal"])` `compras`	`['pão', 'leite', 'café', ['ovo', 'sal']]`
`extend(itens)`	Acrescenta cada item de outra lista (extend = "estender").	`compras = ["pão", "leite"]` `compras.extend(["ovo", "sal"])` `compras`	`['pão', 'leite', 'ovo', 'sal']`	Adicionando Itens
	cuidado: um texto é uma sequência de letras	`compras.extend("mel")` `compras`	`['pão', 'leite', 'ovo', 'sal', 'm', 'e', 'l']`
`lista += itens`	O mesmo que `extend`.	`compras += ["uva"]`	(a lista ganha `'uva'` no fim)	Operadores de Atribuição
`insert(i, x)`	Põe `x` antes da posição `i`; os outros andam uma casa.	`compras = ["pão", "leite"]` `compras.insert(0, "arroz")` `compras`	`['arroz', 'pão', 'leite']`	Adicionando Itens
	posição depois do fim: vai para o fim, sem erro	`compras.insert(99, "fim")` `compras`	`['arroz', 'pão', 'leite', 'fim']`

Remover

Método	O que faz	Exemplo	Resultado	Aula
`remove(x)`	Tira o primeiro item igual a `x` (pelo valor).	`compras = ["pão", "leite", "café", "leite"]` `compras.remove("leite")` `compras`	`['pão', 'café', 'leite']`	Removendo Itens
	se não tem, dá erro	`compras.remove("sal")`	`ValueError: list.remove(x): x not in list`
`pop()`	Tira o último item e o devolve (para você usar).	`compras = ["pão", "leite", "café"]` `compras.pop()` `compras`	`'café'` `['pão', 'leite']`	Removendo Itens
`pop(i)`	Tira o item da posição `i` e o devolve.	`compras.pop(0)` `compras`	`'pão'` `['leite']`
	lista vazia	`[].pop()`	`IndexError: pop from empty list`
`clear()`	Esvazia a lista (ela continua existindo, com 0 itens).	`compras.clear()` `compras`	`[]`	Removendo Itens
`del lista[i]`	Não é método: apaga pela posição, sem devolver.	`compras = ["pão", "leite", "café"]` `del compras[1]` `compras`	`['pão', 'café']`	Removendo Itens
`del lista[a:b]`	Apaga uma fatia inteira.	`compras = ["a", "b", "c", "d", "e"]` `del compras[1:3]` `compras`	`['a', 'd', 'e']`

Qual usar para remover?

Sabe o valor ("leite"): remove.
Sabe a posição e quer o item de volta: pop(i). O pop() sem número é o jeito de usar uma lista como pilha (o último que entra é o primeiro que sai).
Sabe a posição e não precisa do item: del lista[i].
Quer tirar todos os itens de um valor: uma list comprehension, como [x for x in compras if x != "leite"].

Procurar e contar

Método	O que faz	Exemplo	Resultado	Aula
`index(x)`	A posição do primeiro item igual a `x` (a primeira posição é 0).	`notas = [7.5, 9.0, 6.5, 9.0]` `notas.index(9.0)`	`1`	Acessando Itens
`index(x, início)`	Procura a partir da posição `início`.	`notas.index(9.0, 2)`	`3`
	se não tem, dá erro (lista não tem `find`)	`notas.index(10)`	`ValueError: list.index(x): x not in list`
`count(x)`	Quantas vezes `x` aparece.	`notas.count(9.0)`, `notas.count(10)`	`2`, `0`	Acessando Itens
`x in lista`	Não é método: "tem?"	`9.0 in notas`	`True`	is e in
`x not in lista`	"não tem?"	`10 not in notas`	`True`

Ordenar e inverter

Método	O que faz	Exemplo	Resultado	Aula
`sort()`	Ordena a própria lista, do menor para o maior.	`numeros = [3, 1, 2]` `numeros.sort()` `numeros`	`[1, 2, 3]`	Ordenando Listas
`sort(reverse=True)`	Do maior para o menor.	`numeros.sort(reverse=True)` `numeros`	`[3, 2, 1]`
	textos: as maiúsculas vêm antes	`nomes = ["Bia", "ana", "Caio"]` `nomes.sort()` `nomes`	`['Bia', 'Caio', 'ana']`
`sort(key=função)`	Ordena pelo resultado da função em cada item. A função vai sem parênteses.	`nomes.sort(key=str.lower)` `nomes`	`['ana', 'Bia', 'Caio']`	lambda
	pelo tamanho	`itens = ["arroz", "sal", "macarrão"]` `itens.sort(key=len)` `itens`	`['sal', 'arroz', 'macarrão']`
	o `sort` devolve `None`	`print(numeros.sort())`	`None`
	não dá para comparar texto com número	`[3, "a", 1].sort()`	`TypeError: '<' not supported between instances of 'str' and 'int'`
`sorted(lista)`	Função embutida: devolve uma lista nova ordenada; a original fica igual. Aceita os mesmos `key=` e `reverse=`.	`numeros = [3, 1, 2]` `sorted(numeros)` `numeros`	`[1, 2, 3]` `[3, 1, 2]`	Ordenando Listas
`reverse()`	Inverte a ordem atual (não ordena!).	`numeros.reverse()` `numeros`	`[2, 1, 3]`	Ordenando Listas
`lista[::-1]`	Uma cópia invertida, sem mexer na original.	`[1, 2, 3][::-1]`	`[3, 2, 1]`	Índices e Fatias

Copiar

Escrita	O que faz	Exemplo	Resultado	Aula
`b = a`	Não copia: `a` e `b` passam a ser dois nomes para a mesma lista.	`a = [1, 2, 3]` `b = a` `b.append(4)` `a`	`[1, 2, 3, 4]` (o `a` mudou também!)	Copiando Listas
`copy()`	Uma lista nova com os mesmos itens.	`a = [1, 2, 3]` `c = a.copy()` `c.append(4)` `a`, depois `c`	`[1, 2, 3]` `[1, 2, 3, 4]`	Copiando Listas
`a[:]`, `list(a)`	Outros dois jeitos de copiar.	`a[:]`, `list(a)`	`[1, 2, 3]`, `[1, 2, 3]`

Cópia rasa

copy(), [:] e list() copiam só a lista de fora. Se dentro dela houver outras listas, elas continuam compartilhadas. Para copiar tudo, até o fundo, existe o copy.deepcopy(): veja Cópia Rasa e Cópia Profunda.

Operações com listas (que não são métodos)

Escrita	O que faz	Exemplo	Resultado	Aula
`len(lista)`	Quantos itens.	`len(["pão", "leite"])`	`2`	Listas
`a + b`	Uma lista nova com os itens das duas.	`[1, 2] + [3]`	`[1, 2, 3]`	Listas
`lista * n`	Repete os itens `n` vezes.	`[0] * 4`	`[0, 0, 0, 0]`
`lista[i]`	O item da posição `i`; negativo conta do fim.	`compras = ["pão", "leite", "café", "ovo"]` `compras[0]`, `compras[-1]`	`'pão'`, `'ovo'`	Acessando Itens
	posição que não existe	`compras[5]`	`IndexError: list index out of range`
`lista[a:b]`, `lista[::passo]`	Uma fatia (uma lista nova).	`compras[1:3]`, `compras[::2]`	`['leite', 'café']`, `['pão', 'café']`	Acessando Itens
`lista[i] = x`	Troca o item da posição `i`.	`compras[0] = "arroz"` `compras`	`['arroz', 'leite', 'café', 'ovo']`	Alterando Itens
`lista[a:b] = itens`	Troca uma fatia inteira (pode mudar o tamanho).	`compras[1:3] = ["mel"]` `compras`	`['arroz', 'mel', 'ovo']`	Alterando Itens
`min`, `max`, `sum`	O menor, o maior e a soma.	`min([7.5, 9.0, 6.5]), max([7.5, 9.0, 6.5]), sum([7.5, 9.0, 6.5])`	`(6.5, 9.0, 23.0)`	Funções Embutidas
`a == b`, `a < b`	Compara item por item, da esquerda para a direita.	`[1, 2, 3] == [1, 2, 3]`, `[1, 2] < [1, 3]`	`True`, `True`	Comparações
`[expr for x in …]`	Monta uma lista nova a partir de outra.	`[n * 2 for n in [1, 2, 3]]`	`[2, 4, 6]`	List Comprehension
	com filtro	`[n for n in [7.5, 4.0, 9.0] if n >= 7]`	`[7.5, 9.0]`
`for item in lista:`	Passa por todos os itens, um por vez.	veja Percorrendo uma Lista		for

Experimente

Missão: arrume a lista de compras da Ana com três métodos, um por linha: acrescente "café" com append, tire o "sal" com remove e ponha tudo em ordem com sort. A saída deve ser ['arroz', 'café', 'feijão', 'leite']. Lembre: nada de compras = … nessas linhas.

compras = ["leite", "sal", "arroz", "feijão"]

print(compras)

compras = ["leite", "sal", "arroz", "feijão"]
compras.append("café")
compras.remove("sal")
compras.sort()
print(compras)

Livre: a fila da padaria. Mude os nomes, troque pop(0) por pop() e veja quem é atendido.

fila = ["Ana", "Bia", "Caio"]
fila.append("Davi")
print("Chegou o Davi:", fila)
atendido = fila.pop(0)
print("Atendido:", atendido)
print("Ainda na fila:", fila, "-", len(fila), "pessoas")
print("Posição do Caio:", fila.index("Caio") + 1)
fila.insert(0, "Eva")
fila.reverse()
print(fila)

No computador da Ana, a fila fica assim:

$ python3 fila.py
Chegou o Davi: ['Ana', 'Bia', 'Caio', 'Davi']
Atendido: Ana
Ainda na fila: ['Bia', 'Caio', 'Davi'] - 3 pessoas
Posição do Caio: 2
['Davi', 'Caio', 'Bia', 'Eva']

Resumo

Os 11 métodos de lista: append, extend, insert, remove, pop, clear, index, count, sort, reverse, copy.
Quase todos mudam a própria lista e devolvem None: nunca escreva lista = lista.sort(). Só pop, index, count e copy devolvem algo útil.
append põe um item; extend põe vários; insert põe numa posição.
remove tira pelo valor; pop tira pela posição e devolve; del apaga pela posição.
sort() muda a lista; sorted() devolve uma nova. Os dois aceitam key= e reverse=True.
b = a não copia: use a.copy().