antonino, Autor em Área de Trampo

Geradores em Python

15/06/202622/04/2026 Por antonino

O que é yield?

yield é uma palavra-chave que transforma uma função em um gerador (generator). Diferente de return, que encerra a função e retorna um único valor, yield permite que a função “pause” sua execução, retorne um valor e depois retome de onde parou.

Características principais:

Lazy evaluation (avaliação preguiçosa): gera valores sob demanda
Eficiência de memória: não armazena toda a sequência
Estado preservado: mantém variáveis locais entre chamadas

Geradores são funções que produzem valores um de cada vez. Eles usam yield em vez de return para pausar a execução. Primeiramente, geradores economizam memória para grandes sequências. Por exemplo, range(1000000) é um gerador, não uma lista. Além disso, geradores podem produzir sequências infinitas. A voz passiva é usada aqui: “os valores são gerados sob demanda, não antecipadamente”. Quando utilizar geradores? Em processamento de grandes arquivos. Também em fluxos de dados infinitos e pipelines eficientes. Python oferece funções geradoras (yield) e expressões geradoras. Vamos explorar ambos os tipos com exemplos práticos. Três subtítulos guiarão você pelo universo dos geradores. Ao final, você economizará memória e processamento significativamente.

Funções geradoras com yield

Uma função geradora usa yield em vez de return. Ela retorna um objeto gerador, não uma lista completa. Cada yield pausa a função e guarda seu estado. Quando usar funções geradoras? Em sequências complexas. Por exemplo, Fibonacci, números primos ou leitura de arquivos grandes. A voz passiva é aplicada: “o estado da função é preservado entre chamadas”. Exemplo de funções geradoras:

# Gerador simples de números pares
def gerar_pares(limite):
    """Gera números pares até o limite (usando yield)."""
    for i in range(limite):
        if i % 2 == 0:
            yield i

print("=== Funções Geradoras ===")
pares = gerar_pares(10)
print(f"Gerador: {pares}")
print(f"Valores: {list(pares)}")

# Gerador de Fibonacci (sequência infinita)
def fibonacci():
    """Gera sequência de Fibonacci infinitamente."""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print("\nPrimeiros 10 Fibonacci:")
fib = fibonacci()
for _ in range(10):
    print(next(fib), end=" ")
print()

# Gerador para ler arquivo linha a linha
def ler_linhas_arquivo(caminho):
    """Lê arquivo linha por linha (economiza memória)."""
    with open(caminho, 'r') as arquivo:
        for linha in arquivo:
            yield linha.rstrip('\n')

# Criando arquivo de teste
with open("teste_gerador.txt", "w") as f:
    for i in range(1000):
        f.write(f"Linha {i}\n")

print("\nPrimeiras 5 linhas do arquivo:")
for i, linha in enumerate(ler_linhas_arquivo("teste_gerador.txt")):
    if i >= 5:
        break
    print(f"  {linha}")

# Gerador com estado (usando send)
def acumulador():
    """Recebe valores via send e acumula."""
    total = 0
    while True:
        valor = yield total
        if valor is not None:
            total += valor

print("\nAcumulador com send:")
acc = acumulador()
next(acc)  # Inicializa o gerador
print(f"Enviando 5: {acc.send(5)}")
print(f"Enviando 10: {acc.send(10)}")
print(f"Enviando 3: {acc.send(3)}")

# Gerador com fechamento (close)
def contador():
    for i in range(10):
        yield i

print("\nFechando gerador:")
c = contador()
print(next(c))
c.close()
try:
    print(next(c))
except StopIteration:
    print("Gerador fechado!")

# Gerador simples de números pares

def gerar_pares(limite):

"""Gera números pares até o limite (usando yield)."""

for i in range(limite):

if i % 2 == 0:

yield i

print("=== Funções Geradoras ===")

pares = gerar_pares(10)

print(f"Gerador: {pares}")

print(f"Valores: {list(pares)}")

# Gerador de Fibonacci (sequência infinita)

def fibonacci():

"""Gera sequência de Fibonacci infinitamente."""

a, b = 0, 1

while True:

yield a

a, b = b, a + b

print("\nPrimeiros 10 Fibonacci:")

fib = fibonacci()

for _ in range(10):

print(next(fib), end=" ")

print()

# Gerador para ler arquivo linha a linha

