Arquivo de Orientada a Aspectos

Monkey Patching

25/04/202623/04/2026 Por antonino

– Python
– Orientada a Aspectos (AOP)
1 – Decorators para logging, cache, autenticação
2 – Monkey patching
3 – Descriptors (__get__, __set__)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Monkey patching é a técnica de modificar código dinamicamente. Você altera ou adiciona métodos a classes ou módulos existentes. Isso acontece em tempo de execução, sem tocar no código fonte original. Primeiro, entenda que é uma ferramenta poderosa. Segundo, use com cautela para evitar efeitos colaterais. Essa técnica é comum em testes automatizados e hotfixes. Além disso, frameworks como gevent e mock a utilizam. Por exemplo, você pode substituir uma função de rede por uma simulada. Assim, testes rodam sem chamar serviços externos. Portanto, monkey patching resolve problemas urgentes e específicos.

Características fundamentais do monkey patching

Uma característica central é a modificação em tempo real. Nenhuma reinicialização do programa é necessária. Outra propriedade importante é o escopo global ou local. Uma vez alterado, o comportamento muda para todo o sistema. Isso pode gerar confusão se outros módulos dependerem do original. Frequentemente, essa técnica é usada para corrigir bugs em bibliotecas. Quando a biblioteca não é sua, monkey patching é uma saída. Porém, patches mal feitos causam erros imprevisíveis. Por essa razão, muitos desenvolvedores recomendam evitar o uso. Alternativas como herança ou injeção de dependência são mais seguras. Em testes, o monkey patching é amplamente aceito. Afinal, você controla completamente o ambiente.

Uma representação conceitual simples é:

\(\text{obj.metodo}_{\text{original}} \rightarrow \text{obj.metodo}_{\text{patch}}\)

Isso significa que uma referência é substituída pela nova. Assim, o sistema chama a versão alterada sem saber. Esse comportamento foi projetado pela flexibilidade do Python. Portanto, você precisa documentar bem qualquer patch aplicado. Caso contrário, a manutenção se torna um pesadelo.

Quando utilizar monkey patching (e quando evitar)

Use monkey patching em testes unitários com frequência. Por exemplo, para simular APIs externas ou bancos de dados. Ele também ajuda a corrigir bugs urgentes em produção. Quando uma biblioteca tem um erro crítico, você pode contornar. Monkey patching é útil para logging temporário e debugging. Você pode adicionar prints sem alterar o código original. Além disso, em ambientes de pesquisa, ele acelera experimentos. Por outro lado, evite monkey patching em código compartilhado. A equipe ficará confusa com comportamentos inesperados. Também não use para modificar classes centrais como str ou list. Isso quebra outros códigos que confiam no comportamento padrão. Portanto, limite o patch a módulos que você controla.

Primeiro, pergunte-se: existe uma alternativa mais clara? Se a resposta for sim, prefira herança ou composição. Segundo, avalie o impacto em outras partes do sistema. Monkey patching é uma solução elegante apenas em situações específicas. Por exemplo, mock em testes é perfeitamente aceitável. Outro caso é adicionar um método a uma classe de terceiros. Desde que você documente, não há grandes problemas. Então, use com responsabilidade e moderação. Código claro e previsível é sempre melhor.

Exemplo prático: corrigindo uma função problemática

O código abaixo demonstra monkey patching em ação. Suponha que uma biblioteca externa tenha um método lento. Nós vamos substituí-lo por uma versão mais rápida. Primeiro, criamos uma classe Calculadora com erro. O método dividir não trata divisão por zero. Em vez de alterar a classe original, aplicamos um patch. Substituímos o método por uma versão segura em tempo real. Além disso, mostramos como adicionar um novo método. Esse novo método não existia na classe original. Finalmente, restauramos o método original para demonstrar. Perceba como o comportamento muda dinamicamente. Isso ilustra o poder e o risco da técnica.

import sys
from datetime import datetime

# Classe original de uma biblioteca hipotética
class Calculadora:
    """Calculadora com um método problemático."""
    
    def dividir(self, a, b):
        """Método original que não trata divisão por zero."""
        # Simula um problema: retorna None em vez de erro
        if b == 0:
            return None  # Comportamento indesejado!
        return a / b
    
    def multiplicar(self, a, b):
        return a * b


