Méthodes populaires d'asyncio

4.1 Méthode run()

Le module asyncio offre de nombreuses méthodes et fonctions pour créer et gérer des programmes asynchrones. Voici quelques-unes des méthodes et fonctions les plus populaires et fréquemment utilisées du module asyncio.

Aujourd'hui, on va regarder les 4 plus courantes :

• run()
• sleep()
• wait()
• gather()

Et maintenant, en détail :

Méthode asyncio.run(coroutine)

Cette méthode est utilisée pour exécuter un programme asynchrone. Elle est particulièrement utile quand tu veux exécuter du code asynchrone depuis un contexte synchrone, comme à partir du thread principal de ton programme.

La méthode asyncio.run() démarre la coroutine principale et gère la création et la fermeture de la boucle d'événements. Cette méthode crée automatiquement une nouvelle boucle d'événements et la termine une fois l'exécution de la coroutine achevée.

Signature :

asyncio.run(async_function(), *, debug=False)
        

• async_function: La coroutine à exécuter.
• debug: Paramètre optionnel pour activer le mode débogage pour la boucle d'événements.

Exemple d'utilisation :

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')
            
asyncio.run(main())
        

Limitations

Ne peut pas être appelé depuis une autre boucle d'événements :

asyncio.run() doit être appelé uniquement depuis du code synchrone, car il crée et ferme sa propre boucle d'événements. Si tu essaies de l'appeler depuis une boucle d'événements déjà existante, ça va provoquer une erreur.

S'applique uniquement au niveau supérieur :

Cette méthode est conçue pour exécuter le point d'entrée principal du programme et ne doit pas être utilisée pour des appels imbriqués de fonctions asynchrones.

4.2 Méthode sleep()

Cette méthode est utilisée quand tu dois suspendre l'exécution d'une coroutine pendant un certain temps, sans bloquer l'exécution des autres coroutines.

La méthode asyncio.sleep() dans le module asyncio est utilisée pour suspendre l'exécution de la coroutine actuelle pendant un nombre de secondes donné.

Cette méthode diffère de la méthode time.sleep() similaire puisqu'elle permet à d'autres tâches de s'exécuter pendant la suspension. Cela la rend utile pour écrire des programmes asynchrones nécessitant des délais ou des attentes sans bloquer le thread principal.

Signature :

asyncio.sleep(delay, result=None)
        

• delay: Temps de suspension en secondes (peut être un chiffre décimal).
• result: Résultat optionnel qui sera retourné après la fin de la suspension.

Exemple d'application :

import asyncio

async def main():
    print('Start sleeping')
    await asyncio.sleep(2)
    print('Wake up')
            
asyncio.run(main())
        

Dans cet exemple, la coroutine main est suspendue pendant 2 secondes, permettant à d'autres tâches de s'exécuter pendant ce temps, puis continue et affiche "Wake up".

4.3 Méthode wait()

Cette méthode est utile quand tu dois attendre la fin de plusieurs opérations asynchrones, mais que tu veux avoir un contrôle plus fin sur le processus d'attente.

La méthode asyncio.wait() dans le module asyncio permet d'attendre la fin de plusieurs tâches asynchrones ou coroutines. Tu peux attendre la fin de toutes les tâches, de la première tâche terminée ou de la fin d'une tâche avec une erreur.

Contrairement à gather(), la méthode wait() offre plus de contrôle sur le processus d'attente, en permettant de définir un timeout et des conditions de fin.

Caractéristiques principales de la méthode asyncio.wait()

Signature :

asyncio.wait(fs, *, timeout=None, return_when=ALL_COMPLETED)
        

Où :

• fs: Collection d'objets Future ou de coroutines à attendre.
• timeout: Paramètre optionnel, indiquant le temps maximum d'attente en secondes. Si le temps d'attente est écoulé, la méthode retourne les tâches qui ont été terminées à ce moment-là.
• return_when: Condition définissant quand la méthode doit se terminer. Valeurs possibles :
  • ALL_COMPLETED: La méthode retourne le résultat quand toutes les tâches sont terminées (par défaut).
  • FIRST_COMPLETED: La méthode retourne le résultat quand la première tâche est terminée.
  • FIRST_EXCEPTION: La méthode retourne le résultat quand n'importe quelle tâche se termine avec une exception.

Attend la fin de plusieurs tâches ou coroutines. Tu peux spécifier le temps d'attente et les conditions de fin.

import asyncio

async def say(what, delay):
    await asyncio.sleep(delay)
    return what
            
async def main():
    task1 = asyncio.create_task(say('hello', 1)) 
    task2 = asyncio.create_task(say('world', 2))
    done, pending = await asyncio.wait([task1, task2], timeout=1.5)
    for task in done:
        print(task.result())
            
asyncio.run(main())
        

Dans l'exemple ci-dessus, on encapsule chaque coroutine say() dans un objet Task en utilisant l'appel de la méthode create_task(), puis on passe la liste de ces tâches à la méthode wait(). Les objets Task permettent d'exécuter les coroutines parallèlement, sans attendre que l'une soit terminée avant de démarrer l'autre.

La méthode wait attendra l'achèvement des tâches seulement une seconde et demie, après quoi elle retournera un tuple de tâches : la première valeur du tuple contiendra les tâches qui ont pu s'exécuter (done), la seconde celles qui sont encore en cours (pending).

4.4 Méthode gather()

Cette méthode est particulièrement utile quand tu dois lancer plusieurs opérations asynchrones en parallèle et obtenir leurs résultats sous forme de liste.

La méthode asyncio.gather() dans le module asyncio est utilisée pour exécuter plusieurs tâches asynchrones en parallèle et retourner leurs résultats sous forme de liste. C'est un moyen pratique de grouper les coroutines ou les tâches et d'attendre leur achèvement.

Caractéristiques principales de la méthode asyncio.gather()

Signature :

asyncio.gather(*coros_or_futures, return_exceptions=False)
        

Où :

• coros_or_futures: Coroutines ou objets Future à exécuter.
• return_exceptions: Valeur booléenne indiquant si les exceptions doivent être retournées comme résultats. Par défaut False.

Exemple d'utilisation

import asyncio

async def say_after(delay, what):
    await asyncio.sleep(delay)
    return what
            
async def main():
    results = await asyncio.gather(
        say_after(1, 'hello'),
        say_after(2, 'world')
    )
    print(results)
            
asyncio.run(main())
        

Cet exemple montre comment asyncio.gather peut être utilisé pour exécuter plusieurs tâches en parallèle, chacune ayant son propre délai. Les résultats de toutes les tâches sont retournés sous forme de liste. Contrairement à wait, gather n'attend pas simplement la fin des tâches, mais collecte les résultats de toutes les coroutines, ce qui le rend pratique quand le résultat de chaque tâche est important.