🏴‍☠️ LEYLA'S CODE

🔧 1. Event Loop Internals – Die Magie hinter den Kulissen

Der Event Loop ist das Herz von asyncio. Er managt alle Tasks wie ein Dirigent ein Orchester! 🎼

# So funktioniert's intern:
# 1. Event Loop hat eine QUEUE von Tasks
# 2. Task A ruft: await slow_operation()
# 3. Task A pausiert, Control geht zurück zum Loop
# 4. Loop nimmt Task B aus Queue, führt aus
# 5. Task B ruft: await another_operation()
# 6. Task B pausiert, Loop nimmt Task C
# 7. slow_operation() meldet sich "Fertig!"
# 8. Loop weckt Task A auf, setzt fort
# ...und so weiter!

import asyncio

# Event Loop manuell steuern:
loop = asyncio.get_event_loop()

# Task hinzufügen:
task = loop.create_task(my_coroutine())

# Loop manuell laufen lassen:
loop.run_until_complete(task)

# Oder einfach:
asyncio.run(my_coroutine())  # High-level API ✅

Key Insight: Async ist NICHT Multithreading! Alles läuft in EINEM Thread. Event Loop = Cooperative Multitasking. Tasks geben freiwillig Control ab bei await. 🤝

🎁 2. asyncio.gather() – Parallel Execution Power

gather() = "Starte alle diese Coroutines parallel und gib mir alle Ergebnisse!" 🚀

import asyncio

async def fetch_user(user_id):
    await asyncio.sleep(1)  # Simuliert DB-Query
    return f"User {user_id}"

async def main():
    # Sequenziell (langsam):
    user1 = await fetch_user(1)  # 1 Sek
    user2 = await fetch_user(2)  # 1 Sek
    user3 = await fetch_user(3)  # 1 Sek
    # Total: 3 Sek ❌

    # Parallel (schnell):
    results = await asyncio.gather(
        fetch_user(1),
        fetch_user(2),
        fetch_user(3)
    )
    # Total: 1 Sek ✅
    print(results)  # ['User 1', 'User 2', 'User 3']

# gather() wartet auf ALLE Tasks
# Wenn eine Task fehlschlägt? gather() wirft Exception!
# return_exceptions=True → gibt Exceptions als Werte zurück

Pro-Tipp: gather() für Batch-Operationen (DB-Queries, API-Calls). as_completed() für Streaming-Results (erste fertige Task zuerst)! 🏃

🔄 3. async with & async for – Context Manager & Iterators

async with: Wie normales with, aber async! 🔓

import aiohttp

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

# session wird async geschlossen, auch bei Errors!
# Kein manuelles .close() nötig ✅

# Eigene async context managers:
class AsyncDB:
    async def __aenter__(self):
        self.conn = await connect_db()
        return self.conn
    
    async def __aexit__(self, exc_type, exc, tb):
        await self.conn.close()

async with AsyncDB() as db:
    result = await db.query("SELECT * FROM users")

async for: Iteriere über async generators! 🌊

async def stream_data():
    for i in range(10):
        await asyncio.sleep(0.5)  # Simuliert Stream
        yield i

async def main():
    async for value in stream_data():
        print(value)  # 0, 1, 2... (jeweils 0.5 Sek Pause)

# Real-World: WebSocket-Streams, Message Queues!

🏭 4. Tasks vs. Coroutines – Der Unterschied!

Coroutine: async def-Funktion (noch nicht gestartet) 💤
Task: Wrapped Coroutine (im Event Loop, läuft!) 🏃

async def my_coro():
    await asyncio.sleep(1)
    return "Done"

# Coroutine (passiv):
coro = my_coro()  # Noch nicht gestartet!

# Task (aktiv):
task = asyncio.create_task(coro)  # JETZT läuft's!

# Warten auf Ergebnis:
result = await task  # "Done"

# Task-Status checken:
task.done()  # True/False
task.cancelled()  # True/False
task.result()  # Ergebnis oder Exception

Wichtig: await my_coro() = sequenziell. task = create_task(my_coro()); await task = parallel-fähig! 🔥

🌐 5. Real-World Use Cases – Async überall!

FastAPI Web Framework (async by default):

