List Comprehensions no Python

✅ Revisado em Maio de 2026 (Python 3.x) Conteúdo enriquecido com benchmarks de performance, análise de memória, comparação com generators e casos de uso do mundo real.

Olá Pythonista!

List Comprehensions são uma das features mais elegantes e poderosas do Python. Elas permitem criar e transformar listas de forma concisa, legível e geralmente mais rápida que loops tradicionais.

Neste guia completo, você vai aprender:

• ✅ Sintaxe e padrões de list comprehensions
• ✅ Benchmarks reais de performance
• ✅ Comparação Generator vs List (memória)
• ✅ Casos de uso do mundo real
• ✅ Quando NÃO usar (legibilidade)

O que é uma list comprehension? Uma list comprehension (compreensão de listas) é uma sintaxe concisa do Python para criar uma nova lista a partir de um iterável em uma única expressão, no formato [expr for item in iteravel]. Ela aplica uma transformação (expr) a cada elemento e, opcionalmente, filtra com if, substituindo um laço for com append() por uma linha mais legível e idiomática. É o equivalente, para listas, das set e dict comprehensions.

Ah, você sabia que o mesmo conceito pode ser aplicado aos dicionários (dict) e conjuntos (set) do Python?

Já abre o post sobre Dict Comprehensions (e set comprehensions) em outra aba e corre pra lá quando terminar aqui!

Vá Direto ao Assunto…

• Listas em Python
• List Comprehensions (Compreensão de Listas)
• Performance: List Comprehension vs For Loop
• List Comprehensions com if
• List Comprehensions com vários if’s
• List Comprehensions com if + else
• Múltiplas List Comprehensions (aninhadas)
• Generator Expression vs List Comprehension
• Casos de Uso do Mundo Real
• Quando NÃO Usar List Comprehensions

Listas em Python

Lista é uma estrutura de dados provida pela própria linguagem e que utilizamos muito na programação Python.

Saber como manuseá-las corretamente, otimizando seu código e tirando maior proveito daquilo que o Python nos proporciona, é sempre uma boa ideia. Se quiser revisar o básico antes, veja nosso guia completo de Listas no Python.

Os seguintes métodos estão disponíveis em uma lista:

• list.append(x): Adiciona um item ao fim da lista.
• list.extend(iterable): Adiciona todos os itens do iterável iterable ao fim da lista.
• list.insert(i, x): Insere um item em uma dada posição i.
• list.remove(x): Remove o primeiro elemento, cujo valor seja x.
• list.pop(i): Remove o item de posição i da lista e o retorna. Caso i não seja especificado, retorna o último elemento da lista.
• list.clear(): Remove todos os elementos da lista.
• list.index(x[, start[, end]]): Retorna o índice do primeiro elemento cujo valor seja x.
• list.count(x): Retorna o número de vezes que o valor x aparece na lista.
• list.sort(key=None, reverse=False): Ordena os items da lista (os argumentos podem ser usados para customizar a ordenação).
• list.reverse(): Reverte os elementos da lista.
• list.copy(): Retorna uma lista com a cópia dos elementos da lista de origem.

Em Python, utilizamos colchetes para criação de listas. Exemplo:

1
2
3
4
5

# Apenas números
lista_numerica = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Letras e números
lista_alfanumerica = ['a', 'b', 'c', 1, 2, 3]

List Comprehensions (Compreensão de Listas)

Uma list comprehension cria uma lista inteira em uma única linha, aplicando uma expressão a cada item de um iterável. Foi concebida na PEP 202 e também está documentada na documentação oficial do Python.

Sua sintaxe básica é:

1

[expr for item in lista]

Em outras palavras: aplique a expressão expr em cada item da lista.

Exemplo: dado o seguinte código:

1
2

for item in range(10):
  lista.append(item**2)

Podemos reescrevê-lo, utilizando list comprehensions, da seguinte forma:

1

lista = [item**2 for item in range(10)]

Ou seja: aplique a potência de 2 em todos os itens da lista.

