Compreensão de Listas

Compreensão de Listas em Python

A compreensão de listas é uma forma concisa de construir uma nova lista aplicando uma expressão a cada item de um iterável — opcionalmente filtrando itens com uma condição — tudo em uma única linha legível. Esta página abrange a sintaxe completa, padrões comuns, compreensões de dicionários e conjuntos, e orientações sobre quando um laço for simples é a melhor escolha.

Sintaxe

A forma geral de uma compreensão de listas é:

new_list = [expression for item in iterable if condition]

A parte if condition é opcional. Quando omitida, cada item do iterável produz uma entrada na nova lista.

Exemplo Básico: Elevando Números ao Quadrado

O laço for equivalente requer três linhas; a compreensão de listas faz o mesmo em uma:

Filtragem com uma Condição

Adicione uma cláusula if após o iterável para manter apenas os itens que satisfazem uma condição:

Você pode combinar qualquer predicado. Por exemplo, manter palavras com mais de quatro caracteres:

words = ['hi', 'hello', 'world', 'python', 'ai']
long_words = [w for w in words if len(w) > 4]
print(long_words)  # ['hello', 'world', 'python']

if/else na Expressão (Ternário)

Quando você precisa transformar cada item, mas aplicar lógicas diferentes dependendo de uma condição, coloque o if/else dentro da parte da expressão (antes de for), e não após o iterável:

numbers = range(1, 6)
labels = ['even' if x % 2 == 0 else 'odd' for x in numbers]
print(labels)  # ['odd', 'even', 'odd', 'even', 'odd']

Observe a diferença:

• [expr for x in it if cond] — filtro: ignora itens onde cond é False
• [a if cond else b for x in it] — transformação: cada item produz um valor, escolhido por cond

Trabalhando com Strings

A compreensão de listas funciona com qualquer iterável, incluindo strings e listas de strings:

words = ['hello', 'world', 'python']
upper_words = [w.upper() for w in words]
print(upper_words)  # ['HELLO', 'WORLD', 'PYTHON']

Extraia caracteres individuais que atendam a uma condição:

vowels = [ch for ch in 'programming' if ch in 'aeiou']
print(vowels)  # ['o', 'a', 'i']

Loops Aninhados

A compreensão de listas suporta múltiplas cláusulas for, equivalente a laços aninhados. O for mais à esquerda é o laço externo:

Um caso de uso comum para compreensão de listas aninhada é achatar uma lista 2-D (matriz) em uma lista 1-D:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [n for row in matrix for n in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Dica de leitura: expanda mentalmente as compreensões aninhadas como laços for aninhados na mesma ordem da esquerda para a direita.

Compreensão de Dicionários

A mesma ideia se aplica a dicionários usando {} com uma expressão chave: valor:

keys = ['a', 'b', 'c']
values = [1, 2, 3]
mapping = {k: v for k, v in zip(keys, values)}
print(mapping)  # {'a': 1, 'b': 2, 'c': 3}

Troque chaves e valores em um dicionário existente:

original = {'name': 'Alice', 'city': 'Paris'}
inverted = {v: k for k, v in original.items()}
print(inverted)  # {'Alice': 'name', 'Paris': 'city'}

Compreensão de Conjuntos

Use {} com uma única expressão (sem dois-pontos) para construir um conjunto, que remove duplicatas automaticamente:

numbers = [1, 2, 2, 3, 3, 3, 4]
unique_squares = {x ** 2 for x in numbers}
print(unique_squares)  # {1, 4, 9, 16}

O resultado é não ordenado (conjuntos não possuem ordem garantida), portanto não confie na sequência impressa.

Desempenho

As compreensões de listas são geralmente mais rápidas do que laços for equivalentes que chamam .append(), pois o interpretador pode otimizar o laço interno em C. Para medir o tempo do seu próprio código, use o módulo timeit:

import timeit

loop_time = timeit.timeit(
    'result = []\nfor x in range(1000):\n    result.append(x**2)',
    number=10000
)
comp_time = timeit.timeit(
    '[x**2 for x in range(1000)]',
    number=10000
)
print(f'Loop: {loop_time:.3f}s')
print(f'Comprehension: {comp_time:.3f}s')
# Comprehension is typically 20-40% faster

A vantagem de desempenho diminui ou desaparece quando a própria expressão é lenta (I/O de rede, computação intensa). Faça profiling antes de otimizar.

Quando Usar um Laço for Simples

A compreensão de listas nem sempre é a ferramenta certa:

O sinal mais claro para voltar ao laço for é quando você precisa franzir o cenho para entender o que a compreensão faz.

Armadilhas

Vazamento de variável não ocorre no Python 3. A variável do laço em uma compreensão está no escopo da própria compreensão:

x = 'original'
result = [x * 2 for x in range(3)]
print(x)  # 'original' — not overwritten by the comprehension's x

Evite compreensões profundamente aninhadas. Mais de duas cláusulas for em uma única compreensão prejudica a legibilidade com pouco benefício. Divida-as em listas intermediárias nomeadas ou laços for.

Expressões geradoras economizam memória. Se você só precisa iterar sobre o resultado uma vez (por exemplo, passá-lo para sum() ou max()), substitua [] por () para obter um gerador que produz itens um de cada vez:

total = sum(x ** 2 for x in range(1, 1001))
print(total)  # 333833500

Prática