Opfrisser: async/await in Python
Herhaal de kernconcepten van asynchrone programmering in Python, waaronder event loops en coroutines.
Opfrisser: async/await in Python is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Introductie tot asynchroon programmeren met Python
Welkom in de wereld van asynchroon programmeren met Python! Hiermee kunnen je programma's meerdere dingen doen zonder te wachten tot elke taak is voltooid voordat de volgende begint.
Dit is bijzonder nuttig voor taken waarbij je moet wachten, zoals netwerkaanvragen of het lezen en schrijven van bestanden. Anders zou je programma alleen maar inactief wachten.
Synchroon versus asynchroon: het wachtspel
Stel je voor dat je het avondeten kookt:
- Synchroon: Je snijdt groenten, wacht tot ze gaar zijn en wast daarna de afwas. Er gebeurt steeds maar één taak tegelijk.
- Asynchroon: Je snijdt groenten, zet ze op het fornuis en begint tijdens het koken (het wachten) de afwas te doen. Je doet meerdere dingen 'gelijktijdig' door tussen taken te wisselen wanneer er één moet wachten.
Asynchroon programmeren helpt je programma actief te blijven in plaats van te wachten!
Het sleutelwoord `async`: coroutines
In Python gebruiken we het sleutelwoord async om een speciaal type functie te definiëren dat een coroutine wordt genoemd. Een coroutine is een functie die kan worden gepauzeerd en hervat.
De functie wordt niet onmiddellijk uitgevoerd wanneer je haar aanroept. In plaats daarvan geeft ze een 'coroutine-object' terug dat door een gebeurtenislus moet worden ingepland om te worden uitgevoerd.
import asyncio
async def hello_world():
print("Hello, async world!")
# Calling it directly doesn't run it!
# It returns a coroutine object.
coro_obj = hello_world()
print(f"Type of coro_obj: {type(coro_obj)}")
# To actually run it, you need an event loop.
# We'll see how in a moment!
`await`: uitvoering pauzeren
Het sleutelwoord await wordt binnen een functie async def (een coroutine) gebruikt om de uitvoering ervan te pauzeren totdat een andere awaitable, zoals een andere coroutine of een Future, is voltooid.
Wanneer een coroutine iets await, geeft ze tijdelijk de controle terug aan de gebeurtenislus, zodat andere taken kunnen worden uitgevoerd. Dit is essentieel voor niet-blokkerend gedrag.
import asyncio
async def cook_rice():
print("Starting to cook rice...")
await asyncio.sleep(2) # Simulate 2 seconds of cooking
print("Rice is cooked!")
async def chop_veg():
print("Chopping vegetables...")
await asyncio.sleep(1) # Simulate 1 second of chopping
print("Vegetables chopped!")
async def main_meal():
await chop_veg() # Wait for chopping to finish
await cook_rice() # Then wait for rice to cook
print("Dinner is ready!")
# This will run sequentially for now.
# We'll make it concurrent soon!
asyncio.run(main_meal())
De gebeurtenislus: de orkestleider
Zie de gebeurtenislus als de dirigent van een orkest. Deze is verantwoordelijk voor:
- Inplannen wanneer coroutines worden uitgevoerd.
- Afhandelen van I/O-gebeurtenissen, zoals binnenkomende netwerkgegevens.
- Wisselen tussen taken wanneer er één moet wachten, bijvoorbeeld door
await.
De module asyncio van Python biedt de infrastructuur voor de gebeurtenislus.
Asynchrone code uitvoeren met `asyncio.run()`
Om een asynchroon programma uit te voeren, gebruik je meestal asyncio.run(). Deze functie:
- Haalt een gebeurtenislus op voor de huidige thread.
- Voert de opgegeven coroutine uit totdat deze is voltooid.
- Beheert de levensduur van de gebeurtenislus.
Dit is de eenvoudigste manier om je asynchrone hoofdfunctie te starten.
import asyncio
async def say_hello():
print("Hello from coroutine!")
await asyncio.sleep(0.5) # Wait for 0.5 seconds
print("Goodbye from coroutine!")
async def main():
print("Starting async program...")
await say_hello()
print("Async program finished.")
# This is the entry point for your async application
asyncio.run(main())
Niet-blokkerende bewerkingen simuleren
asyncio.sleep() is een 'awaitable' die de huidige coroutine gedurende een opgegeven tijd pauzeert. Belangrijk is dat deze functie niet het hele programma blokkeert. Terwijl één coroutine slaapt, kan de gebeurtenislus overschakelen naar andere coroutines en die uitvoeren.
Zo bereikt asynchroon programmeren gelijktijdigheid zonder dat er meerdere threads nodig zijn.
import asyncio
import time
async def task_one():
print(f"Task One started at {time.strftime('%X')}")
await asyncio.sleep(2)
print(f"Task One finished at {time.strftime('%X')}")
async def task_two():
print(f"Task Two started at {time.strftime('%X')}")
await asyncio.sleep(1)
print(f"Task Two finished at {time.strftime('%X')}")
async def main():
start_time = time.monotonic()
await task_one()
await task_two()
end_time = time.monotonic()
print(f"Total time: {end_time - start_time:.2f} seconds")
asyncio.run(main())
Gelijktijdige uitvoering met `asyncio.gather`
Om meerdere coroutines echt gelijktijdig uit te voeren (wat betekent dat ze hun uitvoering kunnen afwisselen wanneer één ervan await gebruikt), gebruiken we asyncio.gather().
asyncio.gather() neemt meerdere awaitables aan, plant ze in om 'parallel' op de gebeurtenislus te worden uitgevoerd en wacht totdat ze allemaal zijn voltooid.
import asyncio
import time
async def fetch_data(delay, name):
print(f"Fetching {name} data... (starts at {time.strftime('%X')})")
await asyncio.sleep(delay) # Simulate network request
print(f"Finished {name} data. (ends at {time.strftime('%X')})")
return f"Data from {name}"
async def main():
start_time = time.monotonic()
# Run fetch_data for 'users' and 'products' concurrently
user_data, product_data = await asyncio.gather(
fetch_data(2, "users"),
fetch_data(1, "products")
)
end_time = time.monotonic()
print(f"\nReceived: {user_data}, {product_data}")
print(f"Total time: {end_time - start_time:.2f} seconds")
asyncio.run(main())
Controle van async/await-concepten
Welke van de volgende beweringen over de sleutelwoorden async en await van Python zijn WAAR?
Opfrissing en volgende stappen
Geweldig! Je hebt je kennis van de asynchrone basisprincipes van Python opgefrist:
- Asynchroon programmeren helpt I/O-gebonden taken efficiënt te beheren.
async defdefinieert coroutines, functies die kunnen worden gepauzeerd.awaitpauzeert een coroutine en geeft de controle door aan de gebeurtenislus.- De gebeurtenislus coördineert de uitvoering van coroutines.
asyncio.run()start je asynchrone toepassing.asyncio.gather()maakt het mogelijk meerdere coroutines gelijktijdig uit te voeren.
Vervolgens bekijken we hoe FastAPI deze krachtige concepten gebruikt om krachtige web-API's te bouwen!
Leer Bootcamp backendontwikkeling met FastAPI 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
- 21
- Lessen
- 84
Veelgestelde vragen
Is de les “Opfrisser: async/await in Python” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “Opfrisser: async/await in Python”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Wat leer ik in “Opfrisser: async/await in Python”?
Herhaal de kernconcepten van asynchrone programmering in Python, waaronder event loops en coroutines. Je oefent met Bootcamp backendontwikkeling met FastAPI 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 Bootcamp backendontwikkeling met FastAPI te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI 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 “Opfrisser: async/await in Python”?
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 Bootcamp backendontwikkeling met FastAPI?
Ja. Elke les over Bootcamp backendontwikkeling met FastAPI 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
- Opfrisser: async/await in Python
- FastAPI en asynchrone bewerkingen
- Backgroundtasks uitvoeren
- WebSockets voor realtimecommunicatie