Decoradores Python são ferramentas poderosas que nos permitem modificar ou aprimorar o comportamento de funções ou métodos. Os casos de uso comuns incluem registro em log, autorização e muito mais.
No entanto, quando solicitados a definir um decorador, muitos podem dizer:

É um wrapper para uma função.

Embora isso seja tecnicamente correto, há muito mais acontecendo nos bastidores.

Dissecando um decorador simples
Vamos explorar um exemplo simples:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before calling the function")
        result = func(*args, **kwargs)
        print("After calling the function")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

Aqui, my_decorator é um decorador para a função say_hello. Quando say_hello é definido, ele é automaticamente passado para my_decorator, transformando a chamada da função em:
diga_olá = meu_decorador(diga_olá)

Quando essa transformação acontece?
Essa transformação ocorre durante a compilação do código, especificamente no momento da definição da função – não no tempo de execução.

Desmontando o Código
Para entender como os decoradores funcionam em um nível inferior, podemos usar o módulo dis para examinar o bytecode da função decorada:

import dis

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

dis.dis(say_hello)

Detalhamento de bytecode

A saída de dis.dis(say_hello) pode ser assim:

Explicação do Bytecode

1. Antes de chamar a função

   • LOAD_GLOBAL: Carrega a função de impressão.
   • LOAD_CONST: Carrega a mensagem 'Antes de chamar a função'.
   • CALL_FUNCTION: Chamadas impressas.
   • POP_TOP: Descarta o valor de retorno.

2. Chamando a função original

   • LOAD_DEREF: Carrega a função original (func) capturada pelo encerramento.
   • LOAD_FAST: carrega os argumentos posicionais e de palavra-chave.
   • BUILD_MAP: Cria um novo dicionário para argumentos de palavras-chave.
   • CALL_FUNCTION_EX: Chama a função original com os argumentos.
   • STORE_FAST: Armazena o resultado em uma variável local.

3. Depois de chamar a função

   • Semelhante à primeira parte, ele chama print para gerar 'Depois de chamar a função'.
   • Retornando o resultado
   • Carrega a variável de resultado e a retorna.

Conclusão
Os decoradores Python são mais do que apenas wrappers de funções; eles nos permitem modificar o comportamento da função no momento da definição. Ao entender como eles funcionam e examinar o bytecode, podemos usar decoradores de forma mais eficaz em nossos projetos.

Por enquanto é isso! Se houver mais alguma coisa que você gostaria que eu abordasse, é só me avisar!