Comprehensions em Python: guia completo para concursos

Seja para as carreiras de Tecnologia da Informação ou para cargos que exigem Ciência de Dados, Python deixou de ser um diferencial para se tornar um requisito básico. É necessário conhecer diversos aspectos da linguagem. Comprehensions está entre os tópicos mais cobrados nas questões sobre Python nos concursos públicos mais recentes.

Veja o que será abordado:

• O que são comprehensions e qual é sua principal vantagem
• Sintaxe e exemplos de list comprehension
• Como usar filtros dentro de comprehensions
• Dict comprehension e set comprehension
• Generator expressions e eficiência de memória
• Armadilhas comuns cobradas em provas

O que são comprehensions?

Comprehensions são uma forma concisa de criar listas, dicionários e conjuntos em Python a partir de iteráveis. Em vez de escrever um loop for com várias linhas, toda a lógica é condensada em uma única expressão.

A principal vantagem das list comprehensions em relação ao loop for convencional é a sintaxe mais concisa e legível. Isso foi cobrado diretamente em questão de concurso, que perguntava sobre a principal vantagem do recurso. A alternativa correta afirmava justamente que ele “resulta em uma sintaxe mais concisa e legível quando comparado a um loop for convencional para criar listas”.

Vale destacar: comprehensions não se limitam a listas. O Python oferece variações para dicionários, conjuntos e geradores, cada uma com características e delimitadores próprios.

List comprehension

A list comprehension é a forma mais utilizada do recurso. Sua sintaxe segue o padrão abaixo:

resultado = [expressao for item in iteravel]

Exemplo: para criar uma lista com os quadrados dos números de 1 a 5:

numeros = [1, 2, 3, 4, 5]
quadrados = [x**2 for x in numeros]
# Resultado: [1, 4, 9, 16, 25]

Sem o list comprehension, o mesmo resultado exigiria um bloco for com append(). A forma compacta produz o mesmo efeito, mas em menos linhas e com leitura mais fluída para quem conhece a sintaxe.

Filtros em list comprehensions

Uma das variações mais cobradas em provas é o uso de condicionais com if dentro do list comprehension. A sintaxe é:

resultado = [expressao for item in iteravel if condicao]

Observe o exemplo que apareceu diretamente em questão de concurso:

numeros = [1, 2, 3, 4, 5]
resultado = [x**2 for x in numeros if x % 2 == 0]
print(resultado)

O operador x % 2 == 0 seleciona apenas os números pares (2 e 4). Os números 1, 3 e 5 são descartados pelo filtro antes de qualquer transformação.

Esse padrão de filtrar e transformar é exatamente o que as bancas costumam testar: saber identificar corretamente quais elementos sobrevivem ao filtro e qual valor é calculado ao final.

Dict comprehension e set comprehension

Além das listas, o Python permite criar dicionários e conjuntos com a mesma lógica. A distinção está nos delimitadores utilizados:

Tipo	Delimitador	Exemplo
List comprehension	[ ]	[x*2 for x in nums]
Set comprehension	{ }	{x*2 for x in nums}
Dict comprehension	{ : }	{x: x*2 for x in nums}

No dict comprehension, é necessário informar uma expressão para a chave e outra para o valor:

numeros = [1, 2, 3]
quadrados = {x: x**2 for x in numeros}
# Resultado: {1: 1, 2: 4, 3: 9}

No set comprehension, o resultado é um conjunto sem elementos duplicados e sem ordem garantida:

letras = [‘a’, ‘b’, ‘a’, ‘c’]
conjunto = {l.upper() for l in letras}
# Resultado: {‘A’, ‘B’, ‘C’}

Os três tipos admitem condicionais com if da mesma forma que o list comprehension.

Generator expressions

As generator expressions têm a mesma sintaxe das list comprehensions, mas utilizam parênteses no lugar de colchetes:

gerador = (x**2 for x in range(1000000))

A diferença fundamental é que o gerador não armazena todos os valores na memória de uma vez. Os elementos são produzidos sob demanda, conforme o código os consome. Isso foi abordado em questão de concurso, que afirmava corretamente:

“A expressão sum(x**2 for x in range(1000000)) utiliza um gerador, que gera os valores sob demanda sem armazená-los em memória, tornando o processamento mais eficiente para grandes volumes de dados.”

Como regra prática: use list comprehension quando precisar acessar os valores múltiplas vezes ou por índice; use generator expression quando precisar percorrer os dados apenas uma vez, especialmente com grandes volumes.

Armadilhas comuns em provas

Algumas situações costumam confundir candidatos nas provas. As principais são:

• Late binding com lambda: quando uma lambda dentro de um list comprehension referencia (captura) a variável do loop sem recebê-la como parâmetro, todas as funções geradas usam o último valor da variável ao momento em que são chamadas, e não o valor que ela tinha quando a função foi criada. Veja o exemplo que apareceu em questão de concurso:

nums = [1, 2, 3]
res = [lambda: n * 2 for n in nums]
print(res[0](), res[1](), res[2]())
# Saída: 6 6 6

O candidato pode esperar as saídas 2 4 6, mas as três funções imprimem 6, pois ao serem chamadas o loop já terminou e n vale 3 para todas elas. Para corrigir o comportamento, basta passar n como parâmetro padrão da lambda, forçando a captura do valor no momento da criação:

res = [lambda n=n: n * 2 for n in nums]
print(res[0](), res[1](), res[2]())
# Saída: 2 4 6

• Set vs. dict comprehension: ambos usam { }, mas o dict comprehension sempre terá o formato chave: valor. Sem os dois pontos, trata-se de um set.
• O filtro elimina antes de transformar: em [x**2 for x in nums if x > 2], os valores menores ou iguais a 2 são descartados primeiro; só então os demais são elevados ao quadrado.
• Generator não suporta indexação: tentar acessar gerador[0] levanta um TypeError, pois geradores não são sequências indexáveis como listas.

Conclusão

As comprehensions em Python figuram entre os recursos mais cobrados em concursos que envolvem programação. Dominar a sintaxe do list, dict e set comprehension, além das generator expressions, permite não apenas resolver questões de código com segurança, mas também compreender as escolhas de estruturas da linguagem. 

https://docs.python.org/3/tutorial/datastructures.html

https://medium.com/skiller-whale/late-binding-variables-its-a-trap-c17af980164f

https://jellis18.github.io/post/2022-11-23-late-binding-python

Concursos Abertos

Concursos 2026