Decorators

Decorators zijn een krachtige functie van Python waarmee je het gedrag van functies of methoden kunt aanpassen. Ze worden vaak gebruikt om functionaliteit aan functies toe te voegen zonder hun code aan te passen.

In deze les leer je wat decorators zijn, hoe je ze gebruikt en hoe je je eigen decorators maakt.

Een decorator is een functie die een andere functie als invoer neemt en een nieuwe functie met extra functionaliteit teruggeeft. Je gebruikt deze vaak met de syntaxis @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()

Wanneer je een decorator gebruikt, vervangt Python de oorspronkelijke functie door de wrapperfunctie die de decorator teruggeeft.

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

Decorators kunnen samenwerken met functies die argumenten accepteren door *args en **kwargs in de wrapperfunctie te gebruiken:

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

Je kunt meerdere decorateurs op één functie gebruiken. Ze worden toegepast in de volgorde waarin ze staan, van boven naar beneden:

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

Geparametriseerde decorateurs accepteren argumenten en maken flexibelere functionaliteit mogelijk:

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

Decorateurs worden vaak gebruikt voor:

• Het registreren van functieaanroepen en hun argumenten.
• Het meten van de uitvoeringstijd van functies.
• Toegangsbeheer, bijvoorbeeld het controleren van gebruikersrechten.
• Het opslaan van resultaten in de cache voor betere prestaties.

Python bevat enkele ingebouwde decorateurs, waaronder:

• @staticmethod: Definieert een statische methode.
• @classmethod: Definieert een klassemethode.
• @property: Definieert een eigenschapsmethode.

Dit zijn enkele fouten die je moet vermijden:

• De naam en documentatietekst van de oorspronkelijke functie niet behouden, gebruik daarvoor functools.wraps.
• Decorateurs onnodig gebruiken voor eenvoudige taken.
• Vergeten om argumenten in de omhullende functie te verwerken.

In deze les heb je geleerd:

• Wat decorateurs zijn en hoe ze in Python werken.
• Hoe je eenvoudige, geparametriseerde en gekoppelde decorateurs maakt en gebruikt.
• Veelvoorkomende toepassingen en ingebouwde decorateurs in Python.

Goed gedaan! Laten we doorgaan naar het volgende onderwerp.