Python-decorators

Decorators laten je functies wrappen met herbruikbare logica, wat je code modulairder, leesbaarder en onderhoudbaarder maakt. In deze gids bouwen, leggen we uit en passen we decorators toe in real-world scenario's.

Video: @Decorators in Python

Decorators in Python

Python's decorators zijn een krachtig metaprogrammeringstool waarmee je gedrag kunt toevoegen aan functies of klassen op definities-tijd. Omdat alles in Python een object is – inclusief functies en klassen – opereren decorators door een callable te nemen, het in een andere te wrappen en de nieuwe callable te retourneren.

Voorwaarden voor decorators leren

Voordat je induikt, moet je comfortabel zijn met het feit dat in Python, functies first-class objects zijn. Namen zijn simpelweg referenties gebonden aan objecten; dezelfde functie kan door meerdere namen gerefereerd worden.

def eerste(bericht):
    print(bericht)
eerste("Hallo")
tweede = eerste
tweede("Hallo")

Uitvoer

Hallo Hallo

Functies kunnen als argumenten doorgegeven, geretourneerd uit andere functies, en genest binnen andere functies. Deze concepten – higher-order functions, geneste functies en closures – zijn de bouwstenen van decorators.

def inc(x):
    return x + 1
def dec(x):
    return x - 1
def opereer(func, x):
    resultaat = func(x)
    return resultaat

Gebruik:

>>> opereer(inc,3)
4
>>> opereer(dec,3)
2

def is_geroepen():
    def is_geretourneerd():
        print("Hallo")
    return is_geretourneerd
nieuwe = is_geroepen()
nieuwe()

Uitvoer

Hallo

Closures begrijpen is cruciaal: de geneste functie behoudt toegang tot de omringende scope, wat decorators precies benutten om metadata op te slaan of gedrag te wijzigen.

Terug naar decorators

In Python is een decorator simpelweg een callable die een functie (of andere callable) accepteert en een nieuwe callable retourneert. Deze geretourneerde functie wrapt typisch de originele, functionaliteit toevoegend of wijzigend voor of na de aanroep.

def maak_mooi(func):
    def inner():
        print("Ik ben gedecoreerd")
        func()
    return inner

def gewoon():
    print("Ik ben gewoon")

Voorbeeldgebruik:

>>> gewoon()
Ik ben gewoon
>>> mooi = maak_mooi(gewoon)
>>> mooi()
Ik ben gedecoreerd
Ik ben gewoon

Het decorator-patroon houdt de originele functie-semantiek intact terwijl het het verrijkt. Om handmatige hertoewijzing te vermijden, biedt Python syntactische suiker met het @-symbool:

@maak_mooi
def gewoon():
    print("Ik ben gewoon")

Dit is equivalent aan:

def gewoon():
    print("Ik ben gewoon")
gewoon = maak_mooi(gewoon)

Functies met parameters decoreren

Veel decorators moeten willekeurige argumenten afhandelen. De *args en **kwargs-syntax laat je elke positionele of keyword-argumenten vangen en ongewijzigd doorsturen.

def werkt_voor_alle(func):
    def inner(*args, **kwargs):
        print("Ik kan elke functie decoreren")
        return func(*args, **kwargs)
    return inner

Edge-cases afhandelen is een ander veelvoorkomend decorator-use-case. Bijvoorbeeld, bewaken tegen delen door nul:

def slim_delen(func):
    def inner(a, b):
        print("Ik ga", a, "en", b, "delen")
        if b == 0:
            print("Oeps! kan niet delen")
            return
        return func(a, b)
    return inner

@slim_delen
def delen(a, b):
    print(a/b)

Gebruik:

>>> delen(2,5)
Ik ga 2 en 5 delen
0.4
>>> delen(2,0)
Ik ga 2 en 0 delen
Oeps! kan niet delen

Decorators koppelen in Python

Decorators kunnen gestapeld worden. De volgorde van toepassing maakt uit, want elke decorator ontvangt de functie geretourneerd door de eronder.

def ster(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner

def procent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner

@ster
@procent
def printer(bericht):
    print(bericht)

Resultaat:

****************************** %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Hallo %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ******************************

De volgorde omkeren wisselt de omringende patronen, wat demonstreert hoe decorator-stacking gedrag beïnvloedt.