Compreensao de Listas em Python — 2025 | Python Brasil
Domine list comprehensions em Python com exemplos praticos. Aprenda filtros, aninhamento, dict e set comprehensions para codigo mais limpo.
Compreensao de listas, ou list comprehensions, e uma das construcoes mais pythonic da linguagem. Elas permitem criar listas de forma concisa e legivel, substituindo loops tradicionais por expressoes compactas. Neste artigo, a gente vai explorar desde o basico ate tecnicas avancadas com exemplos praticos.
Sintaxe Basica
A estrutura de uma list comprehension segue este padrao:
nova_lista = [expressao for item in iteravel]
Vamos comparar com um loop tradicional:
# Loop tradicional
quadrados = []
for n in range(10):
quadrados.append(n ** 2)
# Com list comprehension
quadrados = [n ** 2 for n in range(10)]
print(quadrados)
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
O resultado e identico, mas a comprehension e mais curta e expressa a intencao de forma direta: estamos criando uma lista de quadrados.
Adicionando Filtros com if
Voce pode filtrar elementos adicionando uma clausula if ao final:
# Apenas numeros pares
pares = [n for n in range(20) if n % 2 == 0]
print(pares)
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# Palavras com mais de 5 letras
palavras = ["python", "e", "uma", "linguagem", "poderosa", "e", "versátil"]
longas = [p for p in palavras if len(p) > 5]
print(longas)
# ['python', 'linguagem', 'poderosa']
# Filtrando valores nulos de uma lista
dados = [10, None, 25, None, 30, None, 45]
limpos = [d for d in dados if d is not None]
print(limpos)
# [10, 25, 30, 45]
Usando if/else na Expressao
Quando voce quer transformar valores condicionalmente, o if/else vai na expressao (antes do for):
# Classificar numeros como par ou impar
numeros = range(1, 11)
classificacao = [f"{n} e par" if n % 2 == 0 else f"{n} e impar" for n in numeros]
print(classificacao)
# ['1 e impar', '2 e par', '3 e impar', ...]
# Substituir negativos por zero
valores = [10, -3, 25, -7, 0, 15, -1]
positivos = [v if v >= 0 else 0 for v in valores]
print(positivos)
# [10, 0, 25, 0, 0, 15, 0]
A diferenca e importante: if depois do for filtra elementos, enquanto if/else antes do for transforma elementos.
Comprehensions Aninhadas
Voce pode aninhar multiplos for para iterar sobre estruturas mais complexas:
# Planificar (flatten) uma lista de listas
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
plana = [num for linha in matriz for num in linha]
print(plana)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Gerar pares ordenados
pares = [(x, y) for x in range(3) for y in range(3) if x != y]
print(pares)
# [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
# Transpor uma matriz
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposta = [[linha[i] for linha in matriz] for i in range(3)]
print(transposta)
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
Para comprehensions aninhadas, leia da esquerda para a direita: o primeiro for e o loop externo.
Dict Comprehensions
A mesma sintaxe funciona para criar dicionarios, usando chaves e o formato chave: valor:
# Criar dicionario de quadrados
quadrados = {n: n ** 2 for n in range(1, 6)}
print(quadrados)
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# Inverter chave-valor de um dicionario
original = {"a": 1, "b": 2, "c": 3}
invertido = {v: k for k, v in original.items()}
print(invertido)
# {1: 'a', 2: 'b', 3: 'c'}
# Contar frequencia de caracteres
texto = "abracadabra"
frequencia = {char: texto.count(char) for char in set(texto)}
print(frequencia)
# {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}
# Filtrar dicionario
precos = {"maca": 3.50, "banana": 2.00, "uva": 8.90, "laranja": 4.20}
caros = {fruta: preco for fruta, preco in precos.items() if preco > 4.0}
print(caros)
# {'uva': 8.90, 'laranja': 4.20}
Set Comprehensions
Para criar conjuntos, use chaves sem o formato de chave-valor:
# Letras unicas de uma frase
frase = "programacao em python"
letras = {char for char in frase if char != " "}
print(letras)
# {'a', 'c', 'e', 'g', 'h', 'm', 'n', 'o', 'p', 'r', 't', 'y'}
# Valores unicos transformados
numeros = [1, -1, 2, -2, 3, -3, 3, 2, 1]
absolutos = {abs(n) for n in numeros}
print(absolutos)
# {1, 2, 3}
Generator Expressions
Usando parenteses ao inves de colchetes, voce cria um gerador que nao armazena tudo na memoria:
# Generator expression - avaliacao preguicosa
soma = sum(n ** 2 for n in range(1_000_000))
print(soma)
# 333332833333500000
# Util para processar arquivos grandes
# linhas_validas = (linha.strip() for linha in open("dados.csv") if linha.strip())
A diferenca principal e que generators nao ocupam memoria para todos os elementos de uma vez. Para grandes volumes de dados, prefira generators.
Exemplos Praticos do Dia a Dia
Veja como comprehensions simplificam tarefas comuns:
# Processar lista de usuarios
usuarios = [
{"nome": "Ana", "idade": 28, "ativo": True},
{"nome": "Bruno", "idade": 17, "ativo": True},
{"nome": "Carla", "idade": 35, "ativo": False},
{"nome": "Diego", "idade": 22, "ativo": True},
]
# Nomes dos usuarios ativos e maiores de idade
nomes_ativos = [
u["nome"]
for u in usuarios
if u["ativo"] and u["idade"] >= 18
]
print(nomes_ativos)
# ['Ana', 'Diego']
# Normalizar dados de texto
entradas = [" Python ", "DJANGO", " flask ", "FastAPI"]
normalizadas = [e.strip().lower() for e in entradas]
print(normalizadas)
# ['python', 'django', 'flask', 'fastapi']
# Extrair extensoes de arquivos
arquivos = ["main.py", "style.css", "index.html", "app.py", "data.json"]
extensoes_python = [a for a in arquivos if a.endswith(".py")]
print(extensoes_python)
# ['main.py', 'app.py']
# Criar slugs a partir de titulos
titulos = ["Meu Primeiro Post", "Guia de Python", "Dicas Uteis"]
slugs = [t.lower().replace(" ", "-") for t in titulos]
print(slugs)
# ['meu-primeiro-post', 'guia-de-python', 'dicas-uteis']
Quando Nao Usar Comprehensions
Nem tudo deve ser uma comprehension. Evite quando:
# Ruim: comprehension muito complexa e ilegivel
resultado = [
func(x, y)
for x in range(10)
for y in range(10)
if x != y
if func(x, y) > 0
if outra_condicao(x)
]
# Melhor: usar um loop normal
resultado = []
for x in range(10):
for y in range(10):
if x != y and outra_condicao(x):
valor = func(x, y)
if valor > 0:
resultado.append(valor)
A regra geral e: se a comprehension nao cabe em duas ou tres linhas ou fica dificil de entender de primeira, use um loop tradicional.
Performance
List comprehensions sao geralmente mais rapidas que loops equivalentes porque o interpretador Python otimiza a operacao internamente:
import timeit
# Comparando performance
n = 100_000
tempo_loop = timeit.timeit("""
resultado = []
for i in range(n):
resultado.append(i ** 2)
""", globals={"n": n}, number=100)
tempo_comp = timeit.timeit("""
resultado = [i ** 2 for i in range(n)]
""", globals={"n": n}, number=100)
print(f"Loop: {tempo_loop:.3f}s")
print(f"Comprehension: {tempo_comp:.3f}s")
# Comprehension costuma ser 20-30% mais rapida
Conclusao
List comprehensions sao uma ferramenta essencial no Python. Elas tornam o codigo mais conciso, legivel e performatico quando usadas corretamente. Domine a sintaxe basica, aprenda a usar filtros e transformacoes, e explore dict e set comprehensions para diferentes estruturas de dados. Lembre-se: legibilidade conta, entao use comprehensions quando elas deixam o codigo mais claro, nao quando o tornam mais confuso.
Equipe Python Brasil
Contribuidor do Python Brasil — Aprenda Python em Português