Métodos de lista em Python: guia prático com exemplos

Os métodos de lista em Python na prática: append, insert, extend, remove, pop, sort, index, count e copy, com range, fatiamento, laço, list comprehension, cópia contra referência e os erros mais comuns, em código que roda.

Revisão técnica: Cesar GargiuloDocumentação oficial do Python: Estruturas de dados
Calcule agora: Formatador de JSONResultado na hora, de graça e sem cadastro.

A lista é a estrutura de dados que você mais vai usar em Python. Ela guarda vários itens em ordem, aceita tipos misturados e cresce ou encolhe conforme o programa roda. Saber criar, acessar, fatiar, adicionar, remover e percorrer uma lista resolve boa parte das tarefas do dia a dia, de somar notas a filtrar nomes. Este guia reúne os métodos de lista com código que roda e aponta os erros que mais pegam quem está começando. Se o conceito ainda é novo, a aula sobre listas em Python explica o que são e para que servem. Para estudar com playground no navegador e exercícios, use o curso de Python do zero, gratuito.

Resposta rápida

  • Crie com colchetes: frutas = ["maçã", "uva"].
  • Acesse por índice a partir do zero; frutas[-1] é o último item.
  • Cresça com append, insert e extend; encolha com remove, pop e del.
  • nova = antiga não copia; use antiga.copy() para separar as duas (e copy.deepcopy em lista aninhada).

Como criar uma lista

Uma lista nasce entre colchetes, com os itens separados por vírgula. Ela pode começar vazia e receber itens depois, ou já vir preenchida. Os itens não precisam ser do mesmo tipo, embora listas de um tipo só sejam as mais comuns.

frutas = ["maçã", "uva", "pera"]
números = [10, 20, 30, 40]
vazia = []
misturada = ["texto", 42, True, 3.14]

print(frutas)      # ['maçã', 'uva', 'pera']
print(len(números))  # 4

A função len devolve quantos itens a lista tem. Ela serve de base para muita coisa: saber se a lista está vazia, montar laços e evitar pedir um índice que não existe.

Para uma lista de números em sequência, não é preciso digitar item por item: a função range gera a sequência e list a transforma em lista. O primeiro número é o início, o segundo é o fim (que não entra) e o terceiro, opcional, é o passo.

de_um_a_cinco = list(range(1, 6))
print(de_um_a_cinco)   # [1, 2, 3, 4, 5]

pares = list(range(0, 11, 2))
print(pares)           # [0, 2, 4, 6, 8, 10]

A aula sobre range() em Python mostra o início, o fim e o passo com exercícios no navegador.

Acessar por índice, inclusive negativo

Cada item tem uma posição, chamada índice, que começa em zero. Para pegar um item, use o índice entre colchetes. Índice negativo conta de trás para frente, o que evita calcular o tamanho só para chegar ao final.

frutas = ["maçã", "uva", "pera", "kiwi"]

print(frutas[0])   # maçã (primeiro)
print(frutas[2])   # pera
print(frutas[-1])  # kiwi (último)
print(frutas[-2])  # pera (penúltimo)

frutas[1] = "banana"  # troca o item na posição 1
print(frutas)         # ['maçã', 'banana', 'pera', 'kiwi']

Como a lista é mutável, você também usa o índice para trocar um item no lugar, sem criar uma lista nova. Pedir um índice que não existe, como frutas[10] numa lista de quatro itens, para o programa com o erro IndexError.

Fatiamento (slicing): pegar um pedaço

O fatiamento recorta um trecho da lista com a sintaxe lista[início:fim]. O item do início entra, o do fim não. Se você omitir um dos lados, o Python assume o começo ou o final. Um terceiro número define o passo.

n = [0, 1, 2, 3, 4, 5]

print(n[1:4])   # [1, 2, 3] (do 1 até antes do 4)
print(n[:3])    # [0, 1, 2] (do começo)
print(n[3:])    # [3, 4, 5] (até o fim)
print(n[::2])   # [0, 2, 4] (de dois em dois)
print(n[::-1])  # [5, 4, 3, 2, 1, 0] (invertida)

O fatiamento sempre devolve uma lista nova, sem mexer na original. Por isso n[:] é um jeito rápido de copiar a lista inteira, e n[::-1] devolve uma versão invertida sem alterar a de origem.

Adicionar itens: append, insert e extend

