🏴‍☠️ LEYLA'S CODE

🔧 1. yield from – Delegation Magic

Du hast einen Generator, der andere Generators aufruft? yield from ist dein Freund!

# OHNE yield from:
def sub_generator():
    yield 1
    yield 2

def main_generator():
    for value in sub_generator():
        yield value  # Manuell weiterleiten ❌

# MIT yield from:
def main_generator():
    yield from sub_generator()  # Auto-Delegation! ✅

# Noch mächtiger – flatten nested lists:
def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)  # Rekursion!
        else:
            yield item

nested = [1, [2, [3, 4], 5], 6]
list(flatten(nested))  # [1, 2, 3, 4, 5, 6] 🔥

🎁 2. Generator Expressions – Lazy List Comprehensions

List Comprehension: [x**2 for x in range(1000000)] → RAM explodiert! 💥
Generator Expression: (x**2 for x in range(1000000)) → nur () statt [] → lazy! ✅

# List Comprehension (eager):
squares = [x**2 for x in range(1000000)]
# RAM: ~8 MB für Liste ❌

# Generator Expression (lazy):
squares = (x**2 for x in range(1000000))
# RAM: ~100 Bytes für Generator-Objekt ✅

# Nutze es mit sum(), max(), etc.:
total = sum(x**2 for x in range(1000000))
# Berechnet on-the-fly, kein RAM-Waste!

Performance-Tipp: Nutze Generator Expressions für any(), all(), sum(), max(), min(). Sie stoppen early, wenn's passt! 🚀

🔄 3. .send() Method – Bidirektionale Kommunikation

Generators können nicht nur Werte SENDEN (yield), sondern auch EMPFANGEN (.send())! 🤯

def echo_generator():
    while True:
        received = yield  # Warte auf Input
        print(f"Empfangen: {received}")

gen = echo_generator()
next(gen)  # Starte Generator (priming)
gen.send("Hello!")   # Empfangen: Hello!
gen.send("World!")   # Empfangen: World!

# Real-World: Coroutines für async Pipelines!
def moving_average():
    total = 0
    count = 0
    average = None
    while True:
        value = yield average
        total += value
        count += 1
        average = total / count

ma = moving_average()
next(ma)  # Prime
print(ma.send(10))  # 10.0
print(ma.send(20))  # 15.0
print(ma.send(30))  # 20.0

Use Case: State Machines, Event Handlers, Data Processing Pipelines! 🏭

🔗 4. Generator Pipelines – Compose Like a Pro

Chain Generators für elegante Data Pipelines! Unix-Pipes für Python! 🐍

def read_lines(file):
    """Generator: Read file line by line"""
    with open(file) as f:
        for line in f:
            yield line.strip()

def filter_comments(lines):
    """Generator: Filter out comments"""
    for line in lines:
        if not line.startswith('#'):
            yield line

def to_uppercase(lines):
    """Generator: Convert to uppercase"""
    for line in lines:
        yield line.upper()

# Pipeline:
pipeline = to_uppercase(
    filter_comments(
        read_lines('config.txt')
    )
)

for line in pipeline:
    print(line)

# LAZY! Nur 1 Zeile zur Zeit im RAM ✅
# Infinite file? No problem! 🔥

Vorteile:
• Jeder Step = eigener Generator (modular!)
• Lazy Evaluation = Memory-effizient
• Composable = Mix & Match wie Lego! 🧱

🏭 5. Real-World Use Cases – Generators überall!

Data Science – Processing große Datasets:

import pandas as pd

def read_csv_chunks(file, chunksize=10000):
    """Generator: Read CSV in chunks"""
    for chunk in pd.read_csv(file, chunksize=chunksize):
        yield chunk

# Process 10 GB CSV ohne RAM-Crash!
for chunk in read_csv_chunks('huge_data.csv'):
    process(chunk)  # Nur 10k Zeilen zur Zeit

Web Scraping – Infinite Pagination:

def fetch_pages(base_url):
    page = 1
    while True:
        response = requests.get(f"{base_url}?page={page}")
        if not response.json():
            break  # No more data
        yield response.json()
        page += 1

for page_data in fetch_pages('https://api.example.com/items'):
    save_to_db(page_data)

System Monitoring – Real-time Streams:

def monitor_cpu():
    import psutil
    while True:
        yield psutil.cpu_percent(interval=1)

for cpu_usage in monitor_cpu():
    if cpu_usage > 80:
        alert("High CPU!")
    # Läuft unendlich! 🔄

⚡ 6. Performance – Memory Comparison

Test: 1 Million Zahlen

import sys

# List:
numbers = [x for x in range(1_000_000)]
sys.getsizeof(numbers)  # ~8 MB ❌

# Generator:
numbers = (x for x in range(1_000_000))
sys.getsizeof(numbers)  # ~120 Bytes ✅

# 66,666x weniger RAM! 🔥

Speed: Generators sind manchmal LANGSAMER (Overhead pro Aufruf), aber das ist irrelevant, wenn die Alternative RAM-Crash ist! 💀

⚠️ 7. Häufige Fehler & Best Practices

❌ FEHLER 1: Generator zweimal iterieren

gen = (x**2 for x in range(5))
list(gen)  # [0, 1, 4, 9, 16]
list(gen)  # [] ← Leer! Generator erschöpft ❌

✅ FIX: Konvertiere zu Liste oder erstelle neu

# Option 1: Liste
numbers = list(x**2 for x in range(5))
# Option 2: Generator-Funktion
def gen():
    for x in range(5):
        yield x**2

list(gen())  # Works!
list(gen())  # Works again! ✅

❌ FEHLER 2: return statt yield

def my_gen():
    return 1  # Kein Generator! ❌
    yield 2

# StopIteration mit value=1

✅ return in Generators = Ende Signal:

def countdown(n):
    while n > 0:
        yield n
        n -= 1
    return "Liftoff!"  # Finale Message

gen = countdown(3)
list(gen)  # [3, 2, 1]
# return-Wert geht in StopIteration.value

🎓 Zusammenfassung – Du bist jetzt Generator-Meister!

• Generators = Lazy Evaluation für Memory-Effizienz 🧠
• yield = pausiert, bewahrt State
• yield from = delegiert an anderen Generator
• Generator Expressions = (x for x in ...) statt [x for x in ...]
• .send() = bidirektionale Kommunikation
• Pipelines = composable, modular, elegant!
• Real-World = Data Science, Web Scraping, Streaming
• NIEMALS Generator zweimal iterieren ohne reset!

Level 24 gemeistert, Käpt'n Nico! Generators sind die geheime Waffe für effiziente Python-Programme. In Production-Code mit Big Data? Generators sind Pflicht! 🏴‍☠️🚀

P.S.: Wenn du das nächste Mal "MemoryError" siehst... denk an Generators! 😉