Introdução aos decoradores

Decoradores são um recurso poderoso do Python que permite modificar o comportamento de funções ou métodos. Eles costumam ser usados para adicionar funcionalidades a funções sem modificar o código delas.

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

O que é um decorator?

Um decorator é uma função que recebe outra função como entrada e retorna uma nova função com funcionalidades adicionais. Ele costuma ser 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 os decoradores funcionam

Quando você usa um decorator, o Python substitui a função original pela função envoltória 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 decoradores com argumentos

Os decoradores podem funcionar com funções que recebem argumentos usando *args e **kwargs na função envoltória:

# 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 para 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 do usuário.
• Armazenar resultados em cache 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

Aqui estão alguns erros que você deve evitar:

• Não preservar o nome e a docstring da função original (use functools.wraps).
• Usar decoradores desnecessariamente para tarefas simples.
• Esquecer de tratar os argumentos na função envoltória.

O que aprendemos?

Nesta lição, você aprendeu:

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

Parabéns! Vamos para o próximo tópico.