Outro Exemplo: dado o seguinte código, que transforma os itens da lista em maiúsculos:

1
2

for item in lista:
  resultado.append(str(item).upper())

Podemos reescrevê-lo da seguinte forma:

1

resultado = [str(item).upper() for item in lista]

Performance: List Comprehension vs For Loop

Em transformações simples, a list comprehension costuma ser mais rápida que o for com append() - porque evita as repetidas chamadas ao método append e roda em bytecode otimizado pelo interpretador.

A tabela abaixo resume as três formas mais comuns de transformar uma lista:

💡 map() e filter() retornam um iterador preguiçoso (não uma lista); só produzem os valores quando consumidos. Para a maioria dos casos do dia a dia, a list comprehension é mais legível que map/filter com lambda.

Benchmark 1: Criação de Lista Simples

Vamos comparar criar uma lista com os quadrados de 10.000 números:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import timeit

# Setup: dados de teste
setup = "data = range(10000)"

# Método 1: For loop tradicional
for_loop = """
result = []
for x in data:
    result.append(x**2)
"""

# Método 2: List comprehension
list_comp = "[x**2 for x in data]"

# Executar 1000 vezes e medir tempo
time_loop = timeit.timeit(for_loop, setup, number=1000)
time_comp = timeit.timeit(list_comp, setup, number=1000)

print(f"For loop:          {time_loop:.4f}s")
print(f"List comprehension: {time_comp:.4f}s")
print(f"List comp é {time_loop/time_comp:.2f}x mais rápida!")

Resultado (exemplo - Python 3.10):

1
2
3

For loop:           2.1426s
List comprehension: 1.9049s
List comp é 1.12x mais rápida!

ℹ️ Os números absolutos variam conforme máquina e versão do Python - rode o código aí na sua para ver os seus. O importante é a tendência: para transformações simples, a list comprehension costuma vencer o for + append().

Por que List Comprehensions são mais rápidas?

1. Otimização do interpretador: Python detecta list comprehensions e otimiza bytecode
2. Menos chamadas de função: append() é chamado toda iteração no loop
3. Alocação de memória: List comprehension pre-aloca espaço quando possível

Benchmark 2: Filtragem e Transformação

Vamos filtrar números pares e elevar ao quadrado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import timeit

setup = "data = range(10000)"

# For loop com if
for_loop_if = """
result = []
for x in data:
    if x % 2 == 0:
        result.append(x**2)
"""

# List comprehension com if
list_comp_if = "[x**2 for x in data if x % 2 == 0]"

time_loop = timeit.timeit(for_loop_if, setup, number=1000)
time_comp = timeit.timeit(list_comp_if, setup, number=1000)

print(f"For loop com if:    {time_loop:.4f}s")
print(f"List comp com if:   {time_comp:.4f}s")
print(f"Diferença: {((time_loop - time_comp) / time_loop * 100):.1f}% mais rápido")

Resultado (exemplo - Python 3.10):

1
2
3

For loop com if:    1.4450s
List comp com if:   1.2851s
Diferença: 11.1% mais rápido

💡 Dica Pro: List comprehensions também levam vantagem em operações com filtros (if). A margem exata depende da máquina e da versão do Python, mas a versão concisa tende a ser mais rápida.

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

List Comprehensions com if

Para filtrar elementos, basta adicionar um if ao final da list comprehension: só os itens que satisfazem a condição entram na nova lista.

Sua sintaxe básica é:

1

[expr for item in lista if cond]

Ou seja: aplique a expressão expr em cada item da lista caso a condição cond seja satisfeita.

Vamos criar algumas listas utilizando condições.

Por exemplo, podemos retirar os números ímpares de um conjunto de número da seguinte forma:

1

resultado = [numero for numero in range(20) if numero % 2 == 0]

O que resulta em:

1

resultado = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Vamos ver como fica com vários if’s.

List Comprehensions com vários if’s

Você pode encadear vários if em sequência: o item só entra na lista se todas as condições forem verdadeiras (equivale a uni-las com and).