# Função de patch (substituto)
def dividir_seguro(self, a, b):
    """Versão melhorada que levanta exceção."""
    if b == 0:
        raise ValueError("Divisão por zero não é permitida")
    return a / b


# Demonstração do monkey patching
print("=== Comportamento original ===")
calc = Calculadora()
print(f"10 / 2 = {calc.dividir(10, 2)}")  # 5.0
print(f"5 / 0 = {calc.dividir(5, 0)}")    # None (comportamento ruim!)

print("\n=== Aplicando monkey patch ===")
# Substitui o método problemático
Calculadora.dividir = dividir_seguro
print("Método 'dividir' foi substituído!")

try:
    resultado = calc.dividir(5, 0)
    print(f"5 / 0 = {resultado}")  # Não chegará aqui
except ValueError as e:
    print(f"Erro capturado: {e}")

# Agora o método funciona corretamente
print(f"10 / 2 = {calc.dividir(10, 2)}")  # 5.0

print("\n=== Adicionando um novo método ===")
# Monkey patching também pode adicionar métodos novos
def potencia(self, a, b):
    """Calcula a potência (a elevado a b)."""
    return a ** b

Calculadora.potencia = potencia
print(f"2 ** 10 = {calc.potencia(2, 10)}")  # 1024

# O método multiplicar permanece inalterado
print(f"3 * 7 = {calc.multiplicar(3, 7)}")  # 21

print("\n=== Injetando logging em método existente ===")
# Exemplo: adicionar logging sem alterar código original
original_multiplicar = Calculadora.multiplicar

def multiplicar_com_log(self, a, b):
    print(f"[{datetime.now()}] Multiplicando {a} * {b}")
    resultado = original_multiplicar(self, a, b)
    print(f"[{datetime.now()}] Resultado: {resultado}")
    return resultado

# Aplica o patch com logging
Calculadora.multiplicar = multiplicar_com_log

print("Testando método com logging:")
calc.multiplicar(4, 5)

print("\n=== Restaurando comportamento original ===")
# É possível restaurar se você guardou a referência
Calculadora.dividir = Calculadora.__dict__.get('_dividir_original', None)
if not hasattr(Calculadora, 'dividir') or Calculadora.dividir is None:
    # Na prática, guarde a referência antes de patch
    print("A referência original foi perdida. Isso é um risco!")
    
# Uma forma segura de restaurar (se guardou antes)
class CalculadoraOriginal:
    def dividir(self, a, b):
        if b == 0:
            return None
        return a / b

print("\n=== Cuidados importantes ===")
print("1. Monkey patching afeta todas as instâncias existentes.")
print("2. É difícil rastrear onde o patch foi aplicado.")
print("3. Use apenas quando absolutamente necessário.")

import sys

from datetime import datetime

# Classe original de uma biblioteca hipotética

class Calculadora:

"""Calculadora com um método problemático."""

def dividir(self, a, b):

"""Método original que não trata divisão por zero."""

# Simula um problema: retorna None em vez de erro

if b == 0:

return None # Comportamento indesejado!

return a / b

def multiplicar(self, a, b):

return a * b

# Função de patch (substituto)

def dividir_seguro(self, a, b):

"""Versão melhorada que levanta exceção."""

if b == 0:

raise ValueError("Divisão por zero não é permitida")

return a / b

# Demonstração do monkey patching

print("=== Comportamento original ===")

calc = Calculadora()

print(f"10 / 2 = {calc.dividir(10, 2)}") # 5.0

print(f"5 / 0 = {calc.dividir(5, 0)}") # None (comportamento ruim!)

print("\n=== Aplicando monkey patch ===")

# Substitui o método problemático

Calculadora.dividir = dividir_seguro

print("Método 'dividir' foi substituído!")

try:

resultado = calc.dividir(5, 0)

print(f"5 / 0 = {resultado}") # Não chegará aqui

except ValueError as e:

print(f"Erro capturado: {e}")

# Agora o método funciona corretamente

print(f"10 / 2 = {calc.dividir(10, 2)}") # 5.0

print("\n=== Adicionando um novo método ===")

# Monkey patching também pode adicionar métodos novos

def potencia(self, a, b):

"""Calcula a potência (a elevado a b)."""

return a ** b

