O que são list comprehensions?

Question

Accepted Answer

Uma **list comprehension** é uma forma concisa e legível de construir uma lista transformando e/ou filtrando um iterável em uma única expressão — a alternativa idiomática do Python para um loop `for` que adiciona a uma lista.

## Sintaxe básica

```python
# the loop way:
squares = []
for n in range(5):
    squares.append(n ** 2)

# the comprehension way — same result, one line
squares = [n ** 2 for n in range(5)]   # [0, 1, 4, 9, 16]
#          └expr──┘ └──for clause───┘
```

Leia como "o quadrado de n, para cada n em range(5)." É mais conciso e frequentemente mais rápido do que o loop manual.

## Adicionando um filtro (if)

```python
# keep only even numbers
evens = [n for n in range(10) if n % 2 == 0]   # [0, 2, 4, 6, 8]

# transform AND filter together
result = [n * 2 for n in range(10) if n % 2 == 0]  # [0, 4, 8, 12, 16]
```

## Expressão condicional na saída

```python
# if/else goes BEFORE the for (it's part of the expression, not a filter)
labels = ["even" if n % 2 == 0 else "odd" for n in range(4)]
# ["even", "odd", "even", "odd"]
```

## Comprehensions para outros tipos

```python
{x ** 2 for x in range(5)}             # set comprehension → {0, 1, 4, 9, 16}
{k: v for k, v in pairs}               # dict comprehension
(x ** 2 for x in range(5))             # generator expression — LAZY, memory-efficient
```

A mesma sintaxe constrói sets e dicts; com parênteses torna-se uma **expressão geradora** que produz valores preguiçosamente (sem lista completa na memória — ótimo para dados grandes).

## Quando NÃO usá-los

```python
# ❌ deeply nested / complex logic → a regular loop is more readable
matrix = [[row[i] for row in data] for i in range(cols)]  # OK, but don't over-nest
```

Mantenha comprehensions simples; se precisarem de múltiplos loops aninhados ou condições complexas, um loop comum é mais claro.

## Por que isso importa

List comprehensions são quintessencialmente "Pythônicas" — concisas, legíveis e frequentemente mais rápidas do que loops equivalentes, usadas constantemente para transformar e filtrar dados.

Dominar elas (mais suas variantes set/dict/generator, e a expressão geradora preguiçosa para dados grandes) é essencial para escrever Python idiomático.

Saber quando usá-las (transformações/filtros simples) versus um loop comum (lógica complexa) é a marca de código limpo e legível.