Traitement asynchrone en Python

Cet article explique le traitement asynchrone en Python.

Vous pouvez apprendre des exemples de code pour l'utilisation de base des async/await de Python et du module asyncio.

YouTube Video

Traitement asynchrone en Python

Le traitement asynchrone en Python est un mécanisme permettant de gérer efficacement les opérations d'E/S longues, telles que la lecture et l'écriture de fichiers ou la communication réseau. Dans le traitement synchrone, l'opération suivante attend que la précédente soit terminée, mais avec le traitement asynchrone, vous pouvez effectuer d'autres tâches pendant le temps d'attente. En Python, le module asyncio est fourni pour effectuer un traitement asynchrone. Ici, nous allons expliquer ses éléments de base et comment les utiliser étape par étape.

Syntaxe de base

Au cœur du traitement asynchrone, on trouve des fonctions appelées coroutines. Les fonctions async définissent des fonctions asynchrones, et await est utilisé pour attendre une tâche asynchrone au sein de ces fonctions.

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

• Dans le code ci-dessus, la fonction say_hello est définie comme une tâche asynchrone. Pendant l'attente d'une seconde avec sleep(), d'autres tâches asynchrones peuvent être exécutées.

Exécution de plusieurs tâches

En utilisant la fonction gather du module asyncio, vous pouvez exécuter plusieurs tâches simultanément.

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

• Dans cet exemple, task1 et task2 sont exécutés en parallèle. En conséquence, task2 se termine en premier parmi les deux tâches, mais le temps total d'exécution correspond au temps d'exécution de la tâche la plus longue.

Gestion des erreurs

La gestion des erreurs est importante même dans le traitement asynchrone. Vous pouvez intercepter et gérer les erreurs en utilisant la syntaxe standard try-except.

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

• Ce code montre comment les exceptions qui se produisent à l'intérieur des fonctions asynchrones peuvent être capturées avec try-except et leurs messages d’erreur gérés en toute sécurité. L'exception provenant de faulty_task est interceptée dans main et correctement affichée.

Résumé

Le traitement asynchrone en Python utilise async / await et asyncio pour exécuter d'autres tâches simultanément pendant l'attente liée aux entrées/sorties, ce qui permet un traitement efficace. En tirant parti de l'exécution concurrente de plusieurs tâches et des E/S asynchrones, vous pouvez considérablement améliorer les performances. De plus, comme vous pouvez gérer les erreurs de la même manière qu’avec un try-except classique, vous pouvez exécuter du code asynchrone en toute sécurité.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video