🏴‍☠️ LEYLA'S Code

⚗️ Ahoi du Code-Alchemist! Willkommen in den Decorator-Dimensionen! 🏴‍☠️

Stell dir vor, du hast eine Kanonenkugel. Eine ganz normale, simple Kanonenkugel. Aber warte mal... was, wenn du sie in flüssiges Gold tauchen könntest? 🌟 Oder sie mit Feuerrunen verzauberst? 🔥 Oder ihr magische Zielsuch-Fähigkeiten verleihst? Das ist GENAU das, was Decorators machen – sie nehmen eine Funktion und geben ihr Superkräfte, OHNE den ursprünglichen Code anzufassen!

Du hast jetzt über 20 Levels durchgekämpft, Käpt'n Nico! Du kennst Funktionen, Schleifen, Conditionals, sogar List Comprehensions und Lambda-Functions. Aber hier wird's mystisch: Funktionen, die Funktionen modifizieren. Meta-Programmierung, wie die Alten sagen. 🧙‍♂️

🎯 Das Decorator-Prinzip (für Piraten erklärt):

Du hast eine Schiffskannone: def feuer(): print("💥"). Schießt eine Kugel. Funktioniert. Aber du willst MEHR Power! Also wickelst du einen Decorator drum herum:

def doppelschuss(func):
    def wrapper():
        func()  # Original
        func()  # NOCH MAL! 🔥
    return wrapper

@doppelschuss
def feuer():
    print("💥")

Jetzt schießt feuer() ZWEI Kugeln! 🎯🎯 Du hast die Funktion "dekoriert" – sie hat jetzt eine zusätzliche Schicht. Wie eine Schokoladenkugel mit Goldfolie drum. 🍫✨

🔧 Warum Decorators in der echten Welt UNVERZICHTBAR sind:

In Flask/Django (Web-Frameworks): @login_required – checkt, ob User eingeloggt ist, BEVOR deine View-Function läuft. Ohne Decorators müsstest du das in JEDER Funktion manuell coden. Chaos!

In APIs: @rate_limit(100) – blockiert Spam-Anfragen. @cache – speichert Ergebnisse für schnellere Antworten. @retry(3) – versucht's dreimal, wenn's fehlschlägt.

Decorators sind deine Code-Bodyguards 💂. Sie stehen VOR der Funktion und sagen: "Halt! Erst meine Checks, DANN darfst du rein!" Oder sie stehen DANACH und sagen: "Warte, ich log das noch schnell!" 📝

📊 ASCII-Diagramm – Decorator Wrapper-Flow:

┌──────────────────────────────────────────┐
│  @decorator  ←  Wrapper drumrum   │
│  ┌─────────────────────────────┐       │
│  │  ORIGINAL FUNKTION     │       │
│  │  def attack():          │       │
│  │      print("💥")       │       │
│  └─────────────────────────────┘       │
└──────────────────────────────────────────┘

# Decorator fügt Schichten hinzu:

┌─ BEFORE CODE ─────────────┐
│  print("🔥 Power-Up!")    │
├───────────────────────────┤
│  ORIGINAL: print("💥")   │
├───────────────────────────┤
│  print("✨ Extra Hit!")   │
└─ AFTER CODE ──────────────┘

# Aufruf: attack() → 3 Outputs!
# 🔥 Power-Up!
# 💥
# ✨ Extra Hit!

🎮 In diesem Level:
Du kämpfst gegen 3 Feinde mit Schilden 🛡️. Normale Schüsse prallen ab! Du brauchst den @power_shot-Decorator, um durch Shields zu brechen. Definiere ihn so:

def power_shot(func):
    def wrapper():
        func()
        func()  # Doppelschuss!
    return wrapper

@power_shot
def schuss():
    print("Feuer")

🔑 Decorator-Details (klick Details unten für mehr!):
• functools.wraps – bewahrt Funktions-Metadaten
• Decorators mit Parametern – @repeat(3)
• Class-based Decorators – __call__ magic method
• Stacking Decorators – mehrere Layers! 🥞

Bereit, Käpt'n? Lass die Shields zerbrechen! 💥🛡️

Deine Leyla 🐀⚓
"Code ist Magie – Decorators sind die Zaubersprüche!" ✨

▶ 🤓 Für Code-Nerds: Noch tiefer eintauchen ⚓

🔧 1. functools.wraps – Der Metadaten-Retter

Problem: Decorators überschreiben den Namen der Original-Funktion. Debugging wird Horror!

# OHNE functools.wraps:
def my_decorator(func):
    def wrapper():
        func()
    return wrapper

@my_decorator
def greet():
    """Sagt Hallo"""
    print("Hi!")

print(greet.__name__)  # "wrapper" ❌
print(greet.__doc__)   # None ❌

# MIT functools.wraps:
from functools import wraps