Calculadora.potencia = potencia

print(f"2 ** 10 = {calc.potencia(2, 10)}") # 1024

# O método multiplicar permanece inalterado

print(f"3 * 7 = {calc.multiplicar(3, 7)}") # 21

print("\n=== Injetando logging em método existente ===")

# Exemplo: adicionar logging sem alterar código original

original_multiplicar = Calculadora.multiplicar

def multiplicar_com_log(self, a, b):

print(f"[{datetime.now()}] Multiplicando {a} * {b}")

resultado = original_multiplicar(self, a, b)

print(f"[{datetime.now()}] Resultado: {resultado}")

return resultado

# Aplica o patch com logging

Calculadora.multiplicar = multiplicar_com_log

print("Testando método com logging:")

calc.multiplicar(4, 5)

print("\n=== Restaurando comportamento original ===")

# É possível restaurar se você guardou a referência

Calculadora.dividir = Calculadora.__dict__.get('_dividir_original', None)

if not hasattr(Calculadora, 'dividir') or Calculadora.dividir is None:

# Na prática, guarde a referência antes de patch

print("A referência original foi perdida. Isso é um risco!")

# Uma forma segura de restaurar (se guardou antes)

class CalculadoraOriginal:

def dividir(self, a, b):

if b == 0:

return None

return a / b

print("\n=== Cuidados importantes ===")

print("1. Monkey patching afeta todas as instâncias existentes.")

print("2. É difícil rastrear onde o patch foi aplicado.")

print("3. Use apenas quando absolutamente necessário.")

No exemplo, a classe Calculadora original tinha um bug. Ela retornava None para divisão por zero. Nós substituímos o método por uma versão segura. Todas as instâncias existentes foram afetadas imediatamente. Isso é útil para corrigir problemas em produção. Porém, um patch mal feito pode piorar a situação. Além disso, adicionamos um novo método completamente novo. A biblioteca original nunca teve esse método. A restauração do método original é possível com referência guardada. Sem cuidado, você pode perder a funcionalidade original. Portanto, sempre documente e teste seus patches. Em testes unitários, use unittest.mock.patch para segurança.

Outro ponto crucial é o escopo do patch. Ele permanece ativo enquanto o programa rodar. Isso pode causar comportamentos estranhos em threads diferentes. Uma boa prática é aplicar patches temporários e restaurá-los. Ou então, use contextos como mock.patch para isolamento. Assim, você evita vazamento de patches para outros testes. Finalmente, lembre-se: código legível é melhor que código esperto. Monkey patching é uma ferramenta de último caso. Use com moderação e sempre com documentação clara. Dessa forma, você mantém a sanidade da equipe. E também evita bugs noturnos inexplicáveis. Portanto, prefira soluções convencionais sempre que possível.

⚠️ Atenção: Monkey patching em produção pode ser perigoso. Sempre tenha um plano de reversão e testes abrangentes. Ferramentas como unittest.mock oferecem patches temporários seguros.

Descriptors em Python

25/04/202623/04/2026 Por antonino

– Python
– Orientada a Aspectos (AOP)
1 – Decorators para logging, cache, autenticação
2 – Monkey patching
3 – Descriptors (__get__, __set__)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

Descriptors são um protocolo poderoso da linguagem Python. Eles permitem personalizar o acesso a atributos de classes. Basicamente, um descriptor implementa métodos como __get__ e __set__. Quando você acessa um atributo, o Python chama esses métodos automaticamente. Isso foi projetado para reutilizar lógica de validação ou conversão. Por exemplo, você pode criar um descriptor que valida idades. Assim, evita repetir o mesmo código em vários lugares. Além disso, descriptors são a base de properties e @property. Portanto, entender eles eleva seu domínio sobre Python.

O protocolo descriptor: métodos especiais

Três métodos principais compõem o protocolo descriptor. __get__(self, instance, owner) recupera o valor do atributo. __set__(self, instance, value) define ou altera o valor. __delete__(self, instance) remove o atributo quando necessário. Cada método recebe a instância da classe dona. Assim, o descriptor sabe qual objeto está sendo manipulado. Somente a implementação de __get__ já qualifica um descriptor como não-dados. Adicione __set__ ou __delete__ e ele se torna um descriptor de dados. Essa distinção influencia a precedência na busca de atributos. Por essa razão, descriptors de dados são mais prioritários.