def ler_linhas_arquivo(caminho):

"""Lê arquivo linha por linha (economiza memória)."""

with open(caminho, 'r') as arquivo:

for linha in arquivo:

yield linha.rstrip('\n')

# Criando arquivo de teste

with open("teste_gerador.txt", "w") as f:

for i in range(1000):

f.write(f"Linha {i}\n")

print("\nPrimeiras 5 linhas do arquivo:")

for i, linha in enumerate(ler_linhas_arquivo("teste_gerador.txt")):

if i >= 5:

break

print(f" {linha}")

# Gerador com estado (usando send)

def acumulador():

"""Recebe valores via send e acumula."""

total = 0

while True:

valor = yield total

if valor is not None:

total += valor

print("\nAcumulador com send:")

acc = acumulador()

next(acc) # Inicializa o gerador

print(f"Enviando 5: {acc.send(5)}")

print(f"Enviando 10: {acc.send(10)}")

print(f"Enviando 3: {acc.send(3)}")

# Gerador com fechamento (close)

def contador():

for i in range(10):

yield i

print("\nFechando gerador:")

c = contador()

print(next(c))

c.close()

try:

print(next(c))

except StopIteration:

print("Gerador fechado!")

Geradores com yield são poderosos e eficientes. Eles permitem pausar e retomar a execução livremente.

Expressões geradoras: generator expressions

Generator expressions são como list comprehensions, mas com parênteses. Elas produzem valores sob demanda, não uma lista inteira. A sintaxe é (expressão for item in iterável). Quando usar generator expressions? Em transformações de dados grandes. Também quando você só precisa iterar uma vez sobre os valores. A voz passiva é aplicada: “os elementos são produzidos um por um”. Exemplo de generator expressions:

# Generator expression básica
numeros = range(10)
quadrados_gen = (x ** 2 for x in numeros)
quadrados_lista = [x ** 2 for x in numeros]

print("=== Generator Expressions ===")
print(f"Generator: {quadrados_gen}")
print(f"Lista: {quadrados_lista}")
print(f"Tamanho do generator: {quadrados_gen.__sizeof__()} bytes")
print(f"Tamanho da lista: {quadrados_lista.__sizeof__()} bytes")

# Economia de memória com generator
import sys

lista_grande = [x for x in range(1000000)]
gen_grande = (x for x in range(1000000))

print(f"\nMemória lista: {sys.getsizeof(lista_grande)} bytes")
print(f"Memória generator: {sys.getsizeof(gen_grande)} bytes")

# Generator com condicional
pares_gen = (x for x in range(20) if x % 2 == 0)
print(f"Pares (generator): {list(pares_gen)}")

# Pipeline com generators (encadeamento)
def gerar_numeros(n):
    for i in range(n):
        yield i

quadrados = (x ** 2 for x in gerar_numeros(10))
pares_quadrados = (x for x in quadrados if x % 2 == 0)
print(f"Pipeline: {list(pares_quadrados)}")

# Generator com múltiplos for
coordenadas_gen = ((x, y) for x in range(3) for y in range(3))
print(f"Coordenadas: {list(coordenadas_gen)}")

# Generator para soma sem criar lista
soma = sum(x ** 2 for x in range(1000000))
print(f"\nSoma de quadrados (sem lista): {soma}")

# Generator para any/all
tem_par = any(x % 2 == 0 for x in range(1000000))
todos_pares = all(x % 2 == 0 for x in range(10))
print(f"Tem par? {tem_par}")
print(f"Todos pares? {todos_pares}")

# Comparação de performance
import timeit

# Com lista comprehension
def usando_lista():
    return sum([x ** 2 for x in range(10000)])

# Com generator expression
def usando_generator():
    return sum(x ** 2 for x in range(10000))

tempo_lista = timeit.timeit(usando_lista, number=1000)
tempo_gen = timeit.timeit(usando_generator, number=1000)
print(f"\nList comprehension: {tempo_lista:.4f}s")
print(f"Generator expression: {tempo_gen:.4f}s")

# Generator expression básica

numeros = range(10)

quadrados_gen = (x ** 2 for x in numeros)

quadrados_lista = [x ** 2 for x in numeros]

print("=== Generator Expressions ===")

print(f"Generator: {quadrados_gen}")

print(f"Lista: {quadrados_lista}")

