Arquivo de Funcional - Página 2 de 5

Decorators em Python

25/04/202622/04/2026 Por antonino

– Python
– Funcional
1 – Funcoes puras
2 – Imutabilidade (tuplas, frozenset, namedtuple)
3 – Funcoes de alta ordem (map, filter, reduce)
4 – Comprehensions (list, dict, set)
5 – Geradores (yield, generator expressions)
6 – Decorators (@)
7 – Closures
8 – Funcoes lambda

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Decorators são funções que modificam o comportamento de outras funções. Eles usam o símbolo @ antes da definição da função. Primeiramente, decorators envolvem uma função para estendê-la. Por exemplo, @timer pode medir o tempo de execução. Além disso, decorators permitem reutilizar código de forma elegante. Assim, você evita repetir a mesma lógica em várias funções. Consequentemente, o código fica mais seco e manutenível. Quando utilizar decorators? Em logging, cache, autenticação e validação. Também para controle de acesso e medição de performance. Por outro lado, evite decorators para lógica muito específica. Python tem decorators nativos como @staticmethod e @property. Então, vamos explorar como criar e usar decorators personalizados. Três subtítulos guiarão você pelo mundo dos decorators. Portanto, ao final, você adicionará poderosas funcionalidades às suas funções.

Criando decorators básicos

Um decorator é uma função que recebe outra função como argumento. Ele retorna uma nova função que substitui a original. Quando usar decorators básicos? Para adicionar comportamento antes/depois. Por exemplo, logging, timing ou autenticação simples. Além disso, sempre preserve os metadados com @wraps. Exemplo de decorators básicos:

import time
from functools import wraps

# Decorator para medir tempo de execução
def timer(func):
    """Mede o tempo de execução da função decorada."""
    @wraps(func)  # Preserva metadados da função original
    def wrapper(*args, **kwargs):
        inicio = time.time()
        resultado = func(*args, **kwargs)
        fim = time.time()
        print(f"{func.__name__} levou {fim - inicio:.4f}s")
        return resultado
    return wrapper

# Decorator para logging
def log(func):
    """Registra chamadas da função."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Chamando {func.__name__} com args={args}, kwargs={kwargs}")
        resultado = func(*args, **kwargs)
        print(f"{func.__name__} retornou {resultado}")
        return resultado
    return wrapper

# Usando os decorators
@timer
@log
def dormir(segundos):
    time.sleep(segundos)
    return f"Dormi por {segundos}s"

print("=== Decorators Básicos ===\n")
resultado = dormir(1)
print(f"Resultado: {resultado}")

# Decorator para repetir execução
def repetir(vezes=3):
    """Repete a execução da função N vezes."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            resultados = []
            for i in range(vezes):
                print(f"Execução {i+1}/{vezes}")
                resultados.append(func(*args, **kwargs))
            return resultados
        return wrapper
    return decorator

@repetir(vezes=2)
def saudacao(nome):
    return f"Olá, {nome}!"

print("\n=== Decorator com Parâmetros ===")
print(saudacao("Ana"))

# Decorator para depuração
def debug(func):
    """Mostra entrada e saída da função."""
    @wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        assinatura = ", ".join(args_repr + kwargs_repr)
        print(f"Chamando {func.__name__}({assinatura})")
        resultado = func(*args, **kwargs)
        print(f"{func.__name__} retornou {resultado!r}")
        return resultado
    return wrapper

@debug
def soma(a, b, multiplicador=1):
    return (a + b) * multiplicador

print("\n=== Decorator de Depuração ===")
soma(3, 5, multiplicador=2)

import time

from functools import wraps

# Decorator para medir tempo de execução

def timer(func):

"""Mede o tempo de execução da função decorada."""

@wraps(func) # Preserva metadados da função original

def wrapper(*args, **kwargs):

inicio = time.time()

resultado = func(*args, **kwargs)

fim = time.time()

print(f"{func.__name__} levou {fim - inicio:.4f}s")

return resultado

return wrapper

# Decorator para logging

def log(func):

"""Registra chamadas da função."""

@wraps(func)

def wrapper(*args, **kwargs):