Por exemplo: gostaríamos de saber os Múltiplos Comuns de 5 e 6.

Utilizando múltiplos if's e list comprehensions, podemos criar o seguinte código:

1

resultado = [numero for numero in range(100) if numero % 5 == 0 if numero % 6 == 0]

Ou seja, o número só será passado para lista resultado caso sua divisão por 5 E por 6 seja igual à zero.

O resultado do código acima será:

1

resultado = [0, 30, 60, 90]

List Comprehensions com if + else

Quando você precisa escolher entre dois valores (em vez de só filtrar), use o if/else ternário antes do for. Repare na posição: com filtro o if vai no fim; com if/else ele vai no começo.

A sintaxe básica para essa construção é:

1

[resultado_if if expr else resultado_else for item in lista]

Em outras palavras: para cada item da lista, aplique o resultado resultado_if se a expressão expr for verdadeira, caso contrário, aplique resultado_else.

Por exemplo, queremos criar uma lista que contenha “1” quando determinado número for múltiplo de 5 e “0” caso contrário.

Podemos codificá-lo da seguinte forma:

1

resultado = ['1' if numero % 5 == 0 else '0' for numero in range(16)]

Dessa forma, teremos o seguinte resultado:

1

resultado = ['1', '0', '0', '0', '0', '1', '0', '0', '0', '0', '1', '0', '0', '0', '0', '1']

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Múltiplas List Comprehensions (aninhadas)

Para estruturas em duas dimensões, você pode aninhar uma list comprehension dentro da outra - o caso clássico é transpor uma matriz.

É aqui que a brincadeira fica séria!

Pra quem não lembra: transpor uma matriz significa transformar as linhas em colunas e vice-versa.

Ou seja, dada a seguinte matriz:

1
2
3
4
5

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

Queremos o seguinte resultado:

Em Python, podemos fazer isso da seguinte forma:

1
2
3
4
5
6
7
8
9

transposta = []
matriz = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

for i in range(len(matriz[0])):
    linha_transposta = []

    for linha in matriz:
        linha_transposta.append(linha[i])
    transposta.append(linha_transposta)

A matriz transposta conteria:

1

transposta = [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Podemos reescrever o código acima, de transposição de matrizes, da seguinte forma, utilizando list comprehension:

1
2

matriz = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
transposta = [[linha[i] for linha in matriz] for i in range(4)]

No código acima:

• No primeiro loop, i assume o valor de 0, portanto [linha[0] for linha in matriz] vai retornar o primeiro elemento de cada linha: [1, 5, 9]
• No segundo loop, i assume o valor de 1, portanto [linha[1] for linha in matriz] vai retornar o segundo elemento de cada linha: [2, 6, 10]
• No terceiro loop, i assume o valor de 2, portanto [linha[2] for linha in matriz] vai retornar o terceiro elemento de cada linha: [3, 7, 11]
• No quarto loop, i assume o valor de 3, portanto [linha[3] for linha in matriz] vai retornar o quarto elemento de cada linha: [4, 8, 12]

Obtendo, assim, o mesmo resultado: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]].

Generator Expression vs List Comprehension

A diferença prática é a memória: a list comprehension (colchetes) materializa todos os valores de uma vez, enquanto a generator expression (parênteses) é lazy e produz um valor por vez, sob demanda.

Sintaxe: Parênteses vs Colchetes

1
2
3
4
5

# List Comprehension (colchetes) - carrega tudo na memória
lista = [x**2 for x in range(1000000)]

# Generator Expression (parênteses) - lazy evaluation
generator = (x**2 for x in range(1000000))

Comparação de Memória

Vamos medir o consumo de memória de cada abordagem:

1
2
3
4
5
6
7
8
9
10
11
12
13

import sys

# Lista: armazena TODOS os 1 milhão de valores
lista = [x**2 for x in range(1000000)]
print(f"Lista:     {sys.getsizeof(lista):,} bytes ({sys.getsizeof(lista) / 1024 / 1024:.2f} MB)")