Uma representação simples do fluxo é:

\(\text{obj.atributo} \rightarrow \text{descriptor.__get__}(\text{obj}, \text{type(obj)})\)

Isso significa que o Python intercepta o acesso. Então, ele delega a responsabilidade ao descriptor. Portanto, você controla exatamente o que acontece. Sem descriptors, cada atributo exigiria getters e setters manuais. Com eles, a reutilização se torna muito mais fácil.

Quando utilizar descriptors no seu código

Use descriptors para validar dados repetidamente em várias classes. Por exemplo, campos de formulários ou modelos de banco de dados. Eles também resolvem problemas de conversão de tipos. Um caso clássico é garantir que uma temperatura esteja em Celsius. Outro exemplo é converter automaticamente moedas em valores numéricos. Além disso, descriptors servem para implementar lazy loading. Isso significa carregar um recurso pesado apenas quando acessado. Frameworks ORM como SQLAlchemy usam descriptors intensamente. Então, você encontra esse padrão em código profissional. Evite descriptors para lógica muito simples ou pontual. Nesses casos, um property comum já resolve bem.

Primeiro, identifique atributos que compartilham a mesma regra. Depois, crie um descriptor único que encapsule essa regra. Assim, você aplica a mesma validação em várias classes. Por exemplo, campos de email com formato específico. Ou campos de CPF que precisam de dígitos verificadores. O descriptor centraliza a lógica e facilita futuras mudanças. Consequentemente, o código fica mais seco e testável. Portanto, descriptors são ferramentas para abstração reutilizável.

Exemplo prático: validação de idade com descriptor

O código abaixo mostra um descriptor completo com __get__ e __set__. Ele valida que a idade seja um número entre 0 e 150. Além disso, armazena o valor em um dicionário interno. Isso evita conflitos com o dicionário __dict__ da instância. Duas classes diferentes usam o mesmo descriptor. Perceba como a lógica de validação não se repete. Esse padrão é útil em sistemas de cadastro. Por exemplo, pessoas, funcionários ou usuários. Teste você mesmo o comportamento no seu ambiente. Observe que tentar definir idade negativa levanta uma exceção. Isso protege a integridade dos seus dados. Assim, você ganha robustez sem esforço repetitivo.

class IdadeDescriptor:
    """Descriptor que valida idade entre 0 e 150."""
    
    def __init__(self, nome_armazenado="idade"):
        self.nome_armazenado = nome_armazenado
    
    def __get__(self, instance, owner=None):
        if instance is None:
            return self  # Acesso pela classe
        # Recupera o valor salvo no dicionário da instância
        return instance.__dict__.get(self.nome_armazenado, None)
    
    def __set__(self, instance, value):
        if not isinstance(value, int):
            raise TypeError(f"Idade deve ser inteiro, recebido {type(value).__name__}")
        if value < 0 or value > 150:
            raise ValueError(f"Idade inválida: {value}. Deve estar entre 0 e 150.")
        # Armazena o valor validado
        instance.__dict__[self.nome_armazenado] = value
    
    def __delete__(self, instance):
        raise AttributeError("Não é permitido deletar a idade")


class Pessoa:
    idade = IdadeDescriptor()  # Aplicando o descriptor
    
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade  # Aqui chama __set__ do descriptor
    
    def __repr__(self):
        return f"Pessoa(nome='{self.nome}', idade={self.idade})"


class Funcionario:
    idade = IdadeDescriptor()  # Reutilizando o mesmo descriptor
    
    def __init__(self, nome, cargo, idade):
        self.nome = nome
        self.cargo = cargo
        self.idade = idade
    
    def __repr__(self):
        return f"Funcionario({self.nome}, {self.cargo}, {self.idade}) anos"


# Testando o comportamento
print("=== Testando Pessoa ===")
p1 = Pessoa("Ana", 30)
print(p1)              # Pessoa(nome='Ana', idade=30)
p1.idade = 35
print(f"Idade atualizada: {p1.idade}")

try:
    p2 = Pessoa("Bob", -5)  # Isso levantará exceção
except ValueError as e:
    print(f"Erro capturado: {e}")

try:
    p1.idade = 200
