Comprehensions são sintaxes concisas para criar coleções em Python.
Elas substituem loops tradicionais por expressões declarativas.
Primeiramente, list comprehension é a mais comum entre elas.
Por exemplo, [x*2 for x in range(5)] gera [0,2,4,6,8].
Além disso, dict comprehension e set comprehension também existem.
Assim, você escreve menos código e com mais clareza.
Consequentemente, a manutenção se torna muito mais fácil.
Quando utilizar comprehensions? Em transformações simples de coleções.
Também para filtrar e mapear dados de forma legível.
Por outro lado, para lógica muito complexa, loops são melhores.
Elas são mais rápidas e pythonicas que loops manuais.
Então, vamos explorar cada tipo com exemplos práticos.
Três subtítulos guiarão você pelas comprehensions.
Portanto, ao final, você escreverá código mais limpo e eficiente.
List comprehension: gerando listas de forma concisa
List comprehension cria uma nova lista a partir de um iterável.
A sintaxe básica é [expressão for item in iterável].
Você pode adicionar condicionais com if no final.
Quando usar list comprehension? Para mapeamentos e filtros simples.
Elas são mais rápidas que loops for tradicionais.
Além disso, você pode aninhar múltiplos for e if.
Exemplo de list comprehension:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
# List comprehension básica numeros = [1, 2, 3, 4, 5] quadrados = [x ** 2 for x in numeros] print("=== List Comprehension ===") print(f"Original: {numeros}") print(f"Quadrados: {quadrados}") # Com condicional (filter) pares = [x for x in numeros if x % 2 == 0] print(f"Apenas pares: {pares}") # Com condicional e transformação pares_quadrados = [x ** 2 for x in numeros if x % 2 == 0] print(f"Quadrados dos pares: {pares_quadrados}") # Com else (expressão condicional) par_ou_impar = ["par" if x % 2 == 0 else "ímpar" for x in numeros] print(f"Classificação: {par_ou_impar}") # Com string palavras = ["Python", "comprehension", "é", "poderoso"] tamanhos = [len(palavra) for palavra in palavras] print(f"Tamanhos: {tamanhos}") # Com múltiplos for (produto cartesiano) coordenadas = [(x, y) for x in range(3) for y in range(2)] print(f"Produto cartesiano: {coordenadas}") # Com aninhamento (matriz) matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] achatada = [elemento for linha in matriz for elemento in linha] print(f"Matriz achatada: {achatada}") # Comparação com loop tradicional # Loop tradicional resultado_loop = [] for x in range(10): if x % 2 == 0: resultado_loop.append(x ** 2) # List comprehension (mais limpo) resultado_comp = [x ** 2 for x in range(10) if x % 2 == 0] print(f"Loop: {resultado_loop}") print(f"Comprehension: {resultado_comp}") |
List comprehensions são rápidas e expressivas. Use-as sempre que possível para código mais limpo. Portanto, prefira comprehension a loops simples.
Dict comprehension: criando dicionários dinâmicos
Dict comprehension cria dicionários com sintaxe semelhante.
A forma é {chave: valor for item in iterável}.
Você também pode adicionar condicionais e múltiplos for.
Quando usar dict comprehension? Em transformações chave-valor.
Por exemplo, inverter dicionários ou criar mapeamentos.
Além disso, você pode combinar duas listas facilmente.
Exemplo de dict comprehension:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
# Dict comprehension básica nomes = ["Ana", "Carlos", "Beatriz", "Daniel"] dicionario = {nome: len(nome) for nome in nomes} print("=== Dict Comprehension ===") print(f"Lista: {nomes}") print(f"Dicionário nome -> tamanho: {dicionario}") # Com condicional nomes_longos = {nome: len(nome) for nome in nomes if len(nome) > 5} print(f"Nomes com mais de 5 letras: {nomes_longos}") # Invertendo dicionário original = {"a": 1, "b": 2, "c": 3} invertido = {valor: chave for chave, valor in original.items()} print(f"Original: {original}") print(f"Invertido: {invertido}") # Criando dicionário a partir de duas listas chaves = ["nome", "idade", "cidade"] valores = ["Ana", 25, "São Paulo"] pessoa = {chaves[i]: valores[i] for i in range(len(chaves))} print(f"De duas listas: {pessoa}") # Com zip (mais pythonico) pessoa_zip = {chave: valor for chave, valor in zip(chaves, valores)} print(f"Com zip: {pessoa_zip}") # Mapeamento com transformação numeros = [1, 2, 3, 4, 5] quadrados_dict = {n: n ** 2 for n in numeros} print(f"Números -> quadrados: {quadrados_dict}") # Filtrando dicionário existente pontuacoes = {"Ana": 85, "Carlos": 92, "Beatriz": 78, "Daniel": 88} aprovados = {nome: nota for nome, nota in pontuacoes.items() if nota >= 80} print(f"Aprovados (nota >= 80): {aprovados}") # Com condicional no valor status = {nome: "aprovado" if nota >= 80 else "reprovado" for nome, nota in pontuacoes.items()} print(f"Status: {status}") |
Dict comprehension é ideal para transformar listas em dicionários.
Ela torna o código mais legível que loops com dict.update().
Assim, você evita código verboso e repetitivo.
Set comprehension: conjuntos únicos e eficientes
Set comprehension cria conjuntos (sets) com elementos únicos.
A sintaxe é {expressão for item in iterável}.
Ela remove duplicatas automaticamente por definição.
Quando usar set comprehension? Em operações com elementos únicos.
Por exemplo, extrair valores distintos de uma lista.
Além disso, set comprehension é muito eficiente em performance.
Exemplo de set comprehension:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
# Set comprehension básica numeros = [1, 2, 2, 3, 3, 3, 4, 5, 5] unicos = {x for x in numeros} print("=== Set Comprehension ===") print(f"Lista com duplicatas: {numeros}") print(f"Set de únicos: {unicos}") # Com transformação quadrados_unicos = {x ** 2 for x in numeros} print(f"Quadrados únicos: {quadrados_unicos}") # Com condicional pares_unicos = {x for x in numeros if x % 2 == 0} print(f"Pares únicos: {pares_unicos}") # Com string (caracteres únicos) texto = "abracadabra" caracteres = {letra for letra in texto} print(f"Caracteres únicos em '{texto}': {caracteres}") # Com range pares_ate_20 = {x for x in range(20) if x % 2 == 0} print(f"Pares únicos até 20: {pares_ate_20}") # Produto cartesiano em set produto = {(x, y) for x in range(3) for y in range(3)} print(f"Produto cartesiano (set): {produto}") # Extraindo palavras únicas de um texto frase = "o rato roeu a roupa do rei de roma" palavras_unicas = {palavra for palavra in frase.split()} print(f"Palavras únicas na frase: {palavras_unicas}") # Comparação de performance import timeit lista_grande = [i % 10 for i in range(10000)] # Set comprehension tempo_comp = timeit.timeit( '{x for x in lista_grande}', globals=globals(), number=1000 ) # Loop tradicional def set_com_loop(): resultado = set() for x in lista_grande: resultado.add(x) return resultado tempo_loop = timeit.timeit(set_com_loop, globals=globals(), number=1000) print(f"\nSet comprehension: {tempo_comp:.4f}s") print(f"Loop tradicional: {tempo_loop:.4f}s") |
Set comprehension é eficiente e elimina duplicatas. A fórmula geral das comprehensions é clara: \(C = [f(x) \text{ for } x \text{ in } S \text{ if } p(x)]\) Comprehensions são mais pythonicas que loops tradicionais. Elas são mais rápidas, mais curtas e mais legíveis. Use list comprehension para transformar sequências. Use dict comprehension para mapeamentos chave-valor. Use set comprehension para conjuntos únicos. Portanto, seu código será mais expressivo e profissional. Finalmente, pratique comprehensions em todos os seus projetos.