Existem três formas principais de crescer uma lista, cada uma para uma situação. Escolha pelo resultado que você quer.

fila = ["ana", "bia"]

fila.append("caio")      # adiciona ao fim
print(fila)              # ['ana', 'bia', 'caio']

fila.insert(0, "duda")   # insere na posição 0
print(fila)              # ['duda', 'ana', 'bia', 'caio']

fila.extend(["edu", "fê"])  # junta item por item
print(fila)              # ['duda', 'ana', 'bia', 'caio', 'edu', 'fê']

Cuidado com a diferença entre append e extend. Se você fizer fila.append(["edu", "fê"]), a lista inteira entra como um único item, criando uma lista dentro da lista. O extend desmonta a sequência e adiciona cada item separado. Outro tropeço comum é escrever fila = fila.append("gil"): o método muda a lista no lugar e devolve None, que passa a ocupar a variável. A aula append e insert em Python treina esses dois métodos com exercícios corrigidos.

Remover itens: remove, pop e del

Para encolher a lista você tem três ferramentas. O remove apaga pelo valor, o pop apaga pela posição e ainda devolve o item retirado, e o del apaga por índice sem devolver nada.

cores = ["azul", "verde", "rosa", "verde"]

cores.remove("verde")   # apaga a PRIMEIRA ocorrência
print(cores)            # ['azul', 'rosa', 'verde']

última = cores.pop()    # tira e devolve o último
print(última)           # verde
print(cores)            # ['azul', 'rosa']

del cores[0]            # apaga por índice
print(cores)            # ['rosa']

Repare que remove apaga só a primeira ocorrência do valor. Se o item aparece mais de uma vez e você quer todos fora, precisa repetir ou usar outra técnica. Chamar remove com um valor que não existe gera ValueError. A aula remove, pop e del em Python compara os três com exemplos para rodar.

Percorrer com for e verificar pertencimento com in

Para trabalhar com todos os itens, o laço for passa por cada um sem você precisar mexer em índices. Quando precisa também da posição, enumerate entrega índice e valor juntos. Para saber se um valor está na lista, o operador in devolve verdadeiro ou falso.

notas = [7, 5, 9, 4]

for nota in notas:
    print(nota)

for i, nota in enumerate(notas):
    print(i, nota)   # 0 7 / 1 5 / 2 9 / 3 4

print(9 in notas)    # True
print(10 in notas)   # False

O operador in é a forma correta de checar presença. Não é preciso escrever um laço só para procurar um item; deixe o Python fazer isso e o código lê melhor. Guarde o custo: numa lista o in percorre item por item, então é O(n). Se a checagem se repete dentro de um laço, converta para um conjunto (set), onde ela responde em tempo praticamente constante.

Ordenar: sort, sorted e reverse

O método sort ordena a própria lista no lugar e não devolve nada. A função sorted devolve uma lista nova ordenada e deixa a original como estava. O método reverse apenas inverte a ordem atual, sem ordenar.

valores = [3, 1, 4, 1, 5]

ordenada = sorted(valores)   # nova lista, original intacta
print(ordenada)              # [1, 1, 3, 4, 5]
print(valores)               # [3, 1, 4, 1, 5]

valores.sort(reverse=True)   # ordena a própria lista
print(valores)               # [5, 4, 3, 1, 1]

nomes = ["caio", "ana", "beatriz"]
nomes.sort(key=len)          # ordena pelo tamanho do texto
print(nomes)                 # ['ana', 'caio', 'beatriz']

Use sorted quando ainda vai precisar da ordem original em outro ponto. O parâmetro key ordena por um critério, como o tamanho de cada texto, e reverse=True inverte para ordem decrescente. O critério com key tem aula própria no curso intermediário: ordenar com key no Python.

List comprehension: montar listas em uma linha

A list comprehension cria uma lista nova a partir de outra, em uma linha, aplicando uma expressão a cada item e, se quiser, filtrando com uma condição. É idiomática em Python e mais enxuta que um laço com append.

números = [1, 2, 3, 4, 5, 6]

dobrados = [n * 2 for n in números]
print(dobrados)   # [2, 4, 6, 8, 10, 12]

pares = [n for n in números if n % 2 == 0]
print(pares)      # [2, 4, 6]

A leitura segue a fala: para cada n em números, pegue n * 2. A condição no fim mantém só os itens que passam no teste. Para transformações simples, prefira a comprehension; para lógica longa, um laço comum lê melhor. A aula list comprehension em Python aprofunda a sintaxe, com filtro e transformação.

