Lorsque vous travaillez avec Python pour interagir avec les API web, en particulier lors de la gestion de plusieurs requêtes, vous avez probablement rencontré des délais. Qu'il s'agisse de télécharger des fichiers, d'extraire des données ou de faire des requêtes aux API, attendre que chaque tâche se termine peut considérablement ralentir les choses. C'est là que la programmation asynchrone entre en jeu pour vous sauver la mise, et l'un des meilleurs outils de l'écosystème Python pour cela est la bibliothèque aiohttp.
Si vous n'êtes pas familier avec la programmation asynchrone, ne vous inquiétez pas ! Je vais la décomposer en termes simples et expliquer comment aiohttp peut vous aider à rationaliser vos requêtes web, les rendant plus rapides et plus efficaces.
Avant d'aller plus loin, abordons quelque chose auquel chaque développeur est confronté : les tests d'API. Et si vous êtes comme la plupart des équipes, vous utilisez probablement Postman pour cela.
Je comprends, Postman est un outil familier. Mais soyons honnêtes, n'avons-nous pas tous remarqué qu'il devient de moins en moins attrayant chaque année ? Pourtant, vous êtes là, en équipe, et vous avez besoin d'outils de collaboration pour que le processus de développement se déroule sans heurts. Alors, que faites-vous ? Vous investissez dans Postman Enterprise pour la somme faramineuse de 49 $ par mois.
Mais voici le hic : vous n'êtes pas obligé.
Oui, vous avez bien lu. Il existe un moyen meilleur et plus efficace de gérer les tests d'API et la collaboration d'équipe sans avoir à dépenser autant d'argent dans un outil qui, franchement, n'offre plus ce qu'il offrait autrefois. Explorons de meilleures alternatives !
APIDog : Vous obtenez tout de la version payante de Postman, mais MOINS CHER
C'est exact, APIDog vous offre toutes les fonctionnalités de la version payante de Postman, à une fraction du prix. La migration a été si facile que vous n'avez qu'à cliquer sur quelques boutons, et APIDog fera tout pour vous.
APIDog vaut vraiment le coup. Mais si vous êtes le Tech Lead d'une équipe de développement qui veut vraiment se débarrasser de Postman pour quelque chose de mieux et de moins cher, consultez APIDog !
Qu'est-ce que aiohttp ?
aiohttp est une bibliothèque Python populaire qui vous permet d'écrire des clients et des serveurs HTTP asynchrones. Considérez-la comme la bibliothèque requests de Python, mais turbocompressée avec la puissance de la programmation asynchrone.
Elle est construite sur le framework asyncio de Python, ce qui signifie qu'elle peut gérer un grand nombre de requêtes simultanément sans attendre que chacune d'elles se termine avant de passer à la suivante.
Imaginez que vous êtes dans un café et qu'au lieu d'attendre en file d'attente que chaque commande soit terminée une par une, plusieurs baristas commencent à travailler sur votre commande simultanément.
Avec aiohttp, c'est comme si vous travailliez avec une équipe de baristas, tous en train de préparer du café (ou, dans ce cas, d'extraire des données) en même temps. Le résultat ? Des résultats plus rapides avec moins d'attente.
Pourquoi devriez-vous vous soucier d'aiohttp ?
Parlons des raisons pour lesquelles aiohttp devrait vous intéresser, que vous soyez un débutant en Python, un scientifique des données, un web scraper ou même un développeur chevronné.
- Performance : La principale raison d'utiliser aiohttp est la performance. Si vous devez effectuer plusieurs appels d'API ou requêtes vers un site web, aiohttp peut les gérer simultanément.
Au lieu de les traiter les uns après les autres, vous pouvez exécuter des dizaines, voire des centaines de requêtes en même temps. - Scalabilité : L'extraction de données web ou l'appel de plusieurs API peuvent être un processus lent et bloquant en utilisant la programmation synchrone. Cependant, avec aiohttp, vous pouvez gérer plus de tâches en moins de temps, ce qui signifie que votre application peut gérer une demande accrue ou des ensembles de données plus importants.
- Réduction des temps d'attente : Les programmes synchrones traditionnels doivent attendre qu'une tâche se termine avant de commencer la suivante.
Avec le code asynchrone, les tâches n'ont pas à attendre. Vous pouvez télécharger des données à partir de plusieurs URL à la fois, ce qui réduit considérablement le temps d'exécution global. - Utilisation efficace des ressources : La programmation asynchrone, et aiohttp en particulier, utilise plus efficacement les ressources de votre système.
Au lieu de bloquer un fil d'exécution ou un processus entier en attendant une réponse, aiohttp permet à d'autres tâches de s'exécuter tout en attendant qu'une opération d'E/S se termine.
Comment fonctionne aiohttp ?
Plongeons dans le fonctionnement d'aiohttp en pratique.
Tout d'abord, clarifions ce que signifie réellement la programmation asynchrone. Dans un programme synchrone, chaque tâche doit se terminer avant que la suivante ne commence.
Si vous attendez qu'un serveur web réponde à votre requête, l'ensemble du programme s'arrête jusqu'à ce que cette réponse arrive. La programmation asynchrone permet au programme de continuer à exécuter d'autres tâches tout en attendant la réponse.
aiohttp exploite ce modèle asynchrone pour vous permettre de lancer plusieurs requêtes HTTP à la fois, puis de gérer les réponses au fur et à mesure qu'elles arrivent. Voici un exemple qui le démontre de manière simple :
Comment faire une requête web avec aiohttp : les bases
Ce diagramme (figure 2) compare le flux synchrone (une tâche se termine avant la suivante) et le flux asynchrone (plusieurs tâches s'exécutent simultanément).
Les cases bleues représentent les tâches synchrones, tandis que les cases vertes représentent les tâches asynchrones.
Les flèches indiquent le flux d'exécution pour les processus synchrones et asynchrones.
Visualisation de la boucle d'événements (mécanisme de boucle dans le modèle asynchrone de Python)
Ce diagramme (figure 3) illustre le mécanisme de la boucle d'événements dans le modèle de programmation asynchrone de Python.
Les nœuds représentent différentes étapes, telles que le démarrage des tâches, l'attente des opérations d'E/S et l'exécution des rappels.
Les flèches dirigées montrent comment les tâches sont lancées, comment elles attendent les opérations d'E/S et comment la boucle d'événements gère les rappels et redémarre les tâches.
Récupération simultanée d'URL dans aiohttp
Le diagramme de cas d'utilisation (figure 4) visualise comment aiohttp peut gérer plusieurs requêtes d'URL simultanément. Chaque processus "Fetch URL" est géré simultanément et transmis à un nœud de traitement central.
Ce diagramme montre comment aiohttp peut récupérer simultanément plusieurs URL dans un scénario d'extraction de données web ou de requête d'API.
Diagramme de flux de travail
Le diagramme de flux de travail visualise un pipeline de données de base, montrant les étapes de récupération, de traitement, de nettoyage et de stockage des données.
Exemple : Effectuer des requêtes asynchrones avec aiohttp
import aiohttp
import asyncio
async def fetch_url(session, url):
async with session.get(url) as response:
return await response.text()
async def main():
urls = [
"https://jsonplaceholder.typicode.com/posts/1",
"https://jsonplaceholder.typicode.com/posts/2",
"https://jsonplaceholder.typicode.com/posts/3",
]
async with aiohttp.ClientSession() as session:
tasks = [fetch_url(session, url) for url in urls]
responses = await asyncio.gather(*tasks)
for i, response in enumerate(responses):
print(f"Response {i+1}: {response[:60]}...") # Print first 60 characters of each response
Run the event loop
asyncio.run(main())
Téléchargement du contenu de manière synchrone
Tout d'abord, essayons de le faire de manière synchrone en utilisant la bibliothèque requests. Elle peut être installée en utilisant :
pip.python3.7 -m pip install requests
Le téléchargement d'une ressource en ligne à l'aide de requests est simple.
import requestsresponse = requests.get("https://www.python.org/dev/peps/pep-8010/")print(response.content)
Il affichera le contenu HTML de PEP 8010. Pour l'enregistrer localement dans un fichier :
filename = "sync_pep_8010.html"with open(filename, "wb") as pep_file:pep_file.write(content.encode('utf-8'))Le fichier sync_pep_8010.html sera créé.
Cas d'utilisation concrets pour aiohttp
1. Extraction de données web
Si vous extrayez des données de plusieurs pages d'un site web, attendre que chaque page se charge peut être un processus horriblement lent. Avec aiohttp, vous pouvez extraire des données de plusieurs pages simultanément, ce qui accélère considérablement le processus. Imaginez simplement récupérer des centaines de pages à la fois au lieu d'attendre que chacune se charge en séquence.
2. Requêtes d'API
Lorsque vous travaillez avec des API, en particulier celles qui ont des limites de débit ou qui répondent lentement, vous pouvez envoyer plusieurs requêtes à la fois en utilisant aiohttp. Par exemple, si vous interrogez une API météo pour obtenir des données pour plusieurs villes, aiohttp peut vous aider à rassembler les résultats plus rapidement.
3. Collecte de données
Que vous travailliez avec des données boursières, des flux de médias sociaux ou des sites web d'actualités, aiohttp peut changer la donne pour gérer simultanément des quantités massives de requêtes HTTP, ce qui vous permet de collecter des données plus rapidement et plus efficacement.
Voici trois exemples pratiques d'utilisation de la bibliothèque aiohttp de Python, avec les étapes et l'exemple de code :
1. Effectuer des requêtes HTTP asynchrones
Cet exemple montre comment effectuer plusieurs requêtes HTTP asynchrones à l'aide d'aiohttp.
Étapes :
- Importer les modules nécessaires
- Définir une fonction asynchrone pour récupérer une URL
- Créer une liste d'URL à récupérer
- Mettre en place une boucle d'événements asynchrone
- Exécuter la fonction asynchrone pour chaque URL simultanément
import aiohttp
import asyncio
async def fetch(session, url):
async with session.get(url) as response:
return await response.text()
async def main():
urls = [
'https://api.github.com',
'https://api.github.com/events',
'https://api.github.com/repos/python/cpython'
]
async with aiohttp.ClientSession() as session:
tasks = [fetch(session, url) for url in urls]
responses = await asyncio.gather(*tasks)
for url, response in zip(urls, responses):
print(f"URL: {url}\nResponse length: {len(response)}\n")
asyncio.run(main())
2. Création d'un serveur API simple
Cet exemple montre comment créer un serveur API de base à l'aide d'aiohttp.
Étapes :
- Importer les modules nécessaires
- Définir les gestionnaires de routes
- Créer l'application et ajouter des routes
- Exécuter l'application
from aiohttp import web
async def handle_root(request):
return web.json_response({"message": "Welcome to the API"})
async def handle_users(request):
users = [
{"id": 1, "name": "Alice"},
{"id": 2, "name": "Bob"},
{"id": 3, "name": "Charlie"}
]
return web.json_response(users)
app = web.Application()
app.add_routes([
web.get('/', handle_root),
web.get('/users', handle_users)
])
if __name__ == '__main__':
web.run_app(app)
3. Serveur de chat Websocket
Cet exemple montre comment créer un serveur de chat simple basé sur les websockets à l'aide d'aiohttp.
Étapes :
- Importer les modules nécessaires
- Créer un ensemble pour stocker les websockets actifs
- Définir le gestionnaire de websocket
- Créer l'application et ajouter des routes
- Exécuter l'application
import aiohttp
from aiohttp import web
import asyncio
active_websockets = set()
async def websocket_handler(request):
ws = web.WebSocketResponse()
await ws.prepare(request)
active_websockets.add(ws)
try:
async for msg in ws:
if msg.type == aiohttp.WSMsgType.TEXT:
for client in active_websockets:
if client != ws:
await client.send_str(f"User{id(ws)}: {msg.data}")
elif msg.type == aiohttp.WSMsgType.ERROR:
print(f"WebSocket connection closed with exception {ws.exception()}")
finally:
active_websockets.remove(ws)
return ws
app = web.Application()
app.add_routes([web.get('/ws', websocket_handler)])
if __name__ == '__main__':
web.run_app(app)
Pour tester ce serveur websocket, vous pouvez utiliser un client websocket ou créer une simple page HTML avec JavaScript pour vous connecter au serveur.
Ces exemples présentent différents aspects d'aiohttp, de l'exécution de requêtes asynchrones à la création de serveurs web et à la gestion des websockets. Ils fournissent une base solide pour la création d'applications plus complexes à l'aide de cette puissante bibliothèque.
Pour conclure
Dans le monde actuel axé sur les données, la vitesse est importante, et la capacité à gérer de nombreuses tâches à la fois peut vous donner un avantage. aiohttp est un outil indispensable dans votre boîte à outils Python si vous traitez de l'extraction de données web, des requêtes d'API ou de toute autre tâche qui nécessite d'effectuer de nombreuses requêtes HTTP.
En passant en mode asynchrone, vous gagnez non seulement du temps, mais vous rendez également votre code plus efficace et évolutif.
Donc, si vous cherchez à faire passer vos requêtes web Python au niveau supérieur, essayez aiohttp.
Vous verrez rapidement pourquoi c'est un choix si populaire parmi les développeurs qui traitent des applications gourmandes en E/S.
Avez-vous trouvé cette page utile ? J'espère que c'était un matériel très riche pour vous !
Je vous souhaite le meilleur !
