Python Academy · Lektion

Coroutinen und die Ereignisschleife

Definieren Sie Coroutinen mit async def und führen Sie sie mit asyncio.run() aus.

Coroutinen und die Ereignisschleife ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist Nebenläufigkeit?

Asyncio stellt kooperative Nebenläufigkeit bereit: Ein einzelner Thread verarbeitet viele Tasks, indem er zwischen ihnen wechselt, sobald einer auf I/O wartet.

# Traditional: blocking I/O holds the whole thread
# Asyncio: while waiting for I/O, run other coroutines

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)   # yield control
    print("World")

asyncio.run(main())

async def — Koroutinenfunktionen

Mit async def definierte Funktionen sind Koroutinenfunktionen. Ihr Aufruf gibt ein Koroutinenobjekt zurück; sie werden erst ausgeführt, wenn sie erwartet oder eingeplant werden.

import asyncio

async def greet(name):
    return f"Hello, {name}"

result = asyncio.run(greet("Alice"))
print(result)   # Hello, Alice

Die Event Loop

Die Event Loop steuert die Ausführung von Koroutinen. asyncio.run(coro) erstellt eine neue Event Loop, führt die Koroutine bis zum Abschluss aus und schließt die Loop.

import asyncio

async def compute():
    await asyncio.sleep(0)
    return 42

value = asyncio.run(compute())
print(value)   # 42

# For advanced use:
loop = asyncio.new_event_loop()
result = loop.run_until_complete(compute())
loop.close()

await pausiert die Ausführung

await expr unterbricht die aktuelle Koroutine, bis expr (eine andere Koroutine oder ein Future) abgeschlossen ist. Währenddessen führt die Event Loop andere Tasks aus.

import asyncio

async def task(name, delay):
    print(f"{name} starting")
    await asyncio.sleep(delay)
    print(f"{name} done")

async def main():
    await task("A", 2)
    await task("B", 1)   # sequential here

asyncio.run(main())

asyncio.sleep()

asyncio.sleep(seconds) unterbricht die aktuelle Koroutine für die angegebene Zeit, ohne die Event Loop zu blockieren.

import asyncio

async def heartbeat():
    while True:
        print("ping")
        await asyncio.sleep(1)

# asyncio.run(heartbeat())  # runs forever

asyncio.run() als Einstiegspunkt

asyncio.run(coro) ist der standardmäßige Einstiegspunkt auf oberster Ebene. Rufen Sie die Funktion niemals innerhalb einer laufenden Event Loop auf.

import asyncio

async def main():
    print("running")

if __name__ == "__main__":
    asyncio.run(main())

Prüfen, ob eine Event Loop ausgeführt wird

Verwenden Sie asyncio.get_running_loop(), um zu erkennen, ob bereits eine Loop ausgeführt wird (löst RuntimeError aus, wenn dies nicht der Fall ist).

import asyncio

async def inner():
    loop = asyncio.get_running_loop()
    print(f"Loop: {loop}")

asyncio.run(inner())

Blockierenden Code ausführen

Führen Sie CPU-gebundenen oder blockierenden I/O-Code mit loop.run_in_executor(None, func, *args) aus, ohne die Event Loop zu blockieren.

import asyncio, time

def blocking():
    time.sleep(2)
    return "done"

async def main():
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, blocking)
    print(result)

asyncio.run(main())

Koroutinen verketteten

Koroutinen können andere Koroutinen mit await aufrufen und so eine Kette bilden. Der Kontrollfluss läuft die Kette hinab und kehrt zurück, sobald jede Ebene abgeschlossen ist.

import asyncio

async def fetch_data():
    await asyncio.sleep(1)
    return {"value": 42}

async def process():
    data = await fetch_data()
    return data["value"] * 2

async def main():
    result = await process()
    print(result)   # 84

asyncio.run(main())

Koroutinen erkennen

Verwenden Sie asyncio.iscoroutine(obj) oder asyncio.iscoroutinefunction(func), um asynchrone Funktionen zur Laufzeit zu untersuchen.

import asyncio

async def my_coro():
    pass

print(asyncio.iscoroutinefunction(my_coro))   # True
coro = my_coro()
print(asyncio.iscoroutine(coro))              # True
coro.close()   # clean up the un-awaited coroutine

Debugging-Modus von asyncio

Aktivieren Sie den Debugging-Modus, um nicht erwartete Koroutinen, langsame Callbacks und andere Probleme zu erkennen: Setzen Sie PYTHONASYNCIODEBUG=1 oder übergeben Sie debug=True an asyncio.run.

import asyncio

async def main():
    pass

asyncio.run(main(), debug=True)

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Schnelltest

Was macht asyncio.run(coro)?

Zusammenfassung

Definieren Sie Koroutinen mit async def, führen Sie sie mit asyncio.run() aus und unterbrechen Sie sie mit await. Die Event Loop plant Koroutinen kooperativ ein und führt andere aus, während eine auf I/O wartet.

Häufig gestellte Fragen

Ist die Lektion „Coroutinen und die Ereignisschleife“ kostenlos?

Ja — der vollständige Text von „Coroutinen und die Ereignisschleife“ 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 „Coroutinen und die Ereignisschleife“?

Definieren Sie Coroutinen mit async def und führen Sie sie mit asyncio.run() aus. 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 1 von 4.

Wie lange dauert die Lektion „Coroutinen und die Ereignisschleife“?

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

Coroutinen und die Ereignisschleife
await, Tasks und Zusammenfassen
Asynchrone Kontextmanager und Iteratoren
Asynchrone I/O-Muster in der Praxis

← Zurück zu Python Academy