from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    async with httpx.AsyncClient() as client:
        # Fetch from 3 services parallel!
        profile, posts, friends = await asyncio.gather(
            client.get(f"api.com/profile/{user_id}"),
            client.get(f"api.com/posts/{user_id}"),
            client.get(f"api.com/friends/{user_id}")
        )
        return {
            "profile": profile.json(),
            "posts": posts.json(),
            "friends": friends.json()
        }

# 1000 concurrent requests? No problem! 🚀

Web Scraping (100 Sites parallel):

import aiohttp
from bs4 import BeautifulSoup

async def scrape(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            html = await response.text()
            soup = BeautifulSoup(html, 'html.parser')
            return soup.title.string

async def scrape_all(urls):
    tasks = [scrape(url) for url in urls]
    return await asyncio.gather(*tasks)

urls = [f"https://example.com/page{i}" for i in range(100)]
titles = asyncio.run(scrape_all(urls))
# 100 Sites in ~3 Sek statt 300 Sek! 🔥

Database Queries (async ORMs):

from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

engine = create_async_engine("postgresql+asyncpg://...")

async def get_users():
    async with AsyncSession(engine) as session:
        result = await session.execute(select(User))
        return result.scalars().all()

# Multiple queries parallel:
users, posts, comments = await asyncio.gather(
    get_users(),
    get_posts(),
    get_comments()
)

⚡ 6. Performance – Wann Async nutzen?

✅ Async ist perfekt für:
• I/O-bound Tasks (Netzwerk, Disk, DB) 🌐
• Viele gleichzeitige Operationen (Web Servers) 🚀
• Waiting-heavy Code (API-Calls) ⏳

❌ Async ist NICHT gut für:
• CPU-bound Tasks (Heavy Computation) 🧮
• Single sequential operation (unnötiger Overhead) 🐌
• Legacy synchronous libraries (Blockieren Event Loop!) 🛑

Benchmark: 100 API-Calls

# Sync: 100 * 0.5 Sek = 50 Sek ❌
# Async: 0.5 Sek (alle parallel) ✅
# Speedup: 100x! 🔥

⚠️ 7. Häufige Fehler & Best Practices

❌ FEHLER 1: Blocking Code in async Funktion

import time

async def bad():
    time.sleep(5)  # Blockiert Event Loop! ❌
    # Alle anderen Tasks stehen auch still!

✅ FIX: Nutze async-äquivalente

async def good():
    await asyncio.sleep(5)  # Non-blocking ✅

# Für sync Libraries: run_in_executor()
import requests

async def fetch():
    loop = asyncio.get_event_loop()
    response = await loop.run_in_executor(
        None,  # Default ThreadPoolExecutor
        requests.get,
        "https://api.com"
    )
    return response.text()

❌ FEHLER 2: await vergessen

async def fetch():
    return "data"

async def main():
    result = fetch()  # Coroutine-Objekt, nicht Result! ❌
    print(result)  # 

✅ FIX: IMMER await

result = await fetch()  # ✅

❌ FEHLER 3: Zu viele parallel Tasks

# 10,000 API-Calls parallel?
tasks = [fetch(url) for url in huge_list]
await asyncio.gather(*tasks)  # Server-Crash! ❌

✅ FIX: Semaphore für Rate Limiting

sem = asyncio.Semaphore(10)  # Max 10 parallel

async def fetch_limited(url):
    async with sem:
        return await fetch(url)

tasks = [fetch_limited(url) for url in huge_list]
await asyncio.gather(*tasks)  # Nur 10 gleichzeitig ✅

🎓 Zusammenfassung – Du bist Async-Champion!

• Async/Await = Cooperative Multitasking (Event Loop) 🎭
• async def = Coroutine, await = pause & yield control
• asyncio.gather() = parallel execution
• async with/for = async context managers/iterators
• Tasks = scheduled coroutines in Event Loop
• Best für: I/O-bound, viele Operationen, Web APIs 🌐
• NICHT für: CPU-bound, blocking libraries 🚫
• IMMER: await async calls, use async alternatives!

Level 25 gemeistert, Käpt'n Nico! Async/Await ist DAS Feature für moderne Python-Apps. FastAPI, aiohttp, async ORMs – die Zukunft ist async! 🏴‍☠️⚡

P.S.: Wenn dein nächstes Projekt Web APIs oder Scraping macht... async ist Pflicht! 😉🚀