**Decorator** funktioniert, indem er eine Funktion als Argument nimmt und sie dann innerhalb einer **Wrapper**-Funktion ausführt.

Um einen Decorator anzuwenden, kann man das **@**-Symbol gefolgt vom Namen der Decorator-Funktion verwenden, direkt über der Funktion, die modifiziert werden soll. Hier ist ein Beispiel:

``` python
def decorator(func):
    ...

# First method
@decorator
add(a,b):
    print(f"Function add: {a} + {b}")

add(2, 3)

# Second method
add(a,b):
    print(f"Function add: {a} + {b}")

inner = decorator(add)

inner(2, 3)
```

In diesem Beispiel erzielen beide Methoden dasselbe Ergebnis. Die erste Methode, die das `@`-Symbol verwendet, ist eine lesbarere und prägnantere Art, `decorators` anzuwenden, oft als "*syntactic sugar*" bezeichnet.

Es ist typisch, innerhalb von Decorators eine verschachtelte Funktion namens `wrapper` zu verwenden.

#### Flexible Dekoratoren: Anpassung an unterschiedliche Funktionsargumente

Funktionen erfordern oft eine unterschiedliche Anzahl von Argumenten. 
Um einen Dekorator zu entwickeln, der auf Funktionen mit unterschiedlichen Argumentanzahlen angewendet werden kann, ist es effektiv, `*args` und `**kwargs` in der `wrapper()`-Funktion zu verwenden.

def indicate(func):
    def wrapper(*args, **kwargs):
        print("=" * 15)
        print("Taken arguments:", *args, kwargs)
        result = func(*args, **kwargs)
        print("=" * 15)
        return result
    return wrapper


@indicate
def avg_two(a, b):
    """Calculate the average of two numbers"""
    return round((a + b) / 2, 1)

@indicate
def avg_three(a, b, c):
    """Calculate the average of three numbers"""
    return round((a + b + c) / 3, 1)

@indicate
def avg_many_kwargs(**kwargs):
    """Calculate the average of multiple numbers in a dictionary"""
    keys = 0
    total = 0

    for value in kwargs.values():
        keys += 1
        total += value

    return round(total / keys, 1)

print("Returned:", avg_two(14, 21), "\n")
print("Returned:", avg_three(225, 12, 11), "\n")
print("Returned:", avg_many_kwargs(first=51, second=11, third=47, fourth=93))

In diesem Kurs lernen Sie fortgeschrittene Themen wie Funktionsargumente, Iteratoren, Generatoren, Closures und Dekoratoren. Dutzende von Übungsaufgaben helfen Ihnen, diese Themen zu verstehen.

Sie werden dieses Thema genießen und lernen, wie man Werte in einer einzigen Zuweisung packt und entpackt.

Erkunden Sie die Leistungsfähigkeit von Pythons Funktionsargumenten, *args, **kwargs, und lernen Sie, wie Sie Funktionen effektiv als Argumente verwenden.

Entdecken Sie die höherwertigen Funktionen und wie Funktionen als Argumente an andere Funktionen in der Programmierung übergeben werden können.

Was ist der Variablenbereich und wie haben wir vorher ohne ihn gearbeitet? Dieses Thema ist entscheidend für das Verständnis der folgenden Themen: Closures und Dekoratoren. Ich versichere Ihnen, dass dieses Thema sowohl unterhaltsam als auch praktisch sein wird. Sie werden Wissen über local, nonlocal, und global Variablen erlangen.

Dieser Abschnitt bietet eine eingehende Erkundung von Python-Dekoratoren, einer leistungsstarken Funktion, die es ermöglicht, das Verhalten von Funktionen zu modifizieren und zu verbessern. Die Teilnehmer werden lernen, wie sie ihre eigenen Dekoratoren schreiben, eingebaute Dekoratoren verstehen und Dekoratoren in praktischen Szenarien anwenden können.

Fortgeschrittene Python-Techniken

Syntax

Flexible Dekoratoren: Anpassung an unterschiedliche Funktionsargumente