Padrões de projeto em Python

Padrão de projeto Decorator em Python

Nesta lição, você vai usar o padrão Decorator para adicionar funcionalidades a um objeto sem alterar a sua classe.

  • Avançado
  • 3 min de leitura
  • 1 exemplo executável

Introdução

O problema

Você quer acrescentar um comportamento a um objeto, como log, formatação ou cache, sem mudar a classe dele e sem criar uma subclasse para cada combinação de extras.

Pense assim

O padrão Decorator é como embrulhar um presente. O presente continua o mesmo; cada camada de embrulho acrescenta algo, como papel, depois uma fita, depois um cartão. Você pode pôr as camadas em qualquer ordem, e o resultado ainda é um presente entregue do mesmo jeito.

Do embrulho de presente para o código
Message()🎁 O presente original
Uppercase(...)🧻 Uma camada que muda a aparência
Logger(...)🎀 Outra camada por cima
.render()🤲 Entregue do mesmo jeito: LOG: HELLO
Cada embrulho oferece o mesmo método e acrescenta o seu comportamento.
Em uma frase

O padrão Decorator envolve um objeto em outro objeto com a mesma interface, que chama o objeto envolvido e acrescenta comportamento antes ou depois.

Pontos-chave

  1. Message.render() devolve "hello".
  2. Uppercase guarda o objeto envolvido e devolve o resultado dele em letras maiúsculas.
  3. Logger coloca "LOG: " na frente do resultado do objeto envolvido.
  4. Logger(Uppercase(Message())).render() empilha os dois embrulhos e dá "LOG: HELLO".

Quando usar?

  • Acrescentar log, cache, validação ou formatação em volta de objetos existentes.
  • Combinar extras opcionais sem uma subclasse para cada combinação.
  • Entender a sintaxe @decorator do Python, que aplica a mesma ideia a funções.

Quando não é preciso

  • Só é preciso um comportamento extra fixo: mude a classe ou adicione um método.
  • Muitas camadas que dependem da ordem umas das outras: a pilha fica difícil de entender.

Código de exemplo

Executar código →
main.py
class Message:
    # Decorator: wrap an object to add behavior dynamically.
    def render(self): return "hello"


class Uppercase:
    def __init__(self, wrapped): self.wrapped = wrapped
    def render(self): return self.wrapped.render().upper()


class Logger:
    def __init__(self, wrapped): self.wrapped = wrapped

    def render(self):
        # Add behavior while preserving the render interface.
        return "LOG: " + self.wrapped.render()


print(Logger(Uppercase(Message())).render())
Gerar um botão Run para este exemplo

Resultado da execução

LOG: HELLO

Explicação do código

Uppercase envolve o objeto Message e converte o resultado para maiúsculas, e depois Logger envolve Uppercase e adiciona o prefixo LOG:. As três classes têm o método render(), então podem se envolver em qualquer ordem. O resultado final é LOG: HELLO.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Tente modificar o código seguindo as sugestões abaixo. Mudar o código e observar o resultado ajuda você a entender muito mais do que só ler.

  1. Substitua o domínio do exemplo preservando a estrutura do padrão.
  2. Compare o padrão com uma implementação mais simples e explique as diferenças.
  3. Escreva testes para cada participante antes de adicionar outra implementação.
Executar no compilador Python →

Erros comuns

Quebrar a interface comum

Um embrulho com outro nome de método não pode ser embrulhado de novo nem usado no lugar do original.

Problema
class Uppercase:
    def show(self): ...
Correção
class Uppercase:
    def render(self): ...

Terminou esta lição?

Marque como aprendida para acompanhar seu progresso.

Pratique com um desafio

Use o conteúdo desta lição para resolver um problema real. Cada desafio roda no navegador, com testes instantâneos e uma revisão por IA.

Todos os desafios