Coroutines Maken en Uitvoeren

Om te beginnen met asynchrone programmeren in Python, is het belangrijk om coroutines te begrijpen. Een coroutine is een speciale functie die wordt gedefinieerd met async def. Coroutines maken het mogelijk om de uitvoering te pauzeren en te hervatten, waardoor taken zoals wachten op invoer/uitvoer-operaties - zoals het lezen van bestanden, netwerkverzoeken of databasequery's - kunnen worden afgehandeld zonder het hele programma te blokkeren. Dit betekent dat terwijl de ene taak op gegevens wacht, andere taken kunnen doorgaan, wat de efficiëntie en responsiviteit verbetert.

Om een coroutine uit te voeren, gebruik je asyncio.run, waarmee een event loop wordt gestart, je coroutine wordt uitgevoerd en de loop wordt gesloten zodra deze klaar is. Dit is de standaardmethode om asynchrone code te starten in modern Python.

Als je meer dan één coroutine tegelijk wilt uitvoeren, kun je asyncio.gather gebruiken om ze gelijktijdig te plannen. Hiermee kan je programma meerdere taken starten en wachten tot ze allemaal klaar zijn, wat vooral handig is bij langzame operaties zoals I/O.

De volgende code demonstreert deze concepten.

import asyncio

async def greet(name, delay):
    await asyncio.sleep(delay)
    print(f"Hello, {name}!")

async def main():
    # Schedule two coroutines to run concurrently
    await asyncio.gather(
        greet("Alice", 2),
        greet("Bob", 1)
    )

asyncio.run(main())

Verwacht resultaat:

Hello, Bob!
Hello, Alice!

De begroeting van Bob verschijnt als eerste omdat deze een kortere vertraging (1 seconde) heeft dan die van Alice (2 seconden).

De greet-coroutine wordt aangemaakt met async def, waardoor deze de uitvoering kan pauzeren met await asyncio.sleep(delay) voordat een begroeting wordt afgedrukt. De main-coroutine plant twee instanties van greet in: één voor "Alice" met een vertraging van 2 seconden en één voor "Bob" met een vertraging van 1 seconde, met behulp van asyncio.gather. Dit betekent dat beide begroetingen gelijktijdig worden afgehandeld, zodat het programma niet wacht tot de ene klaar is voordat de andere start. Ten slotte start asyncio.run(main()) de event loop, voert de main-coroutine uit en zorgt ervoor dat alles daarna wordt opgeruimd. Deze aanpak maakt het mogelijk om meerdere taken die wachten vereisen (zoals netwerkverzoeken of tijdvertragingen) tegelijkertijd af te handelen, waardoor je programma efficiënter en responsiever wordt.