Métodos de lista mais usados

MétodoO que faz
append(x)Adiciona um item ao fim da lista
insert(i, x)Insere o item x na posição i
extend(seq)Adiciona cada item de outra sequência
remove(x)Apaga a primeira ocorrência do valor x
pop(i)Tira e devolve o item da posição i (ou o último)
index(x)Devolve a posição da primeira ocorrência de x
count(x)Conta quantas vezes x aparece
sort()Ordena a própria lista no lugar
copy()Devolve uma cópia independente da lista

Repare que todos esses métodos, menos index, count, copy e pop, devolvem None: o resultado está na própria lista. Quando os dados não devem mudar depois de criados, a tupla é a estrutura certa, e a aula lista ou tupla em Python mostra quando usar cada uma.

Cópia contra referência: o tropeço clássico

Este é o erro que mais confunde quem começa. Escrever nova = antiga não copia a lista: as duas variáveis passam a apontar para a mesma lista na memória. Mexer em uma altera a outra.

a = [1, 2, 3]
b = a          # NÃO copia, é o mesmo objeto
b.append(4)
print(a)       # [1, 2, 3, 4]  <- mudou junto!

c = a.copy()   # cópia rasa (ou list(a), ou a[:]); aninhada pede deepcopy
c.append(9)
print(a)       # [1, 2, 3, 4]  <- intacta

Quando precisa de uma lista independente, use a.copy(), list(a) ou o fatiamento a[:]. Falta um detalhe importante: as três formas fazem cópia rasa. A lista de fora é nova, mas os itens continuam sendo os mesmos objetos, então numa lista de listas mexer num item interno ainda afeta as duas. Para dados aninhados, use copy.deepcopy(a), que copia tudo até o fundo. Guardar essa diferença cedo evita bugs que parecem mágica.

import copy

matriz = [[1, 2], [3, 4]]
rasa = matriz.copy()        # lista de fora nova, itens compartilhados
rasa[0].append(99)
print(matriz)               # [[1, 2, 99], [3, 4]]  <- mudou junto!

funda = copy.deepcopy(matriz)
funda[0].append(7)
print(matriz)               # [[1, 2, 99], [3, 4]]  <- intacta

Erros comuns com listas

O curso de Python do zero cobre listas, laços, fatiamento e os métodos deste guia com playground no navegador e exercícios corrigidos, sem custo. Depois de dominar as listas, avance para dicionários e classes no curso de Python intermediário.

Fontes

Conclusão

Lista é a coleção ordenada e mutável do Python: você cria com colchetes, acessa por índice (inclusive negativo), recorta com fatiamento, cresce com append, insert e extend, encolhe com remove, pop e del, percorre com for e ordena com sort ou sorted. Guarde a diferença entre cópia e referência e você evita o bug mais comum. A melhor forma de fixar é escrever e testar. Para praticar com playground e exercícios gratuitos, use o curso de Python do zero e conheça todos os cursos gratuitos do ValorFinal.

Calculadoras deste guia

As ferramentas de tecnologia mais procuradas no Google: teste de velocidade da internet, letras diferentes, horário de Brasília, cronômetro online, gerador de QR Code, roleta de sorteio, meu IP e gerador de CPF.

Leia também

Como citar esta página

Vai citar este guia em uma matéria, post ou trabalho? Copie a referência pronta. O conteúdo é baseado em Documentação oficial do Python: Estruturas de dados e revisado pela equipe editorial.

ValorFinal. Métodos de lista em Python: guia prático com exemplos. Disponível em: https://valorfinal.com.br/guia/listas-em-python. Atualizado em: 06/11/2026.

ValorFinal VIP: Sem anúncios no portal inteiro, cenários salvos e alertas por e-mail.

Como validamos este conteúdo

Base deste guia: Documentação oficial do Python: Estruturas de dados. Padrões, APIs, versões e recomendações técnicas evoluem. O conteúdo reflete a documentação de referência na data de atualização; confira sempre a documentação oficial da versão que você usa. Entenda nossa metodologia em como validamos os cálculos.

Perguntas frequentes

