PricingLoginStart free
Python Academy · Les

await, taken en verzamelen

Gebruik await, asyncio.create_task en asyncio.gather voor concurrency.

Les 2 van 413 stappen

await, taken en verzamelen is een gratis Python Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

await versus sequentieel

Alleen await gebruiken voert coroutines sequentieel uit. Als je ze gelijktijdig wilt uitvoeren, verpak je ze 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 een coroutine in als een onafhankelijke Task die gelijktijdig met de huidige coroutine wordt uitgevoerd.

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) voert coroutines gelijktijdig uit en geeft alle resultaten in volgorde terug zodra ze allemaal zijn voltooid.

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 met return_exceptions

Stel return_exceptions=True in, zodat een mislukte coroutine haar uitzondering als resultaat teruggeeft in plaats van de hele gather te annuleren.

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=...) retourneert twee verzamelingen: done en pending. Gebruik FIRST_COMPLETED om op het eerste resultaat te reageren.

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()

Taken annuleren

Roep task.cancel() aan om annulering aan te vragen. De taak ontvangt asyncio.CancelledError bij het volgende await-punt.

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+

Wikkel een await in met asyncio.timeout(seconds) om de bewerking te annuleren als die te lang duurt.

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()

Gebruik op Python < 3.11 asyncio.wait_for(coro, timeout=N) om een time-out toe te voegen, waarbij asyncio.TimeoutError wordt opgegooid.

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")

Taaknamen en inspectie

Geef taken een naam om het opsporen van fouten te vereenvoudigen met asyncio.create_task(coro, name="...") en inspecteer ze met 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 maakt een gestructureerde groep taken. Als een taak een fout veroorzaakt, worden ze allemaal geannuleerd.

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

Semaphores voor snelheidsbeperking

Gebruik asyncio.Semaphore(n) om het aantal gelijktijdige bewerkingen te beperken (bijvoorbeeld API-aanroepen).

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

Korte controle

Wat is het verschil tussen await coro() en asyncio.create_task(coro())?

Beantwoord dit in de interactieve les

Samenvatting

Gebruik create_task of gather voor gelijktijdige uitvoering. gather verzamelt alle resultaten; wait biedt fijnmazige controle. Annuleer taken met .cancel() en pas time-outs toe met wait_for of asyncio.timeout.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
76
Lessen
320
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “await, taken en verzamelen” gratis?

Ja — de volledige tekst van “await, taken en verzamelen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “await, taken en verzamelen”?

Gebruik await, asyncio.create_task en asyncio.gather voor concurrency. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “await, taken en verzamelen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Coroutines en de event loop
  2. await, taken en verzamelen
  3. Async-contextmanagers en -iterators
  4. Async-I/O-patronen in productie
← Terug naar Python Academy