print(f"Chamando {func.__name__} com args={args}, kwargs={kwargs}")

resultado = func(*args, **kwargs)

print(f"{func.__name__} retornou {resultado}")

return resultado

return wrapper

# Usando os decorators

@timer

@log

def dormir(segundos):

time.sleep(segundos)

return f"Dormi por {segundos}s"

print("=== Decorators Básicos ===\n")

resultado = dormir(1)

print(f"Resultado: {resultado}")

# Decorator para repetir execução

def repetir(vezes=3):

"""Repete a execução da função N vezes."""

def decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

resultados = []

for i in range(vezes):

print(f"Execução {i+1}/{vezes}")

resultados.append(func(*args, **kwargs))

return resultados

return wrapper

return decorator

@repetir(vezes=2)

def saudacao(nome):

return f"Olá, {nome}!"

print("\n=== Decorator com Parâmetros ===")

print(saudacao("Ana"))

# Decorator para depuração

def debug(func):

"""Mostra entrada e saída da função."""

@wraps(func)

def wrapper(*args, **kwargs):

args_repr = [repr(a) for a in args]

kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]

assinatura = ", ".join(args_repr + kwargs_repr)

print(f"Chamando {func.__name__}({assinatura})")

resultado = func(*args, **kwargs)

print(f"{func.__name__} retornou {resultado!r}")

return resultado

return wrapper

@debug

def soma(a, b, multiplicador=1):

return (a + b) * multiplicador

print("\n=== Decorator de Depuração ===")

soma(3, 5, multiplicador=2)

Decorators básicos são simples e extremamente úteis. Eles separam preocupações transversais do código principal. Portanto, use-os para funcionalidades repetitivas.

Decorators com argumentos e parâmetros

Decorators podem receber argumentos para serem configuráveis. A estrutura tem três níveis: decorator, wrapper interna e função. Quando usar decorators com argumentos? Em comportamentos parametrizáveis. Por exemplo, limites de tempo, contagem de tentativas ou níveis de log. Assim, você cria decorators reutilizáveis e flexíveis. Exemplo de decorators com argumentos:

from functools import wraps
import time

