Python Decorators meistern: Funktionen mit Experten-Techniken erweitern

Python Decorators

Decorators lassen Sie Funktionen mit wiederverwendbarer Logik umhüllen, was Ihren Code modularer, lesbarer und wartbarer macht. In diesem Leitfaden bauen, erklären und wenden wir Decorators in realen Szenarien an.

Video: @Decorators in Python

Decorators in Python

Pythons Decorators sind ein mächtiges Metaprogrammiering-Tool, das es Ihnen erlaubt, Funktionen oder Klassen zur Definitionszeit Verhalten hinzuzufügen. Da alles in Python ein Objekt ist – einschließlich Funktionen und Klassen – operieren Decorators, indem sie ein Callable nehmen, es in ein anderes einwickeln und das neue Callable zurückgeben.

Voraussetzungen für das Erlernen von Decorators

Bevor Sie eintauchen, sollten Sie damit vertraut sein, dass in Python Funktionen First-Class-Objekte sind. Namen sind einfach Referenzen, die an Objekte gebunden sind; dieselbe Funktion kann von mehreren Namen referenziert werden.

def first(msg):
    print(msg)
first("Hallo")
second = first
second("Hallo")

Ausgabe

Hallo Hallo

Funktionen können als Argumente übergeben, aus anderen Funktionen zurückgegeben und sogar in anderen Funktionen verschachtelt werden. Diese Konzepte – Higher-Order-Funktionen, verschachtelte Funktionen und Closures – sind die Bausteine von Decorators.

def inc(x):
    return x + 1
def dec(x):
    return x - 1
def operate(func, x):
    result = func(x)
    return result

Verwendung:

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

def is_called():
    def is_returned():
        print("Hallo")
    return is_returned
new = is_called()
new()

Ausgabe

Hallo

Closures zu verstehen ist der Schlüssel: Die verschachtelte Funktion behält Zugriff auf den umgebenden Scope, was Decorators genau ausnutzen, um Metadaten zu speichern oder Verhalten zu modifizieren.

Zurück zu Decorators

In Python ist ein Decorator einfach ein Callable, das eine Funktion (oder ein anderes Callable) akzeptiert und ein neues Callable zurückgibt. Diese zurückgegebene Funktion umhüllt typischerweise die ursprüngliche, fügt Funktionalität vor oder nach dem Aufruf hinzu oder ändert sie.

def make_pretty(func):
    def inner():
        print("Ich wurde dekoriert")
        func()
    return inner
def ordinary():
    print("Ich bin gewöhnlich")

Beispielverwendung:

>>> ordinary()
Ich bin gewöhnlich
>>> pretty = make_pretty(ordinary)
>>> pretty()
Ich wurde dekoriert
Ich bin gewöhnlich

@make_pretty
def ordinary():
    print("Ich bin gewöhnlich")

def ordinary():
    print("Ich bin gewöhnlich")
ordinary = make_pretty(ordinary)

def works_for_all(func):
    def inner(*args, **kwargs):
        print("Ich kann jede Funktion dekorieren")
        return func(*args, **kwargs)
    return inner

def smart_divide(func):
    def inner(a, b):
        print("Ich werde teilen", a, "und", b)
        if b == 0:
            print("Hoppla! Kann nicht teilen")
            return
        return func(a, b)
    return inner
@smart_divide
def divide(a, b):
    print(a/b)

>>> divide(2, 5)
Ich werde teilen 2 und 5
0.4
>>> divide(2, 0)
Ich werde teilen 2 und 0
Hoppla! Kann nicht teilen

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner
def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner
@star
@percent
def printer(msg):
    print(msg)

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