Python Academy · Lektion

Benutzerdefinierte Decorators schreiben

Erstellen Sie Decorators mit Wrapper-Funktionen und functools.wraps.

Lektion 2 von 414 Schritte

Benutzerdefinierte Decorators schreiben ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Einführung

Dekoratoren sind Funktionen, die andere Funktionen umschließen und Verhalten davor oder danach hinzufügen, ohne das Original zu ändern.

Was ist ein Dekorator?

@decorator über einer Funktion ist syntaktischer Zucker für: func = decorator(func). Der Dekorator erhält die Funktion und gibt einen Wrapper zurück.

def shout(func):
    def wrapper(*a, **kw):
        result = func(*a, **kw)
        return str(result).upper()
    return wrapper
@shout
def greet(name): return f'hello {name}'
print(greet('Alice'))

Das Wrapper-Muster

Die Wrapper-Funktion hat dieselbe Signatur wie das Original. Sie ruft das Original innerhalb des Wrappers auf und fügt darum herum Verhalten hinzu.

def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f'{func.__name__} took {time.time()-start:.4f}s')
        return result
    return wrapper
@timer
def slow(): import time; time.sleep(0.01)
slow()

functools.wraps

@wraps(func) am Wrapper bewahrt __name__, __doc__ und __annotations__ der ursprünglichen Funktion.

from functools import wraps
def log(func):
    @wraps(func)
    def wrapper(*a, **kw):
        print(f'calling {func.__name__}')
        return func(*a, **kw)
    return wrapper
@log
def add(a, b): return a + b
print(add.__name__)
add(1, 2)

Dekorator mit Argumenten

Ein Dekorator mit Argumenten benötigt eine zusätzliche Verschachtelungsebene: eine Factory-Funktion, die die Argumente entgegennimmt und den Dekorator zurückgibt.

def repeat(n):
    def decorator(func):
        from functools import wraps
        @wraps(func)
        def wrapper(*a, **kw):
            for _ in range(n): func(*a, **kw)
        return wrapper
    return decorator
@repeat(3)
def hi(): print('hi')
hi()

Dekoratoren stapeln

Mehrere Dekoratoren werden von unten nach oben gestapelt: @d2 @d1 bedeutet func = d2(d1(func)). Der äußerste (oberste) wird zuletzt ausgeführt.

def bold(f):
    from functools import wraps
    @wraps(f)
    def w(*a,**k): return '<b>' + f(*a,**k) + '</b>'
    return w
def italic(f):
    from functools import wraps
    @wraps(f)
    def w(*a,**k): return '<i>' + f(*a,**k) + '</i>'
    return w
@bold
@italic
def text(): return 'hello'
print(text())

Klassenbasierter Dekorator

Eine Klasse mit __call__ kann als Dekorator dienen. Sie speichert ihren Zustand zwischen Aufrufen.

class Counter:
    def __init__(self, func): self.func,self.count=func,0
    def __call__(self, *a, **kw):
        self.count+=1
        return self.func(*a, **kw)
@Counter
def greet(name): return f'hi {name}'
greet('Alice'); greet('Bob')
print(greet.count)

Memoization-Dekorator

Speichern Sie vorherige Ergebnisse zwischen, um eine erneute Berechnung zu vermeiden: if args in cache: return cache[args]. functools.lru_cache erledigt dies integiert.

from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)
print(fib(30))

Autorisierungsdekorator

Dekoratoren werden häufig für die Zugriffskontrolle verwendet: Prüfen Sie, ob die Benutzerin oder der Benutzer angemeldet ist, bevor Sie die Funktion ausführen.

def requires_auth(func):
    from functools import wraps
    @wraps(func)
    def wrapper(user, *a, **kw):
        if not user.get('authenticated'):
            raise PermissionError('Not authenticated')
        return func(user, *a, **kw)
    return wrapper
@requires_auth
def dashboard(user): return 'Welcome!'
try: dashboard({'authenticated': False})
except PermissionError as e: print(e)

Wiederholungsdekorator

Umschließen Sie eine Funktion, um sie bei einem Fehler erneut auszuführen: for _ in range(retries): try: return func() except Exception: pass

import random
from functools import wraps
def retry(times=3):
    def dec(func):
        @wraps(func)
        def wrapper(*a, **kw):
            for i in range(times):
                try: return func(*a, **kw)
                except Exception as e:
                    if i==times-1: raise
        return wrapper
    return dec
@retry(3)
def flaky():
    if random.random()<0.7: raise ValueError
    return 'ok'
try: print(flaky())
except ValueError: print('failed')

Bewährte Praktiken für Dekoratoren

Verwenden Sie immer @functools.wraps. Beschränken Sie Dekoratoren auf jeweils eine Aufgabe. Dokumentieren Sie, was sie hinzufügen. Testen Sie den Dekorator getrennt von der dekorierten Funktion.

from functools import wraps
def validate_positive(func):
    @wraps(func)
    def wrapper(x, *a, **kw):
        if x <= 0: raise ValueError(f'{x} must be positive')
        return func(x, *a, **kw)
    return wrapper
@validate_positive
def sqrt(x): return x**0.5
print(sqrt(9))

Kurzer Test

Was bewirkt @functools.wraps(func), wenn es auf einen Wrapper angewendet wird?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Dekoratoren: func = decorator(func). Verwenden Sie wrapper(*args, **kwargs). @wraps bewahrt Metadaten. Parametrisierte Dekoratoren fügen eine weitere Ebene hinzu. Stapeln Sie mehrere @decorators.

Weiter so

Hervorragender Fortschritt! Fahren Sie fort, um das nächste Konzept zu meistern.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 76
Lektionen: 320

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Benutzerdefinierte Decorators schreiben“ kostenlos?

Ja — der vollständige Text von „Benutzerdefinierte Decorators schreiben“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Benutzerdefinierte Decorators schreiben“?

Erstellen Sie Decorators mit Wrapper-Funktionen und functools.wraps. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Benutzerdefinierte Decorators schreiben“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy