Einführung in Dekoratoren

Dekoratoren sind eine leistungsfähige Funktion in 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()

So funktionieren Dekoratoren

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

# 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 übernehmen, 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 von oben nach unten aufgeführt sind:

# 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 Decorators erstellen

Parametrisierte Decorators 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 Decorators

Decorators werden häufig für folgende Zwecke verwendet:

• Funktionsaufrufe und ihre Argumente protokollieren.
• Die Ausführungszeit von Funktionen messen.
• Zugriffskontrolle, zum Beispiel durch Überprüfen von Benutzerberechtigungen.
• Ergebnisse zur Leistungsverbesserung zwischenspeichern.

Integrierte Decorators in Python

Python stellt einige integrierte Decorators 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 Namen und den Docstring der ursprünglichen Funktion nicht beizubehalten (verwenden Sie functools.wraps).
• Dekoratoren unnötigerweise für einfache Aufgaben zu verwenden.
• Zu vergessen, Argumente in der Wrapper-Funktion zu verarbeiten.

Was haben Sie gelernt?

In dieser Lektion haben Sie Folgendes gelernt:

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

Gut gemacht! Wechseln wir zum nächsten Thema.