print(f"Tamanho do generator: {quadrados_gen.__sizeof__()} bytes")

print(f"Tamanho da lista: {quadrados_lista.__sizeof__()} bytes")

# Economia de memória com generator

import sys

lista_grande = [x for x in range(1000000)]

gen_grande = (x for x in range(1000000))

print(f"\nMemória lista: {sys.getsizeof(lista_grande)} bytes")

print(f"Memória generator: {sys.getsizeof(gen_grande)} bytes")

# Generator com condicional

pares_gen = (x for x in range(20) if x % 2 == 0)

print(f"Pares (generator): {list(pares_gen)}")

# Pipeline com generators (encadeamento)

def gerar_numeros(n):

for i in range(n):

yield i

quadrados = (x ** 2 for x in gerar_numeros(10))

pares_quadrados = (x for x in quadrados if x % 2 == 0)

print(f"Pipeline: {list(pares_quadrados)}")

# Generator com múltiplos for

coordenadas_gen = ((x, y) for x in range(3) for y in range(3))

print(f"Coordenadas: {list(coordenadas_gen)}")

# Generator para soma sem criar lista

soma = sum(x ** 2 for x in range(1000000))

print(f"\nSoma de quadrados (sem lista): {soma}")

# Generator para any/all

tem_par = any(x % 2 == 0 for x in range(1000000))

todos_pares = all(x % 2 == 0 for x in range(10))

print(f"Tem par? {tem_par}")

print(f"Todos pares? {todos_pares}")

# Comparação de performance

import timeit

# Com lista comprehension

def usando_lista():

return sum([x ** 2 for x in range(10000)])

# Com generator expression

def usando_generator():

return sum(x ** 2 for x in range(10000))

tempo_lista = timeit.timeit(usando_lista, number=1000)

tempo_gen = timeit.timeit(usando_generator, number=1000)

print(f"\nList comprehension: {tempo_lista:.4f}s")

print(f"Generator expression: {tempo_gen:.4f}s")

Generator expressions economizam memória drasticamente. Elas são ideais para processamento de grandes volumes de dados.

Comparando geradores com listas e aplicações práticas

Geradores são melhores para grandes volumes de dados. Listas são melhores quando você precisa acessar múltiplas vezes. Quando usar cada um? Listas para dados pequenos e reuso. Geradores para streams grandes e iteração única. A voz passiva é aplicada: “os dados são processados em fluxo contínuo”. Exemplo prático e comparação detalhada:

# Comparação de consumo de memória
import tracemalloc

def medir_memoria(func):
    tracemalloc.start()
    resultado = func()
    atual, pico = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return resultado, pico / 1024  # KB

def gerar_com_lista():
    return [x ** 2 for x in range(1000000)]

def gerar_com_generator():
    return (x ** 2 for x in range(1000000))

print("=== Comparação de Memória ===")
_, memoria_lista = medir_memoria(gerar_com_lista)
_, memoria_gen = medir_memoria(gerar_com_generator)
print(f"Lista: {memoria_lista:.0f} KB")
print(f"Generator: {memoria_gen:.0f} KB")

# Processamento de arquivo gigante (simulado)
def processar_logs_com_generator(caminho):
    """Processa logs linha a linha sem carregar tudo."""
    with open(caminho, 'r') as f:
        for linha in f:
            if "ERRO" in linha:
                yield linha.strip()

print("\n=== Processamento de Logs ===")
# Criando arquivo de log simulado
with open("logs.txt", "w") as f:
    for i in range(10000):
        tipo = "ERRO" if i % 100 == 0 else "INFO"
        f.write(f"{tipo}: Mensagem {i}\n")

erros = processar_logs_com_generator("logs.txt")
contagem = 0
for erro in erros:
    contagem += 1
    if contagem <= 5:
        print(f"  {erro}")
print(f"Total de erros encontrados: {contagem}")

# Gerador para paginação de dados
def paginar(dados, tamanho_pagina):
    """Divide dados em páginas usando gerador."""
    for i in range(0, len(dados), tamanho_pagina):
        yield dados[i:i + tamanho_pagina]

dados = list(range(100))
print("\n=== Paginação ===")
for pagina in paginar(dados, 20):
    print(f"Página: {pagina[:5]}... (total {len(pagina)})")

