Requêtes HTTP asynchrones en Python avec HTTPX et asyncio

La programmation asynchrone est de plus en plus vitale dans le développement Python. Avec asyncio désormais un composant de bibliothèque standard et de nombreux packages tiers compatibles, ce paradigme est là pour rester. Ce didacticiel montre l'utilisation de la bibliothèque HTTPX pour les requêtes HTTP asynchrones, un cas d'utilisation privilégié pour le code non bloquant.

Qu'est-ce qu'un code non bloquant ?

Des termes tels que « asynchrone », « non bloquant » et « simultané » peuvent prêter à confusion. Essentiellement :

• Les routines asynchrones peuvent « mettre en pause » en attendant les résultats, permettant ainsi à d'autres routines de s'exécuter simultanément.
• Cela crée l'apparence d'une exécution simultanée, même si le véritable parallélisme peut ne pas être impliqué.

Le code asynchrone évite le blocage, permettant à d'autres codes de s'exécuter en attendant les résultats. La bibliothèque asyncio fournit des outils pour cela et aiohttp propose une fonctionnalité de requête HTTP spécialisée. Les requêtes HTTP sont idéales pour l'asynchronicité car elles impliquent d'attendre les réponses du serveur, une période pendant laquelle d'autres tâches peuvent s'exécuter efficacement.

Configuration

Assurez-vous que votre environnement Python est configuré. Reportez-vous à un guide d'environnement virtuel si nécessaire (Python 3.7 est requis). Installer HTTPX :

<code class="language-bash">pip install httpx==0.18.2</code>

Faire une requête HTTP avec HTTPX

Cet exemple utilise une seule requête GET à l'API Pokémon pour récupérer les données de Mew (Pokémon #151) :

<code class="language-python">import asyncio
import httpx

async def main():
    url = 'https://pokeapi.co/api/v2/pokemon/151'
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        pokemon = response.json()
        print(pokemon['name'])

asyncio.run(main())</code>

async désigne une coroutine ; await cède le contrôle à la boucle d'événements, reprenant l'exécution dès la disponibilité des résultats.

Faire plusieurs demandes

Le véritable pouvoir de l'asynchronicité est évident lorsque l'on fait de nombreuses demandes. Cet exemple récupère les données des 150 premiers Pokémon :

<code class="language-python">import asyncio
import httpx
import time

start_time = time.time()

async def main():
    async with httpx.AsyncClient() as client:
        for number in range(1, 151):
            url = f'https://pokeapi.co/api/v2/pokemon/{number}'
            response = await client.get(url)
            pokemon = response.json()
            print(pokemon['name'])

asyncio.run(main())
print(f"--- {time.time() - start_time:.2f} seconds ---")</code>

Chronométrez l'exécution. Comparez cela avec une approche synchrone.

Comparaison des demandes synchrones

L'équivalent synchrone :

<code class="language-python">import httpx
import time

start_time = time.time()
client = httpx.Client()
for number in range(1, 151):
    url = f'https://pokeapi.co/api/v2/pokemon/{number}'
    response = client.get(url)
    pokemon = response.json()
    print(pokemon['name'])

print(f"--- {time.time() - start_time:.2f} seconds ---")</code>

Notez la différence d'exécution. Le regroupement de connexions de HTTPX minimise la disparité, mais asyncio offre une optimisation supplémentaire.

Techniques asynchrones avancées

Pour des performances supérieures, exécutez des requêtes simultanément en utilisant asyncio.ensure_future et asyncio.gather :

<code class="language-python">import asyncio
import httpx
import time

start_time = time.time()

async def fetch_pokemon(client, url):
    response = await client.get(url)
    return response.json()['name']

async def main():
    async with httpx.AsyncClient() as client:
        tasks = [asyncio.ensure_future(fetch_pokemon(client, f'https://pokeapi.co/api/v2/pokemon/{number}')) for number in range(1, 151)]
        pokemon_names = await asyncio.gather(*tasks)
        for name in pokemon_names:
            print(name)

asyncio.run(main())
print(f"--- {time.time() - start_time:.2f} seconds ---")</code>

Cela réduit considérablement le temps d'exécution en exécutant les requêtes simultanément. La durée totale approche la durée de la demande unique la plus longue.

Conclusion

L'utilisation de HTTPX et de la programmation asynchrone améliore considérablement les performances pour plusieurs requêtes HTTP. Ce tutoriel fournit une introduction de base à asyncio ; explorez davantage ses capacités pour améliorer vos projets Python. Pensez à explorer aiohttp pour une gestion alternative des requêtes HTTP asynchrones.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!