Itérateurs et générateurs asynchrones

10.1 AsyncIterator

Les itérateurs asynchrones (AsyncIterator) permettent de travailler avec des séquences de données qui produisent des éléments de manière asynchrone. Ils sont utilisés dans les fonctions asynchrones et les coroutines pour itérer sur des données qui peuvent être reçues avec un délai, par exemple, à partir de requêtes réseau, d'opérations d'entrée-sortie asynchrones ou d'autres sources asynchrones.

Itérateur asynchrone

Un itérateur asynchrone doit implémenter deux méthodes :

Méthode __aiter__() :

Cette méthode doit retourner l'itérateur asynchrone lui-même. Elle est analogue à la méthode __iter__() pour les itérateurs synchrones.

Méthode __anext__() :

Cette méthode doit retourner la prochaine valeur de manière asynchrone ou lever une exception StopAsyncIteration si les éléments sont épuisés. Elle est analogue à la méthode __next__() pour les itérateurs synchrones.

Exemple :

import asyncio

class AsyncIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end
        
    def __aiter__(self):
        return self
        
    async def __anext__(self)(self):
        if self.current >= self.end:
            raise StopAsyncIteration
        
        await asyncio.sleep(1)  # Simulation d'un délai asynchrone
        self.current += 1
        return self.current
        
async def main():
    async for number in AsyncIterator(1, 5):
        print(number)
        
asyncio.run(main())

Les itérateurs asynchrones permettent de traiter les données au fur et à mesure qu'elles arrivent, sans bloquer l'exécution d'autres tâches. C'est particulièrement utile pour travailler avec des requêtes réseau et d'autres opérations asynchrones.

L'utilisation des itérateurs asynchrones permet d'écrire un code plus lisible et plus facile à maintenir pour le traitement asynchrone des séquences de données.

10.2 AsyncGenerator

Les générateurs asynchrones permettent de produire des valeurs de manière asynchrone, en utilisant les mots-clés async et await. Ils fonctionnent de manière similaire aux générateurs habituels, mais peuvent suspendre leur exécution pour effectuer des opérations asynchrones.

Création d'un générateur asynchrone

Un générateur asynchrone est défini en utilisant async def et yield. Les générateurs asynchrones peuvent utiliser await à l'intérieur d'eux pour effectuer des opérations asynchrones.

Exemple :

async def async_generator():
    for i in range(3):
        await asyncio.sleep(1)  # Délai asynchrone
        yield i  # Génération de valeur

Utilisation d'un générateur asynchrone

Les générateurs asynchrones sont utilisés à l'intérieur de fonctions asynchrones avec l'opérateur async for.

import asyncio

async def main():
    async for value in async_generator():
        print(value)
            
asyncio.run(main())

Les générateurs asynchrones améliorent la lisibilité et la maintenabilité du code, permettant d'utiliser une construction syntaxique simple async for pour travailler avec des séquences asynchrones.