Uma lista em Python aceita tipos misturados?
Aceita. A lista é uma coleção ordenada de itens, guardada entre colchetes e separada por vírgula, e pode ter números, textos, valores lógicos e até outras listas no mesmo lugar. Ela mantém a ordem em que você colocou os itens e pode crescer ou encolher durante o programa. Na prática, listas de um tipo só são as mais comuns, porque facilitam somar, ordenar e comparar os itens sem tratar exceção a cada passo.
Como acessar um item específico de uma lista?
Use o índice entre colchetes, começando do zero. Em uma lista frutas, frutas[0] é o primeiro item e frutas[1] é o segundo. Índice negativo conta de trás para frente: frutas[-1] é o último item e frutas[-2] é o penúltimo. Isso evita ter que calcular o tamanho da lista só para pegar o final. Pedir um índice que não existe gera o erro IndexError.
Qual a diferença entre append e extend?
O append adiciona um único item ao fim da lista, mesmo que esse item seja outra lista, que entra inteira como um só elemento. O extend recebe uma sequência e adiciona cada item dela um por um ao fim. Se você tem [1, 2] e faz append([3, 4]), fica [1, 2, [3, 4]]. Com extend([3, 4]) fica [1, 2, 3, 4]. Escolha pelo resultado que quer.
Como ordenar uma lista sem alterar a original?
Use a função sorted, que devolve uma lista nova ordenada e deixa a original intacta. Já o método sort ordena a própria lista no lugar e não devolve nada. Prefira sorted quando ainda precisa da ordem original em outro ponto do código. Os dois aceitam reverse=True para ordem decrescente e o parâmetro key para ordenar por um critério, como o tamanho de cada texto.
Por que minha cópia da lista muda junto com a original?
Porque escrever nova = antiga não copia os itens: as duas variáveis apontam para a mesma lista na memória. Mexer em uma reflete na outra. Para separar as duas, use antiga.copy(), list(antiga) ou o fatiamento antiga[:]. Guarde a ressalva que resolve o segundo tropeço: essas três formas fazem cópia rasa, ou seja, a lista de fora é nova, mas os itens continuam sendo os mesmos objetos. Numa lista de listas, mexer num item interno ainda afeta as duas; para esse caso, use copy.deepcopy.
Por que minha lista virou None depois do append?
Porque o append muda a própria lista e devolve None. Quem escreve lista = lista.append(4) guarda esse None na variável e perde a lista inteira. O certo é chamar só lista.append(4), numa linha sozinha, e continuar usando a mesma variável. O mesmo vale para insert, extend, remove, sort e reverse: todos alteram a lista no lugar e não devolvem uma lista nova. Quando você precisa de uma lista nova sem mexer na original, use sorted, fatiamento ou list comprehension.
Como criar uma lista de números com range em Python?
Passe o range para a função list. list(range(5)) devolve [0, 1, 2, 3, 4]: o range começa em zero e para antes do número final. Com dois números você define o início e o fim, como list(range(1, 6)), que dá [1, 2, 3, 4, 5]. O terceiro número é o passo: list(range(0, 11, 2)) devolve os pares de 0 a 10. Num laço for não precisa do list, porque o range já entrega um número de cada vez sem montar a lista inteira na memória.
Quando usar list comprehension em vez de um laço for?
Use list comprehension quando a tarefa é montar uma lista nova transformando ou filtrando outra, em uma ideia só, como [n * 2 for n in valores] ou [n for n in valores if n > 0]. Ela fica mais curta que o laço com append e lê como a frase em português. Prefira o laço for comum quando há várias etapas, condições encadeadas, tratamento de erro ou quando o objetivo é só repetir uma ação, como imprimir ou gravar em arquivo, e não montar uma lista.
Qual a diferença entre lista, tupla e conjunto em Python?
A lista é ordenada e mutável: aceita repetição e muda depois de criada, com append, remove e afins. A tupla, escrita entre parênteses, também é ordenada, mas imutável, então serve para dados que não devem mudar, como as coordenadas de um ponto. O conjunto, criado com set ou chaves, não guarda ordem nem itens repetidos, e responde muito rápido se um valor está nele. A documentação oficial do Python, na seção de estruturas de dados, descreve os três tipos.
Onde pratico listas em Python sem instalar nada?
Dá para rodar tudo no navegador. O curso de Python do zero do ValorFinal tem um playground que executa o código na própria página, então você cria listas, fatia, ordena e percorre com laço vendo o resultado na hora, sem configurar ambiente. É a forma mais rápida de fixar cada método escrevendo e testando por conta própria.