Introduzione ai decoratori

I decoratori sono una potente funzionalità di Python che consente di modificare il comportamento di funzioni o metodi. Vengono spesso usati per aggiungere funzionalità alle funzioni senza modificarne il codice.

In questa lezione apprenderà che cosa sono i decoratori, come usarli e come crearne di propri.

Che cos'è un decoratore?

Un decoratore è una funzione che accetta un'altra funzione come input e restituisce una nuova funzione con funzionalità aggiuntive. Viene spesso usato con la sintassi @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()

Come funzionano i decoratori

Quando usa un decoratore, Python sostituisce la funzione originale con la funzione wrapper restituita dal decoratore.

# 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()

Utilizzo dei decoratori con argomenti

I decoratori possono funzionare con funzioni che accettano argomenti usando *args e **kwargs nella funzione 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))

Concatenazione di più decoratori

È possibile usare più decoratori su una singola funzione. Vengono applicati nell'ordine in cui compaiono, dall'alto verso il basso:

# 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()

Creazione di decoratori parametrizzati

I decoratori parametrizzati accettano argomenti e consentono di ottenere funzionalità più flessibili:

# 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()

Casi d'uso comuni dei decoratori

I decoratori vengono comunemente utilizzati per:

• Registrare le chiamate alle funzioni e i relativi argomenti.
• Misurare il tempo di esecuzione delle funzioni.
• Controllare l'accesso, ad esempio verificando le autorizzazioni degli utenti.
• Memorizzare nella cache i risultati per migliorare le prestazioni.

Decoratori integrati in Python

Python mette a disposizione alcuni decoratori integrati, tra cui:

• @staticmethod: definisce un metodo statico.
• @classmethod: definisce un metodo di classe.
• @property: definisce un metodo property.

Errori comuni con i decoratori

Ecco alcuni errori da evitare:

• Non preservare il nome e la docstring della funzione originale (usi functools.wraps).
• Usare decoratori senza necessità per attività semplici.
• Dimenticare di gestire gli argomenti nella funzione wrapper.

Che cosa abbiamo imparato?

In questa lezione ha imparato:

• Che cosa sono i decorator e come funzionano in Python.
• Come creare e utilizzare decorator di base, parametrizzati e concatenati.
• I casi d'uso comuni e i decorator integrati in Python.

Ottimo lavoro! Passiamo al prossimo argomento.