Asynchrone verwerking in Python

Dit artikel legt uit hoe asynchrone verwerking in Python werkt.

Je kunt codevoorbeelden leren voor het basisgebruik van Python's async/await en de asyncio module.

YouTube Video

Asynchrone verwerking in Python

Asynchrone verwerking in Python is een mechanisme om efficiënt tijdrovende I/O-bewerkingen af te handelen, zoals het lezen en schrijven van bestanden of netwerkcommunicatie. Bij synchrone verwerking wacht de volgende bewerking totdat de huidige voltooid is, maar met asynchrone verwerking kun je tijdens het wachten doorgaan met andere taken. In Python is de module asyncio beschikbaar voor het uitvoeren van asynchrone verwerking. Hier leggen we de basiselementen ervan uit en hoe je ze stap voor stap gebruikt.

Basis Syntax

De kern van asynchrone verwerking wordt gevormd door functies die coroutines worden genoemd. async functies definiëren asynchrone functies, en await wordt gebruikt om te wachten op een asynchrone taak binnen die functies.

 1import asyncio
 2
 3async def say_hello():
 4    print("Hello")
 5    await asyncio.sleep(1)
 6    print("World")
 7
 8if __name__ == "__main__":
 9    # Execute asynchronous task
10    asyncio.run(say_hello())

• In de bovenstaande code wordt de functie say_hello gedefinieerd als een asynchrone taak. Tijdens het wachten van 1 seconde met sleep(), kunnen andere asynchrone taken worden uitgevoerd.

Meerdere taken uitvoeren

Door de functie gather van de module asyncio te gebruiken, kun je meerdere taken tegelijkertijd uitvoeren.

 1import asyncio
 2
 3async def task1():
 4    print("Task 1 started")
 5    await asyncio.sleep(2)
 6    print("Task 1 completed")
 7
 8async def task2():
 9    print("Task 2 started")
10    await asyncio.sleep(1)
11    print("Task 2 completed")
12
13async def main():
14    await asyncio.gather(task1(), task2())
15
16if __name__ == "__main__":
17    asyncio.run(main())

• In dit voorbeeld worden task1 en task2 gelijktijdig uitgevoerd. Als resultaat is task2 de eerste van de twee taken die voltooid wordt, maar de totale uitvoeringstijd is gelijk aan de uitvoeringstijd van de langste taak.

Foutenafhandeling

Foutafhandeling is belangrijk, zelfs bij asynchrone verwerking. Je kunt fouten opvangen en afhandelen met behulp van de standaard try-except syntax.

 1import asyncio
 2
 3async def faulty_task():
 4    raise Exception("An error occurred")
 5
 6async def main():
 7    try:
 8        await faulty_task()
 9    except Exception as e:
10        print(f"Caught an error: {e}")
11
12if __name__ == "__main__":
13    asyncio.run(main())

• Deze code laat zien hoe uitzonderingen die binnen asynchrone functies optreden kunnen worden opgevangen met try-except en hoe hun foutmeldingen veilig kunnen worden afgehandeld. De uitzondering van faulty_task wordt binnen main opgevangen en vervolgens correct weergegeven.

Samenvatting

Asynchrone verwerking in Python gebruikt async / await en asyncio om andere taken gelijktijdig uit te voeren tijdens het wachten op I/O, waardoor efficiënte verwerking mogelijk wordt. Door gelijktijdige uitvoering van meerdere taken en asynchrone I/O te benutten, kun je de prestaties aanzienlijk verbeteren. Bovendien kun je fouten afhandelen zoals bij een gewone try-except, waardoor je asynchrone code veilig kunt uitvoeren.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video