# Generator: armazena apenas o estado atual
generator = (x**2 for x in range(1000000))
print(f"Generator: {sys.getsizeof(generator):,} bytes ({sys.getsizeof(generator) / 1024:.4f} KB)")

# Diferença
diferenca = sys.getsizeof(lista) / sys.getsizeof(generator)
print(f"\nLista usa {diferenca:,.0f}x MAIS memória!")

Resultado (exemplo - CPython 64 bits):

1
2
3
4

Lista:     8,448,728 bytes (8.06 MB)
Generator: 104 bytes (0.1016 KB)

Lista usa 81,238x MAIS memória!

ℹ️ O tamanho do generator é constante (~104 bytes) independentemente de processar mil ou um bilhão de itens - é justamente aí que mora a economia de memória. O número exato varia com a plataforma/versão do Python.

Quando Usar Cada Um?

Use List Comprehension quando:

• ✅ Você precisa acessar os valores múltiplas vezes
• ✅ Precisa de indexação (lista[5])
• ✅ Precisa dos métodos de lista (len(), sort(), reverse())
• ✅ O dataset é pequeno (< 10.000 itens)

Use Generator quando:

• ✅ Você vai iterar apenas uma vez
• ✅ O dataset é grande ou infinito
• ✅ Quer economizar memória
• ✅ Processa streams de dados (logs, arquivos, APIs)

Exemplo Prático: Processar Arquivo Grande

1
2
3
4
5
6
7
8
9
10
11

# ❌ RUIM: Carrega arquivo inteiro na memória (pode estourar RAM)
with open('gigante.log') as arquivo:
    linhas = [linha.strip().upper() for linha in arquivo]
for linha in linhas:
    processar(linha)

# ✅ BOM: Processa linha por linha (memória constante)
with open('gigante.log') as arquivo:
    linhas = (linha.strip().upper() for linha in arquivo)
    for linha in linhas:
        processar(linha)  # Processa uma de cada vez

💡 Regra de Ouro: Se você iterar apenas uma vez, use generator. Se precisar acessar múltiplas vezes, use list.

Casos de Uso do Mundo Real

Vamos ver exemplos práticos que você pode usar no dia a dia:

1. Limpeza de Dados CSV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import csv

# Ler CSV e limpar dados em uma linha
with open('usuarios.csv') as f:
    reader = csv.DictReader(f)
    # Remove espaços e converte emails para minúsculas
    usuarios_limpos = [
        {
            'nome': row['nome'].strip(),
            'email': row['email'].lower().strip(),
            'idade': int(row['idade'])
        }
        for row in reader
        if row['email']  # Ignora linhas sem email
    ]

2. Processar Resposta de API (JSON)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import requests

# Buscar repos do GitHub e extrair informações
response = requests.get('https://api.github.com/users/python/repos')
repos = response.json()

# Extrair apenas nome e estrelas dos repos com mais de 100 stars
repos_populares = [
    {'nome': repo['name'], 'stars': repo['stargazers_count']}
    for repo in repos
    if repo['stargazers_count'] > 100
]

print(repos_populares)
# [{'nome': 'cpython', 'stars': 45231}, {'nome': 'peps', 'stars': 3421}, ...]

3. Filtrar DataFrames (Pandas)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import pandas as pd

# Criar DataFrame
df = pd.DataFrame({
    'produto': ['A', 'B', 'C', 'D', 'E'],
    'preco': [10, 25, 15, 30, 12],
    'estoque': [100, 0, 50, 200, 5]
})

# Produtos disponíveis (estoque > 0) e baratos (< 20)
produtos_validos = [
    row['produto']
    for _, row in df.iterrows()
    if row['estoque'] > 0 and row['preco'] < 20
]

print(produtos_validos)  # ['A', 'C', 'E']

4. Flatten (Achatar) Lista de Listas

1
2
3
4
5
6
7
8
9

# Lista aninhada
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Achatar em uma única lista
flat = [item for sublista in matriz for item in sublista]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Ou com sum (menos eficiente)
flat = sum(matriz, [])

5. Combinar Múltiplas Listas (Zip)

