Einführung in Dekoratoren

Dekoratoren sind eine leistungsstarke Funktion von Python, mit der Sie das Verhalten von Funktionen oder Methoden ändern können. Sie werden häufig verwendet, um Funktionen zusätzliche Funktionalität hinzuzufügen, ohne deren Code zu ändern.

In dieser Lektion lernen Sie, was Dekoratoren sind, wie Sie sie verwenden und wie Sie eigene Dekoratoren erstellen.

Was ist ein Dekorator?

Ein Dekorator ist eine Funktion, die eine andere Funktion als Eingabe übernimmt und eine neue Funktion mit zusätzlicher Funktionalität zurückgibt. Er wird häufig mit der Syntax @decorator_name verwendet.

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

Funktionsweise von Dekoratoren

Wenn Sie einen Dekorator verwenden, ersetzt Python die ursprüngliche Funktion durch die vom Dekorator zurückgegebene Wrapper-Funktion.

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

Dekoratoren mit Argumenten verwenden

Dekoratoren können mit Funktionen arbeiten, die Argumente entgegennehmen, indem Sie *args und **kwargs in der Wrapper-Funktion verwenden:

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

Mehrere Dekoratoren verketten

Sie können mehrere Dekoratoren auf eine einzelne Funktion anwenden. Sie werden in der Reihenfolge angewendet, in der sie erscheinen, von oben nach unten:

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

Parametrisierte Dekoratoren erstellen

Parametrisierte Dekoratoren akzeptieren Argumente und ermöglichen eine flexiblere Funktionalität:

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

Häufige Anwendungsfälle für Dekoratoren

Dekoratoren werden häufig für Folgendes verwendet:

• Funktionsaufrufe und ihre Argumente zu protokollieren.
• Die Ausführungszeit von Funktionen zu messen.
• Die Zugriffskontrolle zu realisieren (z. B. durch das Prüfen von Benutzerberechtigungen).
• Ergebnisse zur Verbesserung der Leistung zwischenzuspeichern.

In Python integrierte Dekoratoren

Python stellt einige integrierte Dekoratoren bereit, darunter:

• @staticmethod: Definiert eine statische Methode.
• @classmethod: Definiert eine Klassenmethode.
• @property: Definiert eine Property-Methode.

Häufige Fehler bei Dekoratoren

Hier sind einige Fehler, die Sie vermeiden sollten:

• Den ursprünglichen Namen und Docstring der Funktion nicht beizubehalten (verwenden Sie functools.wraps).
• Dekoratoren für einfache Aufgaben unnötigerweise zu verwenden.
• Zu vergessen, Argumente in der Wrapper-Funktion zu verarbeiten.

Was haben Sie gelernt?

In dieser Lektion haben Sie Folgendes gelernt:

• Was Dekoratoren sind und wie sie in Python funktionieren.
• Wie Sie einfache, parametrisierte und verkettete Dekoratoren erstellen und verwenden.
• Häufige Anwendungsfälle und integrierte Dekoratoren in Python.

Sehr gut! Fahren Sie mit dem nächsten Thema fort.