Introdução ao uso de decorator

Um decorator é um recurso poderoso do Python que permite modificar o comportamento de funções ou métodos. Ele costuma ser usado para adicionar funcionalidades a funções sem modificar seu código.

Nesta lição, você aprenderá o que são decorators, como usá-los e como criar seus próprios decorators.

O que é um decorator?

Um decorator é uma função que recebe outra função como entrada e retorna uma nova função com funcionalidade adicional. Ele é frequentemente usado com a sintaxe @decorator_name.

# Basic example of a decorator
def decorator(func):
    def wrapper():
        print("Before the function call")
        func()
        print("After the function call")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

Como funciona um decorator

Ao usar um decorator, o Python substitui a função original pela função wrapper retornada pelo decorator.

# How decorators work
def decorator(func):
    def wrapper():
        print("Wrapper called")
        func()
    return wrapper

@decorator
def greet():
    print("Greetings!")

print(greet.__name__)  # Outputs: wrapper
greet()

Usando um decorator com argumentos

Um decorator pode trabalhar com funções que recebem argumentos usando *args e **kwargs na função wrapper:

# Decorator for functions with arguments
def decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Arguments: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@decorator
def add(a, b):
    return a + b

print(add(3, 5))

Encadeando vários decoradores

Você pode usar vários decoradores em uma única função. Eles são aplicados na ordem em que aparecem, de cima para baixo:

# Chaining multiple decorators
def decorator1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@decorator1
@decorator2
def greet():
    print("Hello!")

greet()

Criando decoradores parametrizados

Os decoradores parametrizados recebem argumentos e permitem uma funcionalidade mais flexível:

# Parameterized decorator
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

Casos de uso comuns de decoradores

Os decoradores são usados com frequência para:

• Registrar chamadas de funções e seus argumentos.
• Medir o tempo de execução das funções.
• Controlar o acesso (por exemplo, verificando as permissões dos usuários).
• Armazenar resultados temporariamente para melhorar o desempenho.

Decoradores integrados no Python

O Python fornece alguns decoradores integrados, incluindo:

• @staticmethod: define um método estático.
• @classmethod: define um método de classe.
• @property: define um método de propriedade.

Erros comuns com decoradores

Veja alguns erros que você deve evitar:

• Não preservar o nome e a string de documentação da função original (use functools.wraps).
• Usar decoradores desnecessariamente em tarefas simples.
• Esquecer de lidar com os argumentos na função de encapsulamento.

O que aprendemos?

Nesta lição, você aprendeu:

• O que são decoradores e como eles funcionam no Python.
• Como criar e usar decoradores básicos, parametrizados e encadeados.
• Casos de uso comuns e decoradores integrados no Python.

Muito bem! Vamos passar ao próximo tópico.