Création et exécution de coroutines

Pour commencer à travailler avec la programmation asynchrone en Python, il est essentiel de comprendre les coroutines. Une coroutine est une fonction spéciale définie avec async def. Les coroutines permettent de suspendre et de reprendre l'exécution, ce qui rend possible la gestion de tâches telles que l'attente d'opérations d'entrée/sortie — comme la lecture de fichiers, les requêtes réseau ou les requêtes de base de données — sans bloquer l'ensemble du programme. Cela signifie que pendant qu'une tâche attend des données, d'autres tâches peuvent continuer à s'exécuter, améliorant ainsi l'efficacité et la réactivité.

Pour exécuter une coroutine, on utilise asyncio.run, qui démarre une boucle d'événements, exécute la coroutine, puis ferme la boucle une fois terminée. Il s'agit de la méthode standard pour lancer du code asynchrone dans les versions modernes de Python.

Si vous souhaitez exécuter plusieurs coroutines en même temps, vous pouvez utiliser asyncio.gather pour les planifier de manière concurrente. Cela permet à votre programme de démarrer plusieurs tâches et d'attendre que toutes soient terminées, optimisant ainsi le temps, notamment lors d'opérations lentes comme l'I/O.

Le code suivant illustre ces concepts.

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

Résultat attendu :

Hello, Bob!
Hello, Alice!

Le message de Bob apparaît en premier car il utilise un délai plus court (1 seconde) que celui d'Alice (2 secondes).

La coroutine greet est créée avec async def, ce qui lui permet de suspendre son exécution avec await asyncio.sleep(delay) avant d'afficher un message de salutation. La coroutine main planifie deux instances de greet : une pour « Alice » avec un délai de 2 secondes, et une pour « Bob » avec un délai de 1 seconde, en utilisant asyncio.gather. Cela signifie que les deux salutations sont traitées simultanément, donc le programme n'attend pas que l'une se termine avant de commencer l'autre. Enfin, asyncio.run(main()) démarre la boucle d'événements, exécute la coroutine main et s'assure que tout est nettoyé par la suite. Cette approche permet de gérer plusieurs tâches impliquant de l'attente (comme des requêtes réseau ou des délais temporels) en même temps, rendant votre programme plus efficace et réactif.