1
2
3
4
5
6
7
8
9
10
11
12

nomes = ['Ana', 'Bruno', 'Carlos']
idades = [25, 30, 28]
cidades = ['SP', 'RJ', 'MG']

# Criar dicionário com todos os dados
pessoas = [
    {'nome': n, 'idade': i, 'cidade': c}
    for n, i, c in zip(nomes, idades, cidades)
]

print(pessoas)
# [{'nome': 'Ana', 'idade': 25, 'cidade': 'SP'}, ...]

Quando NÃO Usar List Comprehensions

List comprehensions são poderosas, mas podem prejudicar legibilidade quando mal usadas.

❌ Exemplo RUIM: Muito Complexo

1
2
3
4
5
6

# ❌ NÃO FAÇA ISSO - Ilegível!
resultado = [
    {'usuario': u['nome'], 'total': sum(c['valor'] for c in u['compras'] if c['status'] == 'aprovado')}
    for u in usuarios
    if u['ativo'] and len([c for c in u['compras'] if c['status'] == 'aprovado']) > 0
]

Problema: Muito aninhamento, dificulta debug e manutenção.

✅ Solução: Quebrar em Etapas

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# ✅ FAÇA ISSO - Legível e testável!
def calcular_total_aprovado(usuario):
    """Calcula total de compras aprovadas do usuário"""
    compras_aprovadas = [c['valor'] for c in usuario['compras'] if c['status'] == 'aprovado']
    return sum(compras_aprovadas)

def usuario_valido(usuario):
    """Verifica se usuário está ativo e tem compras aprovadas"""
    return usuario['ativo'] and calcular_total_aprovado(usuario) > 0

# Agora fica claro e testável
resultado = [
    {'usuario': u['nome'], 'total': calcular_total_aprovado(u)}
    for u in usuarios
    if usuario_valido(u)
]

Regras de Legibilidade

✅ Use list comprehensions quando:

1. Cabe em 1-2 linhas (máx 79-100 caracteres)
2. A lógica é simples (1 filtro, 1 transformação)
3. Não precisa de debug complexo

❌ Evite list comprehensions quando:

1. Tem múltiplos níveis de aninhamento
2. Lógica complexa com vários if/else
3. Você precisa imprimir valores intermediários (debug)
4. Usa side effects (modificar variáveis externas, I/O)

Exemplo: Quando Usar For Loop Normal

1
2
3
4
5
6
7
8
9

# ❌ RUIM: Side effect em list comprehension
[print(x) for x in lista]  # NÃO FAÇA ISSO!

# ✅ BOM: For loop quando precisa side effects
for x in lista:
    print(x)
    log.info(f'Processando {x}')
    if x > 100:
        enviar_alerta(x)

💡 Lembre-se: Código legível é mais importante que código conciso. Se alguém vai demorar 5 minutos para entender sua list comprehension, use um loop normal!

Conclusão

Neste guia completo sobre List Comprehensions, você aprendeu:

✅ Sintaxe e padrões - Do básico ao aninhamento ✅ Performance - List comprehensions costumam ser mais rápidas que loops for + append() ✅ Generator vs List - Memória constante (~104 bytes) vs lista materializada (vários MB) ✅ Casos de uso reais - CSV, APIs, Pandas, flatten, zip ✅ Quando NÃO usar - Legibilidade é mais importante que concisão

Principais lições:

• List comprehensions são rápidas e concisas para transformações simples
• Use generators para datasets grandes (economiza memória)
• Mantenha legibilidade - se está complexo demais, use loop normal
• Evite side effects em list comprehensions

Agora que você domina list comprehensions, use com sabedoria! Lembre-se: código legível é mais importante que código conciso.

Próximos passos:

• Pratique com seus próprios dados
• Aplique o mesmo conceito a dicionários e conjuntos em Dict Comprehensions (e set comprehensions)
• Experimente Generator Expressions em arquivos grandes

Então… Mão na massa!

Até o próximo post!

Por Vinícius Ramos em 25/10/2018

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Minhas redes: