Listas em Python: Um Guia Completo

Esta página abrange tudo o que você precisa saber sobre listas em Python — como criá-las, ler e modificar seu conteúdo, usar fatiamento, aplicar métodos integrados, escrever compreensões de lista, trabalhar com listas aninhadas e desempacotar valores de lista em variáveis.

O Que É uma Lista em Python?

Uma lista é a estrutura de dados integrada mais versátil do Python. Ela armazena uma sequência ordenada de itens, onde cada item pode ser de qualquer tipo: um número, uma string, um boolean, outra lista ou qualquer objeto. As listas são:

• Ordenadas — os itens mantêm a posição que você lhes atribui.
• Mutáveis — você pode adicionar, remover ou alterar itens após a criação da lista.
• Indexadas — cada item possui um índice inteiro começando em 0.
• Heterogêneas — uma única lista pode conter valores de tipos diferentes.

Crie uma lista com colchetes, separando os itens com vírgulas:

Uma lista vazia é escrita como []. As listas também podem conter tipos mistos:

mixed = [42, 'hello', True, 3.14, None]
print(mixed)
# [42, 'hello', True, 3.14, None]

Acessando Itens de uma Lista

Indexação Positiva

Acesse um item pela sua posição baseada em zero dentro dos colchetes:

Indexação Negativa

Índices negativos contam de trás para frente a partir do final. -1 é o último item, -2 o penúltimo, e assim por diante — útil quando você conhece a posição a partir do final, mas não o comprimento total:

Fatiamento

Um fatiamento extrai uma sub-lista usando a sintaxe list[start:stop:step]. O índice stop é exclusivo (não incluído).

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

print(fruits[1:4])   # ['banana', 'cherry', 'date']
print(fruits[:2])    # ['apple', 'banana']   — start defaults to 0
print(fruits[2:])    # ['cherry', 'date', 'elderberry'] — stop defaults to end
print(fruits[::2])   # ['apple', 'cherry', 'elderberry'] — every other item
print(fruits[::-1])  # ['elderberry', 'date', 'cherry', 'banana', 'apple'] — reversed copy

O fatiamento sempre retorna uma nova lista e nunca lança um IndexError, mesmo que os índices estejam fora do intervalo.

Modificando Itens de uma Lista

Como as listas são mutáveis, você pode atribuir um novo valor a qualquer índice:

Você também pode substituir um intervalo de itens usando atribuição por fatiamento:

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30]
print(nums)
# [1, 20, 30, 4, 5]

Adicionando Itens

append() — Adicionar ao Final

append() adiciona um único item ao final da lista em seu lugar:

insert() — Adicionar em uma Posição Específica

insert(index, value) insere um novo item antes do índice fornecido sem remover nada:

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'mango')
print(fruits)
# ['apple', 'mango', 'banana', 'cherry']

extend() — Adicionar Múltiplos Itens

extend() acrescenta todos os itens de outro iterável (lista, tupla ou string) ao final:

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
# [1, 2, 3, 4, 5, 6]

O operador + faz a mesma coisa, mas retorna uma nova lista em vez de modificar a original:

combined = [1, 2, 3] + [4, 5, 6]
print(combined)
# [1, 2, 3, 4, 5, 6]

Removendo Itens

remove() — Remover por Valor

remove() exclui a primeira ocorrência de um valor. Lança ValueError se o valor não estiver na lista:

pop() — Remover por Índice

pop() remove e retorna o item em um índice fornecido (padrão: último item). É útil quando você precisa ao mesmo tempo recuperar e remover um item:

fruits = ['apple', 'banana', 'cherry']
last = fruits.pop()
print(last)    # cherry
print(fruits)  # ['apple', 'banana']

first = fruits.pop(0)
print(first)   # apple
print(fruits)  # ['banana']

del — Excluir por Índice ou Fatiamento

A instrução del remove um item por índice ou um fatiamento inteiro:

clear() — Remover Todos os Itens

clear() esvazia a lista sem excluí-la:

fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits)
# []

Métodos Úteis de Lista

As listas Python vêm com um conjunto completo de métodos integrados. Consulte Métodos de Lista em Python para a referência completa.

len() — Comprimento da Lista

sort() — Ordenar no Lugar

sort() ordena a lista em ordem crescente por padrão. Use reverse=True para ordem decrescente:

Use o parâmetro key para ordenar por um critério personalizado — por exemplo, pelo comprimento da palavra:

words = ['banana', 'apple', 'cherry', 'date']
words.sort(key=len)
print(words)
# ['date', 'apple', 'banana', 'cherry']

sort() modifica a lista no lugar. Para obter uma cópia ordenada sem alterar a original, use a função integrada sorted():

original = [3, 1, 2]
s = sorted(original)
print(original)  # [3, 1, 2]
print(s)         # [1, 2, 3]

Consulte Ordenar Listas para mais padrões de ordenação.

reverse() — Inverter no Lugar

count() — Contar Ocorrências

count(value) retorna quantas vezes um valor aparece:

nums = [1, 2, 2, 3, 2, 4]
print(nums.count(2))
# 3

index() — Encontrar um Valor

index(value) retorna o índice da primeira ocorrência. Lança ValueError se não for encontrado:

nums = [1, 2, 3, 4]
print(nums.index(3))
# 2

copy() — Cópia Superficial

copy() retorna uma nova lista com os mesmos itens de nível superior. Modificar a cópia não afeta o original:

original = [1, 2, 3]
copy = original.copy()
copy.append(4)
print(original)  # [1, 2, 3]
print(copy)      # [1, 2, 3, 4]

Ordenar vs. Inverter: Diferença Fundamental

sort() e reverse() ambos modificam a lista no lugar e retornam None. Um erro comum é escrever my_list = my_list.sort(), o que substitui a lista por None. Sempre os chame como instruções:

fruits = ['banana', 'apple', 'cherry']
fruits.sort()   # correct — modifies in place
# fruits = fruits.sort()  # wrong — sets fruits to None
print(fruits)
# ['apple', 'banana', 'cherry']

Listas Aninhadas

Uma lista pode conter outras listas como itens, formando uma estrutura 2D (ou mais profunda):

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

print(matrix[0])     # [1, 2, 3]
print(matrix[1][2])  # 6  — row 1, column 2

Listas aninhadas são comumente usadas para representar grades, tabelas e matrizes.

Compreensões de Lista

Uma compreensão de lista é uma expressão concisa de uma linha para construir uma nova lista transformando ou filtrando um iterável existente. A sintaxe é:

[expression for item in iterable if condition]

A parte if condition é opcional.

Quadrados de 1 a 10:

Apenas números pares:

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)
# [2, 4, 6, 8, 10]

Transformar strings:

fruits = ['apple', 'banana', 'cherry']
upper = [f.upper() for f in fruits]
print(upper)
# ['APPLE', 'BANANA', 'CHERRY']

Compreensões de lista geralmente são mais rápidas do que um loop for equivalente com append(). Consulte Compreensão de Lista para padrões avançados.

Desempacotando Listas

Você pode atribuir itens de uma lista a variáveis individuais em uma única etapa:

a, b, c = ['x', 'y', 'z']
print(a, b, c)
# x y z

O operador * (asterisco) captura qualquer número de itens restantes:

first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

O desempacotamento lança ValueError se o número de variáveis não corresponder ao número de itens (a menos que você use *).

Quando Usar uma Lista

Prática