List comprehension Python: como simplificar seu código
9 min9 minutos de leitura
9 min9 minutos de leitura
Autor(a)
Mike de Sousa
Olá, me chamo Mike de Sousa. Atuo como Suporte Educacional aqui na Alura, onde tenho a oportunidade de aprender ainda mais enquanto ajudo outras pessoas em sua jornada. Tenho um foco especial em Front-end, explorando React e TypeScript, mas estou sempre em busca de novos conhecimentos e desafios. Fora da programação, gosto de jogar RPG de mesa, explorar novas ideias e deixar a criatividade fluir.
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Sabe aquele momento em que você precisa percorrer uma lista, aplicar uma regra e salvar o resultado em uma nova coleção?
No Python, o que normalmente exigiria um loop de várias linhas e um .append() pode ser resolvido de forma muito mais elegante com a List Comprehension.
Mais do que "escrever menos", essa técnica permite transformar dados rapidamente, mantendo a lógica concentrada em uma única expressão.
É como trocar um caminho cheio de curvas por uma linha reta bem sinalizada: o código não fica apenas menor, ele fica mais legível.
Neste artigo, vamos mergulhar no funcionamento da List Comprehension: entender como criar e usá-la com exemplos práticos, quando ela é a melhor escolha e quais cuidados tomar para que a simplicidade não acabe excluindo a clareza do seu projeto.
O que é List Comprehension?
List Comprehension é uma forma concisa de criar listas em Python a partir de outras listas, strings, dicionários ou qualquer estrutura iterável. Em vez de escrever várias linhas usando loops, você expressa a transformação dos dados em uma única linha.
Na prática, funciona como uma fábrica de listas: você define de onde vêm os dados, o que será feito com cada item e, se quiser, quais itens entram no resultado. Tudo isso dentro de colchetes.
Para entender a diferença, veja como criaríamos uma lista de números dobrados da forma tradicional:
numeros = [1, 2, 3, 4, 5]
dobrados = []
for n in numeros:
dobrados.append(n * 2)
Com List Comprehension, eliminamos o ruído visual e focamos no que importa:
numeros = [1, 2, 3, 4, 5]
dobrados = [n * 2 for n in numeros]
O resultado é o mesmo, mas o código fica mais direto e fácil de entender quando a lógica é simples.
List Comprehension não substitui todo tipo de for, mas ela é muito útil quando a intenção é transformar, filtrar ou criar listas rapidamente. Quando a lógica começa a ficar complexa demais, o loop tradicional ainda é uma ótima escolha.
O que muda quando usamos List Comprehension?
Quando você usa List Comprehension, o foco muda do como fazer para o que está sendo feito. Em vez de declarar uma lista vazia e ir preenchendo aos poucos, você descreve diretamente a transformação dos dados.
Usando o mesmo exemplo anterior:
numeros = [1, 2, 3, 4, 5]
dobrados = [n * 2 for n in numeros]
A principal mudança está na clareza da intenção. Em uma única linha, fica claro de onde vêm os dados, qual transformação acontece e qual é o resultado esperado.
Sintaxe básica da List Comprehension
A sintaxe da List Comprehension segue um padrão bem fácil de memorizar. A ideia é sempre a mesma: definir o que será gerado, percorrer uma coleção e, se necessário, aplicar uma condição.
O formato básico é esse:
[ expressão for item in iterável ]
Expressão: é o que será gerado e guardado na nova lista (o valor transformado).
Item: é a variável que representa cada elemento individual da lista original.
Iterável: é a fonte dos dados (uma lista, string, etc.).
Se você não quiser processar todos os itens, pode adicionar uma condição if ao final. A estrutura passa a ser:
[ expressão for item in iterável if condição]
Diferente do for tradicional, onde primeiro você abre o loop e depois decide o que fazer, aqui a expressão que gera o valor final vem primeiro. Essa sequência ajuda a ler o código como uma frase: "Eu quero [isso] para cada [item] em [algum lugar] se [esta regra for verdade]".
Essa lógica de leitura fluida é o que evita confusões conforme você começa a criar listas mais elaboradas.
Exemplos práticos de List Comprehension
List Comprehension aparece o tempo todo em todo lugar, desde tarefas mais simples até fluxos mais completos de dados. Vamos ver alguns exemplos.
Criando listas a partir de outras listas
Imagine que você recebe uma lista de preços e precisa aplicar um desconto de 10% em cada item antes de mostrar no sistema. Podemos fazer da seguinte forma:
precos = [100, 250, 400]precos_com_desconto = [preco * 0.9 for preco in precos]
# Resultado: [90.0, 225.0, 360.0]
Nesse exemplo, você:
percorre a lista precos
aplica o desconto em cada valor
gera uma nova lista já pronta para uso
Usando condição para filtrar dados
Agora pense em um cenário de validação. Você tem uma lista de idades e precisa separar apenas quem pode acessar determinado conteúdo.
idades = [12, 16, 18, 21, 14]permitidas = [idade for idade in idades if idade >= 18]
# Resultado: [18, 21]
Nesse caso:
o for percorre todas as idades
a condição if idade >= 18 filtra os valores, e
apenas os números que passam pela regra entram na lista final
Padronizando strings
Muitas vezes recebemos dados “sujos” de usuários. A List Comprehension é perfeita para normalizar essas strings:
nomes = [" Ana ", "joão", " MARIA "]nomes_formatados = [nome.strip().title() for nome in nomes]
# Resultado: ["Ana", "João", "Maria"]
Extraindo dados de estruturas complexas
Em aplicações reais, o cenário mais comum é lidar com JSONs(listas de dicionários) retornados por APIs ou banco de dados. Com a List Comprehension podemos “limpar” esses dados e extrair somente o que é necessário.
usuarios = [
{"nome": "Ana", "ativo": True},
{"nome": "João", "ativo": False},
{"nome": "Maria", "ativo": True}
]
usuarios_ativos = [usuario["nome"] for usuario in usuarios if usuario["ativo"]]
print(usuarios_ativos)
# Resultado: ['Ana', 'Maria']
A List Comprehension é muito versátil, e em todos os casos, o objetivo é o mesmo: unificar a iteração (for) e a ação (cálculo ou filtro, por exemplo) em uma estrutura única, economizando linhas de código e tornando a intenção da pessoa desenvolvedora muito mais clara.
No entanto, com grandes poderes vem a necessidade de cautela. Existe um limite onde a brevidade começa a atrapalhar a clareza do código.
Quando usar (e quando evitar) List Comprehension
A grande vantagem da List Comprehension é a concisão, mas o seu limite é sempre a legibilidade. Nem tudo que pode ser escrito em uma linha deve ser escrito em uma linha.
Quando usar
A List Comprehension se destaca quando a intenção do código é direta. Prefira usá-la quando:
A lógica é imediata: o que está sendo feito pode ser lido e entendido em segundos.
Fluxo Simples: você tem apenas um for principal e, no máximo, um if de filtragem.
Transformações Puras: o objetivo é apenas gerar uma nova lista a partir de uma existente (ex: converter moedas, extrair nomes, formatar textos).
Fluidez: a leitura da linha de código parece uma frase natural: "pegue o nome para cada usuário se ele estiver ativo".
Quando evitar
Se você precisar parar para "decifrar" o que a linha faz, ela provavelmente deveria ser um loop tradicional. Evite quando:
Lógica com muitos else: o uso de if/else dentro da compreensão costuma ficar confuso rapidamente.
Loops Aninhados: usar dois ou mais for na mesma linha (ex: percorrer uma matriz) dificilmente é intuitivo para quem lê.
Precisa de um comentário? se você sente que precisa escrever um comentário acima da List Comprehension para explicar o que ela faz, é sinal de que ela está complexa demais.
O código é lido muito mais vezes do que é escrito. Entre economizar três linhas de código e economizar dez segundos de interpretação de um colega, escolha sempre poupar o esforço de quem lê.
# Evite
resultado = [x if x > 0 else 0 for x in numeros if x % 2 == 0]
Um loop for tradicional é "honesto": ele mostra passo a passo o que está acontecendo. Já uma List Comprehension complexa pode esconder bugs em meio a uma sintaxe compacta.
A ideia não é escolher um estilo para usar sempre, mas sim saber qual ferramenta melhor comunica a sua intenção no momento.
Próximos passos para evoluir em Python
Dominar a List Comprehension é um marco na sua evolução com Python. Mais do que "escrever menos", esse recurso ensina você a pensar de forma mais declarativa, focando no resultado que deseja obter dos seus dados.
A partir daqui, o desafio é aplicar essa mentalidade em cenários reais de desenvolvimento. Para quem deseja se aprofundar e entender como Python sustenta aplicações completas, desde a manipulação eficiente de dados até a construção de APIs, vale explorar a carreira de Desenvolvimento Backend com Python
Espero que este guia tenha ajudado a tornar seu código mais simples e expressivo.
Bons estudos e até a próxima!
FAQ | Perguntas frequentes sobre List Comprehension em Python
Você ainda ficou com algumas dúvidas depois do conteúdo? Calma, confira abaixo as perguntas mais frequentes!
1. A List Comprehension é mais rápida do que um for tradicional?
Na maioria dos casos, sim. No entanto, performance não deve ser o principal critério. Se a List Comprehension comprometer a legibilidade, o for tradicional é a melhor escolha.
2. Posso usar else dentro de uma List Comprehension?
Sim, mas é preciso cuidado. O else faz parte da expressão, não da condição de filtragem. Por exemplo:
numeros = [1, -2, 3, -4]
resultado = [n if n > 0 else 0 for n in numeros]
# Resultado: [1, 0, 3, 0]
Perceba que:
if/else vem antes do for
Esse padrão não filtra, mas transforma os valores
3. Qual a diferença entre filtrar e usar if/else?
Filtrar decide quais itens entram na lista:
[n for n in numeros if n > 0]
if/else decide como cada item será transformado:
[n if n > 0 else 0 for n in numeros]
Entender essa diferença evita muitos erros comuns.
4. Posso usar funções dentro da List Comprehension?
Sim, sem problema algum. É muito comum usar funções para deixar o código mais legível:
defaplicar_desconto(preco):
return preco * 0.9
precos_com_desconto = [aplicar_desconto(p) for p in precos]
5. List Comprehension substitui map() e filter()?
Na prática, sim, e com melhor legibilidade em grande parte dos casos.
Compare:
list(map(lambda x: x * 2, numeros))
com:
[x * 2 for x in numeros]
A List Comprehension costuma ser mais clara, especialmente para quem está lendo o código depois.
6. Quando devo evitar usar a List Comprehension?
Evite quando:
a lógica depende de vários passos
há múltiplas decisões encadeadas
você precisa tratar exceções
o código perde clareza ao ficar em uma única linha