# Decorator com argumento (máximo de tentativas)
def retry(max_tentativas=3, delay=1):
    """Tenta executar a função novamente em caso de erro."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for tentativa in range(max_tentativas):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if tentativa == max_tentativas - 1:
                        raise
                    print(f"Tentativa {tentativa+1} falhou: {e}")
                    time.sleep(delay)
            return None
        return wrapper
    return decorator

@retry(max_tentativas=3, delay=0.5)
def funcao_instavel():
    import random
    if random.random() < 0.7:
        raise ValueError("Erro aleatório!")
    return "Sucesso!"

print("=== Decorator com Argumentos (retry) ===")
try:
    print(funcao_instavel())
except ValueError:
    print("Falha após todas as tentativas")

# Decorator para timeout
def timeout(segundos):
    """Cancela a função se exceder o tempo limite."""
    import signal
    
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            def handler(signum, frame):
                raise TimeoutError(f"Função excedeu {segundos}s")
            
            signal.signal(signal.SIGALRM, handler)
            signal.alarm(segundos)
            try:
                resultado = func(*args, **kwargs)
            finally:
                signal.alarm(0)
            return resultado
        return wrapper
    return decorator

@timeout(2)
def operacao_lenta():
    time.sleep(3)
    return "Nunca chegará"

print("\n=== Decorator com Timeout ===")
try:
    print(operacao_lenta())
except TimeoutError as e:
    print(f"Timeout: {e}")

# Decorator para cache (memorização)
def cache(maxsize=128):
    """Cache simples para resultados de funções."""
    def decorator(func):
        cache_dict = {}
        
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Cria chave a partir dos argumentos
            chave = (args, tuple(sorted(kwargs.items())))
            if chave in cache_dict:
                print(f"Cache hit para {func.__name__}{args}")
                return cache_dict[chave]
            
            print(f"Cache miss para {func.__name__}{args}")
            resultado = func(*args, **kwargs)
            
            # Limita tamanho do cache
            if len(cache_dict) >= maxsize:
                cache_dict.pop(next(iter(cache_dict)))
            cache_dict[chave] = resultado
            return resultado
        return wrapper
    return decorator

@cache(maxsize=2)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print("\n=== Decorator com Cache ===")
print(f"fibonacci(10): {fibonacci(10)}")
print(f"fibonacci(10) (segunda vez): {fibonacci(10)}")

100

from functools import wraps

import time

# Decorator com argumento (máximo de tentativas)

def retry(max_tentativas=3, delay=1):

"""Tenta executar a função novamente em caso de erro."""

def decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

for tentativa in range(max_tentativas):

try:

return func(*args, **kwargs)

except Exception as e:

if tentativa == max_tentativas - 1:

raise

print(f"Tentativa {tentativa+1} falhou: {e}")

time.sleep(delay)

return None

return wrapper

return decorator

@retry(max_tentativas=3, delay=0.5)

def funcao_instavel():

import random

if random.random() < 0.7:

raise ValueError("Erro aleatório!")

return "Sucesso!"

print("=== Decorator com Argumentos (retry) ===")

try:

print(funcao_instavel())

except ValueError:

print("Falha após todas as tentativas")

# Decorator para timeout

def timeout(segundos):

"""Cancela a função se exceder o tempo limite."""

import signal

def decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

def handler(signum, frame):

raise TimeoutError(f"Função excedeu {segundos}s")

signal.signal(signal.SIGALRM, handler)

signal.alarm(segundos)

try:

resultado = func(*args, **kwargs)

finally:

signal.alarm(0)

return resultado

return wrapper

return decorator

@timeout(2)

def operacao_lenta():

time.sleep(3)

return "Nunca chegará"

print("\n=== Decorator com Timeout ===")

try:

print(operacao_lenta())

except TimeoutError as e:

print(f"Timeout: {e}")

# Decorator para cache (memorização)

def cache(maxsize=128):

"""Cache simples para resultados de funções."""

def decorator(func):

cache_dict = {}

@wraps(func)

def wrapper(*args, **kwargs):

# Cria chave a partir dos argumentos

chave = (args, tuple(sorted(kwargs.items())))

if chave in cache_dict:

print(f"Cache hit para {func.__name__}{args}")

return cache_dict[chave]

print(f"Cache miss para {func.__name__}{args}")

resultado = func(*args, **kwargs)

# Limita tamanho do cache

if len(cache_dict) >= maxsize:

cache_dict.pop(next(iter(cache_dict)))

cache_dict[chave] = resultado

return resultado

return wrapper

return decorator

@cache(maxsize=2)

def fibonacci(n):

if n < 2:

return n

return fibonacci(n-1) + fibonacci(n-2)

print("\n=== Decorator com Cache ===")

print(f"fibonacci(10): {fibonacci(10)}")

print(f"fibonacci(10) (segunda vez): {fibonacci(10)}")

Decorators com argumentos oferecem grande flexibilidade. Eles permitem configurar o comportamento dinamicamente. Portanto, use-os para criar ferramentas reutilizáveis.

Decorators práticos: autenticação e validação

Decorators são excelentes para validação e controle de acesso. Eles verificam pré-condições antes de executar a função. Quando usar esses decorators? Em APIs, rotas web e sistemas de permissão. Por exemplo, verificar se usuário está logado ou dados são válidos. Além disso, eles centralizam a lógica de segurança. Exemplo de decorators práticos:

from functools import wraps

# Decorator para validação de tipos
def type_check(**tipos):
    """Valida os tipos dos argumentos."""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # Combina args e kwargs
            nomes_args = func.__code__.co_varnames[:len(args)]
            valores = dict(zip(nomes_args, args))
            valores.update(kwargs)
            
            for nome, tipo_esperado in tipos.items():
                if nome in valores:
                    valor = valores[nome]
                    if not isinstance(valor, tipo_esperado):
                        raise TypeError(
                            f"Argumento '{nome}' deve ser {tipo_esperado.__name__}, "
                            f"recebeu {type(valor).__name__}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator

@type_check(a=int, b=int)
def somar_numeros(a, b):
    return a + b

print("=== Decorator de Validação de Tipos ===")
print(f"somar_numeros(5, 3): {somar_numeros(5, 3)}")
try:
    print(somar_numeros(5, "3"))
except TypeError as e:
    print(f"Erro: {e}")

# Decorator para autenticação (simulada)
def requer_login(func):
    """Verifica se o usuário está autenticado."""
    @wraps(func)
    def wrapper(usuario, *args, **kwargs):
        if not usuario.get("autenticado", False):
            raise PermissionError("Usuário não autenticado")
        return func(usuario, *args, **kwargs)
    return wrapper

def requer_permissao(permissao_necessaria):
    """Verifica se o usuário tem uma permissão específica."""
    def decorator(func):
        @wraps(func)
        def wrapper(usuario, *args, **kwargs):
            if not usuario.get("autenticado", False):
                raise PermissionError("Usuário não autenticado")
            if permissao_necessaria not in usuario.get("permissoes", []):
                raise PermissionError(
                    f"Usuário não tem permissão '{permissao_necessaria}'"
                )
            return func(usuario, *args, **kwargs)
        return wrapper
    return decorator

# Usuários de exemplo
usuario_comum = {"nome": "Ana", "autenticado": True, "permissoes": ["ler"]}
usuario_admin = {"nome": "Carlos", "autenticado": True, "permissoes": ["ler", "escrever", "deletar"]}
usuario_nao_auth = {"nome": "João", "autenticado": False}

@requer_login
def perfil(usuario):
    return f"Perfil de {usuario['nome']}"

@requer_permissao("escrever")
def criar_post(usuario, titulo):
    return f"Post '{titulo}' criado por {usuario['nome']}"

print("\n=== Decorator de Autenticação ===")
print(perfil(usuario_comum))
print(criar_post(usuario_admin, "Meu post"))

try:
    print(criar_post(usuario_comum, "Tentativa"))
except PermissionError as e:
    print(f"Erro: {e}")

# Decorator para rate limiting (limite de chamadas)
def rate_limit(max_chamadas, janela_segundos):
    """Limita o número de chamadas por janela de tempo."""
    def decorator(func):
        chamadas = []
        
        @wraps(func)
        def wrapper(*args, **kwargs):
            agora = time.time()
            # Remove chamadas antigas
            while chamadas and chamadas[0] < agora - janela_segundos:
                chamadas.pop(0)
            
            if len(chamadas) >= max_chamadas:
                raise RuntimeError(
                    f"Limite de {max_chamadas} chamadas em {janela_segundos}s excedido"
                )
            
            chamadas.append(agora)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(max_chamadas=3, janela_segundos=5)
def api_request(url):
    return f"Requisição para {url}"

print("\n=== Decorator de Rate Limit ===")
for i in range(5):
    try:
        print(api_request(f"url_{i}"))
    except RuntimeError as e:
        print(f"Erro: {e}")
    time.sleep(1)

# Empilhando múltiplos decorators
@timer
@log
@retry(max_tentativas=2, delay=0.1)
def operacao_critica():
    import random
    if random.random() < 0.5:
        raise ValueError("Falha aleatória")
    return "Operação bem-sucedida!"

print("\n=== Múltiplos Decorators ===")
try:
    resultado = operacao_critica()
    print(f"Resultado: {resultado}")
except ValueError:
    print("Operação falhou após tentativas")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

from functools import wraps

# Decorator para validação de tipos

def type_check(**tipos):

"""Valida os tipos dos argumentos."""

def decorator(func):

@wraps(func)

def wrapper(*args, **kwargs):

# Combina args e kwargs

nomes_args = func.__code__.co_varnames[:len(args)]

valores = dict(zip(nomes_args, args))

valores.update(kwargs)

for nome, tipo_esperado in tipos.items():

if nome in valores:

valor = valores[nome]

if not isinstance(valor, tipo_esperado):

raise TypeError(

f"Argumento '{nome}' deve ser {tipo_esperado.__name__}, "

f"recebeu {type(valor).__name__}"

)

return func(*args, **kwargs)

return wrapper

return decorator

@type_check(a=int, b=int)

def somar_numeros(a, b):

return a + b

print("=== Decorator de Validação de Tipos ===")

print(f"somar_numeros(5, 3): {somar_numeros(5, 3)}")

try:

print(somar_numeros(5, "3"))

except TypeError as e:

print(f"Erro: {e}")

# Decorator para autenticação (simulada)

def requer_login(func):

"""Verifica se o usuário está autenticado."""

@wraps(func)

def wrapper(usuario, *args, **kwargs):

if not usuario.get("autenticado", False):

raise PermissionError("Usuário não autenticado")

return func(usuario, *args, **kwargs)

return wrapper

def requer_permissao(permissao_necessaria):

"""Verifica se o usuário tem uma permissão específica."""

def decorator(func):

@wraps(func)

def wrapper(usuario, *args, **kwargs):

if not usuario.get("autenticado", False):

raise PermissionError("Usuário não autenticado")

if permissao_necessaria not in usuario.get("permissoes", []):

raise PermissionError(

f"Usuário não tem permissão '{permissao_necessaria}'"

)

return func(usuario, *args, **kwargs)

return wrapper

return decorator

# Usuários de exemplo

usuario_comum = {"nome": "Ana", "autenticado": True, "permissoes": ["ler"]}

usuario_admin = {"nome": "Carlos", "autenticado": True, "permissoes": ["ler", "escrever", "deletar"]}

usuario_nao_auth = {"nome": "João", "autenticado": False}

@requer_login

def perfil(usuario):

return f"Perfil de {usuario['nome']}"

@requer_permissao("escrever")

def criar_post(usuario, titulo):

return f"Post '{titulo}' criado por {usuario['nome']}"

print("\n=== Decorator de Autenticação ===")

print(perfil(usuario_comum))

print(criar_post(usuario_admin, "Meu post"))

try:

print(criar_post(usuario_comum, "Tentativa"))

except PermissionError as e:

print(f"Erro: {e}")

# Decorator para rate limiting (limite de chamadas)

def rate_limit(max_chamadas, janela_segundos):

"""Limita o número de chamadas por janela de tempo."""

def decorator(func):

chamadas = []

@wraps(func)

def wrapper(*args, **kwargs):

agora = time.time()

# Remove chamadas antigas

while chamadas and chamadas[0] < agora - janela_segundos:

chamadas.pop(0)

if len(chamadas) >= max_chamadas:

raise RuntimeError(

f"Limite de {max_chamadas} chamadas em {janela_segundos}s excedido"

)

chamadas.append(agora)

return func(*args, **kwargs)

return wrapper

return decorator

@rate_limit(max_chamadas=3, janela_segundos=5)

def api_request(url):

return f"Requisição para {url}"

print("\n=== Decorator de Rate Limit ===")

for i in range(5):

try:

print(api_request(f"url_{i}"))

except RuntimeError as e:

print(f"Erro: {e}")

time.sleep(1)

# Empilhando múltiplos decorators

@timer

@log

@retry(max_tentativas=2, delay=0.1)

def operacao_critica():

import random

if random.random() < 0.5:

raise ValueError("Falha aleatória")

return "Operação bem-sucedida!"

print("\n=== Múltiplos Decorators ===")

try:

resultado = operacao_critica()

print(f"Resultado: {resultado}")

except ValueError:

print("Operação falhou após tentativas")

Decorators são ferramentas essenciais no dia a dia do Python. A fórmula de um decorator pode ser expressa assim: \(D(f) = \text{wrapper} \quad \text{onde} \quad \text{wrapper} \approx \text{antes} + f + \text{depois}\) Use decorators para separar preocupações transversais. Seu código será mais limpo, modular e reutilizável. Portanto, comece com decorators simples e avance para os mais complexos. Finalmente, pratique criando seus próprios decorators.

Geradores em Python

25/04/202622/04/2026 Por antonino

– Python
– Funcional
1 – Funcoes puras
2 – Imutabilidade (tuplas, frozenset, namedtuple)
3 – Funcoes de alta ordem (map, filter, reduce)
4 – Comprehensions (list, dict, set)
5 – Geradores (yield, generator expressions)
6 – Decorators (@)
7 – Closures
8 – Funcoes lambda

LEGENDA

Nivel_1

Nivel_2

Nivel_3

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.