except ValueError as e:
    print(f"Erro capturado: {e}")

print("\n=== Testando Funcionario ===")
f1 = Funcionario("Carlos", "Analista", 28)
print(f1)
f1.idade = 29
print(f"Funcionario com idade {f1.idade} anos")

try:
    f1.idade = "trinta"
except TypeError as e:
    print(f"Erro capturado: {e}")

# Acesso pela classe retorna o próprio descriptor
print(f"\nDescriptor na classe: {Pessoa.idade}")
print(f"Tipo do descriptor: {type(Pessoa.idade).__name__}")

class IdadeDescriptor:

"""Descriptor que valida idade entre 0 e 150."""

def __init__(self, nome_armazenado="idade"):

self.nome_armazenado = nome_armazenado

def __get__(self, instance, owner=None):

if instance is None:

return self # Acesso pela classe

# Recupera o valor salvo no dicionário da instância

return instance.__dict__.get(self.nome_armazenado, None)

def __set__(self, instance, value):

if not isinstance(value, int):

raise TypeError(f"Idade deve ser inteiro, recebido {type(value).__name__}")

if value < 0 or value > 150:

raise ValueError(f"Idade inválida: {value}. Deve estar entre 0 e 150.")

# Armazena o valor validado

instance.__dict__[self.nome_armazenado] = value

def __delete__(self, instance):

raise AttributeError("Não é permitido deletar a idade")

class Pessoa:

idade = IdadeDescriptor() # Aplicando o descriptor

def __init__(self, nome, idade):

self.nome = nome

self.idade = idade # Aqui chama __set__ do descriptor

def __repr__(self):

return f"Pessoa(nome='{self.nome}', idade={self.idade})"

class Funcionario:

idade = IdadeDescriptor() # Reutilizando o mesmo descriptor

def __init__(self, nome, cargo, idade):

self.nome = nome

self.cargo = cargo

self.idade = idade

def __repr__(self):

return f"Funcionario({self.nome}, {self.cargo}, {self.idade}) anos"

# Testando o comportamento

print("=== Testando Pessoa ===")

p1 = Pessoa("Ana", 30)

print(p1) # Pessoa(nome='Ana', idade=30)

p1.idade = 35

print(f"Idade atualizada: {p1.idade}")

try:

p2 = Pessoa("Bob", -5) # Isso levantará exceção

except ValueError as e:

print(f"Erro capturado: {e}")

try:

p1.idade = 200

except ValueError as e:

print(f"Erro capturado: {e}")

print("\n=== Testando Funcionario ===")

f1 = Funcionario("Carlos", "Analista", 28)

print(f1)

f1.idade = 29

print(f"Funcionario com idade {f1.idade} anos")

try:

f1.idade = "trinta"

except TypeError as e:

print(f"Erro capturado: {e}")

# Acesso pela classe retorna o próprio descriptor

print(f"\nDescriptor na classe: {Pessoa.idade}")

print(f"Tipo do descriptor: {type(Pessoa.idade).__name__}")

No exemplo, a classe IdadeDescriptor controla totalmente o atributo. Cada instância de Pessoa ou Funcionario herda essa validação. O método __get__ retorna o valor armazenado em instance.__dict__. O método __set__ valida o tipo e a faixa antes de guardar. Foi usado um dicionário interno para evitar conflitos de nomes. Além disso, a implementação respeita o princípio de encapsulamento. Assim, você não precisa escrever getters e setters manualmente. Descriptors também funcionam com herança normalmente. Portanto, eles se integram bem ao modelo de classes Python. Primeiro, comece com propriedades simples. Depois, evolua para descriptors quando a repetição aparecer. Isso torna seu código mais limpo e profissional.

Outro benefício importante é a documentação implícita. Um descriptor bem nomeado comunica sua intenção claramente. Por exemplo, IdadeDescriptor já sugere validação. Assim, outros desenvolvedores entendem o comportamento rapidamente. Além disso, você pode estender descriptors para logging automático. Ou para rastrear mudanças de valores (observadores). A flexibilidade é enorme quando você domina esse padrão. Finalmente, recomendo estudar a implementação do @property. Ela é um caso especial de descriptor embutido no Python. Com esse conhecimento, você escreve APIs mais expressivas. Portanto, explore descriptors em seus próximos projetos.