# Gerador para streaming de dados
def streaming_dados():
    """Simula streaming de dados de um sensor."""
    import random
    import time
    while True:
        yield {"timestamp": time.time(), "valor": random.random()}
        time.sleep(0.1)

print("\n=== Streaming (primeiros 5 valores) ===")
stream = streaming_dados()
for i in range(5):
    dado = next(stream)
    print(f"  {dado['timestamp']:.2f}: {dado['valor']:.4f}")

# Pipeline de processamento com geradores
def ler_dados():
    for i in range(1000):
        yield i

def filtrar_pares(dados):
    for valor in dados:
        if valor % 2 == 0:
            yield valor

def multiplicar_por_dois(dados):
    for valor in dados:
        yield valor * 2

def somar(dados):
    total = 0
    for valor in dados:
        total += valor
        yield total

pipeline = somar(multiplicar_por_dois(filtrar_pares(ler_dados())))
print(f"\nPipeline (primeiros 10 resultados): {list(pipeline)[:10]}")

# Comparação de consumo de memória

import tracemalloc

def medir_memoria(func):

tracemalloc.start()

resultado = func()

atual, pico = tracemalloc.get_traced_memory()

tracemalloc.stop()

return resultado, pico / 1024 # KB

def gerar_com_lista():

return [x ** 2 for x in range(1000000)]

def gerar_com_generator():

return (x ** 2 for x in range(1000000))

print("=== Comparação de Memória ===")

_, memoria_lista = medir_memoria(gerar_com_lista)

_, memoria_gen = medir_memoria(gerar_com_generator)

print(f"Lista: {memoria_lista:.0f} KB")

print(f"Generator: {memoria_gen:.0f} KB")

# Processamento de arquivo gigante (simulado)

def processar_logs_com_generator(caminho):

"""Processa logs linha a linha sem carregar tudo."""

with open(caminho, 'r') as f:

for linha in f:

if "ERRO" in linha:

yield linha.strip()

print("\n=== Processamento de Logs ===")

# Criando arquivo de log simulado

with open("logs.txt", "w") as f:

for i in range(10000):

tipo = "ERRO" if i % 100 == 0 else "INFO"

f.write(f"{tipo}: Mensagem {i}\n")

erros = processar_logs_com_generator("logs.txt")

contagem = 0

for erro in erros:

contagem += 1

if contagem <= 5:

print(f" {erro}")

print(f"Total de erros encontrados: {contagem}")

# Gerador para paginação de dados

def paginar(dados, tamanho_pagina):

"""Divide dados em páginas usando gerador."""

for i in range(0, len(dados), tamanho_pagina):

yield dados[i:i + tamanho_pagina]

dados = list(range(100))

print("\n=== Paginação ===")

for pagina in paginar(dados, 20):

print(f"Página: {pagina[:5]}... (total {len(pagina)})")

# Gerador para streaming de dados

def streaming_dados():

"""Simula streaming de dados de um sensor."""

import random

import time

while True:

yield {"timestamp": time.time(), "valor": random.random()}

time.sleep(0.1)

print("\n=== Streaming (primeiros 5 valores) ===")

stream = streaming_dados()

for i in range(5):

dado = next(stream)

print(f" {dado['timestamp']:.2f}: {dado['valor']:.4f}")

# Pipeline de processamento com geradores

def ler_dados():

for i in range(1000):

yield i

def filtrar_pares(dados):

for valor in dados:

if valor % 2 == 0:

yield valor

def multiplicar_por_dois(dados):

for valor in dados:

yield valor * 2

def somar(dados):

total = 0

for valor in dados:

total += valor

yield total

pipeline = somar(multiplicar_por_dois(filtrar_pares(ler_dados())))

print(f"\nPipeline (primeiros 10 resultados): {list(pipeline)[:10]}")

Geradores são fundamentais para programação eficiente. A fórmula da economia de memória com geradores: \(M_{\text{gerador}} \approx O(1) \quad \text{vs} \quad M_{\text{lista}} \approx O(n)\) Use geradores para grandes volumes de dados. Use listas quando precisar de acesso aleatório múltiplo. Geradores com yield são ideais para sequências complexas. Generator expressions são perfeitas para transformações simples. Seu código será mais eficiente e escalável com geradores.

Comprehensions em Python

22/05/202622/04/2026 Por antonino

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:

# 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 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:

# 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 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:

# 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 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.