def my_decorator(func):
    @wraps(func)  # Bewahrt Metadaten!
    def wrapper():
        func()
    return wrapper

@my_decorator
def greet():
    """Sagt Hallo"""
    print("Hi!")

print(greet.__name__)  # "greet" ✅
print(greet.__doc__)   # "Sagt Hallo" ✅

Warum wichtig? Debugger, Logging-Tools und Dokumentation brauchen diese Infos! In Production-Code ist @wraps(func) PFLICHT. 🛡️

🎁 2. Decorators mit Parametern – Die nächste Stufe

Du willst einen Decorator, der 3-mal wiederholt? Oder 5-mal? Flexibel sein! 🔥

def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)  # Parameter!
def shoot():
    print("💥")

shoot()
# Output:
# 💥
# 💥
# 💥

Struktur: Decorator-Factory → Decorator → Wrapper. Drei Schichten! 🧅 Die äußere Funktion nimmt Parameter, die innere ist der eigentliche Decorator.

🌐 3. Real-World Use Cases – Wo du Decorators überall siehst

Flask Web-Framework:

@app.route('/dashboard')
@login_required  # Nur für eingeloggte User!
@admin_only      # Nur für Admins!
def dashboard():
    return render_template('dashboard.html')

Ohne Decorators wäre jede View-Function 20 Zeilen länger mit Boilerplate-Code! 🙈

Performance-Messung:

import time

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"⏱️ {func.__name__}: {time.time()-start:.3f}s")
        return result
    return wrapper

@timer
def process_data():
    # Heavy computation
    pass

API Rate Limiting:

@rate_limit(requests=100, window=60)  # 100/min
def api_call():
    return fetch_data()

🔥 4. Class-Based Decorators – Für die Profis

Decorators müssen keine Funktionen sein! Du kannst Classes mit __call__ verwenden:

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0
    
    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"Call #{self.count}")
        return self.func(*args, **kwargs)

@CountCalls
def greet():
    print("Hello!")

greet()  # Call #1 / Hello!
greet()  # Call #2 / Hello!

Vorteil: Du kannst State speichern (wie self.count)! Mit Funktions-Decorators bräuchtest du nonlocal oder globale Variablen. 🗄️

🥞 5. Stacking Decorators – Mehrere Layers

Du kannst Decorators stapeln wie Pfannkuchen! 🥞

@log_calls       # Äußerste Schicht
@timer           # Mittlere Schicht
@cache           # Innerste Schicht
def complex_calc(x):
    return x ** 2

Reihenfolge: Von unten nach oben! @cache wird ZUERST angewendet, dann @timer, dann @log_calls.

⚠️ 6. Häufige Fehler & Best Practices

❌ FEHLER 1: *args, **kwargs vergessen

# BAD:
def my_decorator(func):
    def wrapper():  # Nimmt keine Args!
        return func()
    return wrapper

@my_decorator
def add(a, b):  # Braucht Args!
    return a + b

add(2, 3)  # TypeError! ❌

✅ FIX: Immer *args, **kwargs!

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

❌ FEHLER 2: return vergessen

def my_decorator(func):
    def wrapper(*args, **kwargs):
        func(*args, **kwargs)  # Kein return!
    return wrapper

@my_decorator
def get_value():
    return 42

result = get_value()  # result = None ❌

✅ FIX: Immer returnen!

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)  # ✅
    return wrapper

🎓 Zusammenfassung – Du bist jetzt Decorator-Master!

• Decorators = Funktions-Wrapper mit Superkräften 🦸
• @wraps(func) = Pflicht für Production-Code
• Parameter-Decorators = 3-Layer-Struktur (Factory → Decorator → Wrapper)
• Real-World = Flask Routes, API Limiting, Logging, Caching
• Class-based = Für State-Management
• Stacking = Von unten nach oben
• IMMER *args, **kwargs + return!

Du hast Level 23 gemeistert, Käpt'n Nico! Decorators sind eines der mächtigsten Python-Features. In jedem professionellen Codebase wirst du sie sehen. Jetzt bist du bereit! 🏴‍☠️🔥

P.S.: Wenn du Decorators auf deine eigenen Projekte anwendest, wirst du nie wieder zurückwollen. Es ist wie... Code-Magie! ✨

🏴‍☠️ LEYLA'S CODE

Level 23 – Die Dekoratoren-Dimensionen

🏴‍☠️ Unterstütze Leyla's Code – Nutze meine Referral-Links!

🏴‍☠️ Spende BTC an Leyla's Code 🚀

Python Dekoratoren - Meta-Programmierung meistern

Was sind Dekoratoren?

Dekoratoren mit Argumenten

Built-in Dekoratoren in Python

Dekoratoren in Web-Frameworks

Class-Dekoratoren und Decorator-Chaining

Performance und Best Practices