0Pricing
Python Academy · Lektion

await, Tasks und Zusammenfassen

Verwenden Sie await, asyncio.create_task und asyncio.gather für nebenläufige Abläufe.

await, Tasks und Zusammenfassen ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

await vs. sequenziell

Die alleinige Verwendung von await führt Koroutinen nacheinander aus. Um sie nebenläufig auszuführen, verpacken Sie sie in Tasks.

import asyncio

async def main():
    # Sequential — total ~3 s
    await asyncio.sleep(2)
    await asyncio.sleep(1)

    # Concurrent using gather — total ~2 s
    await asyncio.gather(asyncio.sleep(2), asyncio.sleep(1))

asyncio.create_task()

asyncio.create_task(coro) plant eine Koroutine als unabhängigen Task ein, der neben der aktuellen Koroutine ausgeführt wird.

import asyncio

async def work(n):
    await asyncio.sleep(n)
    return n

async def main():
    t1 = asyncio.create_task(work(2))
    t2 = asyncio.create_task(work(1))
    r1 = await t1
    r2 = await t2
    print(r1, r2)   # 2 1 (total ~2 s)

asyncio.run(main())

asyncio.gather()

asyncio.gather(*coros) führt Koroutinen nebenläufig aus und gibt alle Ergebnisse in ihrer Reihenfolge zurück, sobald alle abgeschlossen sind.

import asyncio

async def fetch(i):
    await asyncio.sleep(1)
    return f"data-{i}"

async def main():
    results = await asyncio.gather(fetch(1), fetch(2), fetch(3))
    print(results)  # ["data-1", "data-2", "data-3"] in ~1 s

asyncio.run(main())

gather mit return_exceptions

Setzen Sie return_exceptions=True, damit eine fehlgeschlagene Koroutine ihre Ausnahme als Ergebnis zurückgibt, anstatt die gesamte gather-Ausführung abzubrechen.

import asyncio

async def risky(n):
    if n == 2: raise ValueError("bad")
    return n

async def main():
    results = await asyncio.gather(
        risky(1), risky(2), risky(3),
        return_exceptions=True
    )
    print(results)   # [1, ValueError("bad"), 3]

asyncio.wait()

asyncio.wait(tasks, return_when=...) gibt zwei Mengen zurück: done und pending. Verwenden Sie FIRST_COMPLETED, um auf das erste Ergebnis zu reagieren.

import asyncio

async def slow(): await asyncio.sleep(3); return "slow"
async def fast(): await asyncio.sleep(1); return "fast"

async def main():
    tasks = {asyncio.create_task(slow()), asyncio.create_task(fast())}
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    for t in pending: t.cancel()

Task-Abbruch

Rufen Sie task.cancel() auf, um den Abbruch anzufordern. Der Task erhält am nächsten await-Punkt asyncio.CancelledError.

import asyncio

async def long_job():
    try:
        await asyncio.sleep(100)
    except asyncio.CancelledError:
        print("Cancelled!")
        raise   # re-raise is required

async def main():
    t = asyncio.create_task(long_job())
    await asyncio.sleep(1)
    t.cancel()
    await t

asyncio.timeout() — Python 3.11+

Umschließen Sie einen await-Ausdruck mit asyncio.timeout(seconds), um den Vorgang abzubrechen, wenn er zu lange dauert.

import asyncio

async def main():
    try:
        async with asyncio.timeout(2):
            await asyncio.sleep(10)   # too slow
    except TimeoutError:
        print("Timed out!")

asyncio.wait_for()

Verwenden Sie unter Python < 3.11 asyncio.wait_for(coro, timeout=N), um ein Zeitlimit hinzuzufügen; bei Überschreitung wird asyncio.TimeoutError ausgelöst.

import asyncio

async def slow(): await asyncio.sleep(5)

async def main():
    try:
        await asyncio.wait_for(slow(), timeout=2)
    except asyncio.TimeoutError:
        print("Timed out")

Task-Namen und Inspektion

Benennen Sie Tasks zur einfacheren Fehlersuche mit asyncio.create_task(coro, name="...") und prüfen Sie sie mit task.get_name().

import asyncio

async def worker(): await asyncio.sleep(1)

async def main():
    t = asyncio.create_task(worker(), name="worker-1")
    print(t.get_name())   # worker-1
    await t

TaskGroup — Python 3.11+

asyncio.TaskGroup erstellt eine strukturierte Gruppe von Tasks. Wenn ein Task eine Ausnahme auslöst, werden alle Tasks abgebrochen.

import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(asyncio.sleep(1))
        t2 = tg.create_task(asyncio.sleep(2))
    # all tasks done here

Semaphore zur Ratenbegrenzung

Verwenden Sie asyncio.Semaphore(n), um die Anzahl gleichzeitig ausgeführter Vorgänge zu begrenzen, zum Beispiel API-Aufrufe.

import asyncio

sem = asyncio.Semaphore(5)  # max 5 concurrent

async def limited_fetch(url):
    async with sem:
        await fetch(url)   # at most 5 at a time

Wissenscheck

Was ist der Unterschied zwischen await coro() und asyncio.create_task(coro())?

Zusammenfassung

Verwenden Sie create_task oder gather für die gleichzeitige Ausführung. gather sammelt alle Ergebnisse, während wait eine genau abgestufte Kontrolle ermöglicht. Brechen Sie Tasks mit .cancel() ab und wenden Sie Zeitlimits mit wait_for oder asyncio.timeout an.

Häufig gestellte Fragen

Ist die Lektion „await, Tasks und Zusammenfassen“ kostenlos?

Ja — der vollständige Text von „await, Tasks und Zusammenfassen“ 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 „await, Tasks und Zusammenfassen“?

Verwenden Sie await, asyncio.create_task und asyncio.gather für nebenläufige Abläufe. 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 2 von 4.

Wie lange dauert die Lektion „await, Tasks und Zusammenfassen“?

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

  1. Coroutinen und die Ereignisschleife
  2. await, Tasks und Zusammenfassen
  3. Asynchrone Kontextmanager und Iteratoren
  4. Asynchrone I/O-Muster in der Praxis
← Zurück zu Python Academy