Python Academy · Les

Coroutines en de event loop

Definieer coroutines met async def en voer ze uit met asyncio.run().

Les 1 van 413 stappen

Coroutines en de event loop is een gratis Python Academy-les op CoddyKit. Dit is les 1 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.

Wat is concurrency

Asyncio biedt coöperatieve gelijktijdigheid: één thread verwerkt veel taken door ertussen te schakelen wanneer een taak op I/O wacht.

# 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 — Coroutinefuncties

Functies die met async def zijn gedefinieerd, zijn coroutinefuncties. Als je ze aanroept, geven ze een coroutineobject terug; ze worden pas uitgevoerd wanneer erop wordt gewacht of wanneer ze zijn ingepland.

import asyncio

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

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

De eventloop

De eventloop stuurt de uitvoering van coroutines aan. asyncio.run(coro) maakt een nieuwe eventloop, voert de coroutine volledig uit en sluit de lus.

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 pauzeert de uitvoering

await expr schort de huidige coroutine op totdat expr (een andere coroutine of future) is voltooid. Ondertussen voert de eventloop andere taken uit.

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) schort de huidige coroutine gedurende de opgegeven tijd op zonder de eventloop te blokkeren.

import asyncio

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

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

asyncio.run() als ingangspunt

asyncio.run(coro) is het standaardingangspunt op topniveau. Roep dit nooit aan vanuit een actieve eventloop.

import asyncio

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

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

Controleren of je in een eventloop zit

Gebruik asyncio.get_running_loop() om vast te stellen of er al een eventloop actief is. Als dat niet zo is, wordt RuntimeError opgegooid.

import asyncio

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

asyncio.run(inner())

Blokkerende code uitvoeren

Voer CPU-gebonden of blokkerende I/O-code uit zonder de eventloop te blokkeren met loop.run_in_executor(None, func, *args).

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

Coroutines koppelen

Coroutines kunnen andere coroutines awaiten, waardoor een keten ontstaat. De besturing loopt de keten af en keert terug wanneer elk niveau is voltooid.

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

Coroutines herkennen

Gebruik asyncio.iscoroutine(obj) of asyncio.iscoroutinefunction(func) om asynchrone functies tijdens runtime te inspecteren.

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

Debugmodus van asyncio

Schakel de debugmodus in om niet-afgewachte coroutines, trage callbacks en andere problemen te detecteren: stel PYTHONASYNCIODEBUG=1 in of geef debug=True door aan asyncio.run.

import asyncio

async def main():
    pass

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

# Or:
# PYTHONASYNCIODEBUG=1 python script.py

Korte controle

Wat doet asyncio.run(coro)?

Beantwoord dit in de interactieve les

Samenvatting

Definieer coroutines met async def, voer ze uit met asyncio.run() en schort ze op met await. De eventloop plant coroutines coöperatief in en voert andere coroutines uit terwijl één coroutine op I/O wacht.

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 leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Coroutines en de event loop” gratis?

Ja — de volledige tekst van “Coroutines en de event loop” 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 “Coroutines en de event loop”?

Definieer coroutines met async def en voer ze uit met asyncio.run(). 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 1 van 4.

Hoe lang duurt de les “Coroutines en de event loop”?

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

← Terug naar Python Academy