Les meilleurs clients HTTP Python pour le Web scraping

Les clients HTTP sont des bibliothèques Python utiles qui autorisent votre code à envoyer des requêtes à des serveurs Web ou à des API et à recevoir des réponses. Ils permettent d’envoyer facilement différents types de requêtes HTTP (GET, POST, PUT, DELETE, etc.), de récupérer des données, de soumettre des données ou d’effectuer des actions sur des sites Web ou des API.

En matière de Web scraping, ces clients sont souvent utilisés conjointement aux bibliothèques d’analyse HTML comme Beautiful Soup ou html5lib.

Dans cet article, vous allez examiner certains des meilleurs clients HTTP Python, notamment Requests, urllib3, Uplink, GRequests, HTTPX et aiohttp. Vous évaluerez chacun selon ses fonctionnalités, sa facilité d’utilisation, sa documentation, son support et sa popularité. À la fin de cet article, vous aurez une meilleure idée de la bibliothèque la mieux adaptée à votre cas d’utilisation.

Requests

Commençons par le client HTTP Python le plus populaire : la bibliothèque Requests , avec un impressionnant chiffre de 30 millions de téléchargements par semaine.

Voici un exemple de la façon dont vous pouvez gérer les requêtes et les réponses HTTP à l’aide de Requests :

import requests

print("Testing `requests` library...")
resp = requests.get('https://httpbin.org/get', params={"foo": "bar"})
if resp.status_code == 200:     # success
    print(f"Response Text: {resp.text} (HTTP-{resp.status_code})")
else:   # error
    print(f"Error: HTTP-{resp.status_code}")

Notez que httpbin.org fournit des exemples de réponses pour tester diverses méthodes HTTP.

Dans ce fragment de code, la méthode requests.get (...) utilise l’URL souhaitée et un seul paramètre de requête, foo. Vous pouvez transmettre n’importe quel paramètre de requête à l’aide du paramètre params .

Avec Requests et les autres clients HTTP, vous n’avez pas besoin d’ajouter manuellement des chaînes de requête à vos URL ou de coder vos données ; la bibliothèque les gère pour vous. Pour envoyer des données JSON, vous transmettez un dictionnaire Python à l’aide du paramètre data , et vous pouvez recevoir la réponse JSON directement avec resp.json ().

La bibliothèque Requests gère automatiquement les redirections HTTP (3xx) par défaut, ce qui est utile lors du Web scraping pour accéder au contenu à partir d’URL redirigées. Elle prend également en charge les connexions SSL (Secure Sockets Layer).

Sous le capot, Requests utilise urllib3 pour gérer les tâches HTTP de bas niveau, telles que le regroupement des connexions et la vérification SSL, offrant ainsi une API de niveau supérieur et plus pythonique aux développeurs.

En outre, Requests prend en charge la gestion des sessions , ce qui vous permet de conserver les paramètres, tels que les cookies, les en-têtes ou les jetons d’authentification, sur plusieurs demandes. Cela est particulièrement utile pour les tâches de Web scraping où le maintien de tels paramètres est essentiel pour accéder à du contenu restreint.

La bibliothèque Requests prend également en charge le streaming, ce qui est utile pour les tâches de Web scraping impliquant des réponses volumineuses, telles que le téléchargement de fichiers ou le traitement de données de streaming à partir d’API.

Pour traiter efficacement les données de réponse sans les charger toutes en mémoire, vous pouvez utiliser des méthodes telles que iter_content () ou iter_lines () :

import requests

print("Testing `requests` library with streaming...")
resp = requests.get('https://httpbin.org/stream/10', stream=True)
for chunk in resp.iter_content(chunk_size=1024):
    print(chunk.decode('utf-8'))

Cependant, la bibliothèque Requests ne dispose pas de fonctionnalités asynchrones intégrées et ne prend pas en charge la mise en cache intégrée (bien qu’elle soit disponible via requests-cache). De plus, Requests ne prend pas en charge HTTP/2, et il est peu probable qu’il soit ajouté prochainement, comme indiqué dans cette discussion.

Remarque : HTTP/2 est la version la plus récente du protocole HTTP, conçue pour être plus rapide et plus efficace que HTTP/1.1. Elle permet de multiples demandes et réponses via une seule connexion TCP (Transmission Control Protocol) par multiplexage, ce qui réduit les connexions client-serveur et accélère le chargement des pages. Cependant, la prise en charge de HTTP/2 est encore limitée.

La bibliothèque Requests simplifie les interactions HTTP de Python. Elle se distingue par ses méthodes simples, sa syntaxe concise, sa mise en commun automatique des connexions pour plus d’efficacité et son décodage JSON intégré. Sa facilité d’utilisation, sa gestion des sessions, ses fonctionnalités de streaming et sa documentation complète  en font un choix populaire auprès des développeurs.

urllib3

urllib3 est une bibliothèque bien testée et largement utilisée pour effectuer des requêtes HTTP, non seulement par les développeurs mais également par de nombreux autres clients HTTP. Elle propose des fonctionnalités utiles et des options de personnalisation pour gérer les requêtes HTTP de bas niveau dans le cadre du Web scraping.

Voici un exemple simple qui utilise urllib3 pour effectuer une requête HTTP :

import urllib3

print("Testing `urllib3` library...")
http = urllib3.PoolManager()    # PoolManager for connection pooling
resp = http.request('GET', 'https://httpbin.org/get', fields={"foo": "bar"})

if resp.status == 200:     # success
    print(f"Response: {resp.data.decode('utf-8')} (HTTP-{resp.status})")
else:    # error
    print(f"Error: HTTP-{resp.status}")

Dans cet extrait de code, URLlib3.poolManager () crée un pool de connexions qui peuvent être réutilisées pour plusieurs demandes, améliorant ainsi les performances en évitant les frais liés à l’établissement de nouvelles connexions pour chaque demande. En plus de l’URL, vous pouvez transmettre les paramètres de requête requis à l’aide de son paramètre fields .

L’une des caractéristiques remarquables d’urllib3 est sa capacité à gérer les réponses en streaming, ce qui vous permet de traiter efficacement de grandes quantités de données sans les charger toutes en mémoire. Cela est utile pour télécharger des fichiers volumineux ou utiliser des API de streaming lors du Web scraping.

urllib3 prend en charge la redirection automatique par défaut et dispose d’un support SSL intégré. Cependant, elle ne dispose pas de fonctionnalités asynchrones intégrées, de prise en charge de la mise en cache et de gestion des sessions (comme les cookies), et elle ne prend pas en charge HTTP/2.

Bien que la gestion du regroupement de connexions par urllib3 la rende moins conviviale que la bibliothèque Requests, urllib3 utilise une syntaxe de script simple, contrairement à certains clients qui nécessitent une approche basée sur les classes ou des décorateurs, ce qui rend urllib3 utile pour les interactions HTTP de base. De plus, urllib3 est livrée avec une documentation bien fournie.

Si vous voulez une bibliothèque puissante et que vous n’avez pas besoin de gérer vos sessions, urllib3 est idéale pour les tâches simples de Web scraping.

Uplink

Uplink est un client HTTP Python puissant mais moins connu. Il simplifie les interactions avec les API RESTful à l’aide d’interfaces basées sur les classes, ce qui le rend particulièrement utile pour le Web scraping qui implique des appels d’API.

Regardez cet exemple de code utilisant Uplink pour appeler un point de terminaison d’API :

import uplink

@uplink.json
class JSONPlaceholderAPI(uplink.Consumer):
    @uplink.get("/posts/{post_id}")
    def get_post(self, post_id):
        pass


def demo_uplink():
    print("Testing `uplink` library...")
    api = JSONPlaceholderAPI(base_url="https://jsonplaceholder.typicode.com")
    resp = api.get_post(post_id=1)
    if resp.status_code == 200:     # success
        print(f"Response: {resp.json()} (HTTP-{resp.status_code})")
    else:   # error
        print(f"Error:HTTP-{resp.status_code}")

Cet extrait de code définit une classe JSONPlaceholderAPI qui hérite de la classe Uplink.Consumer. Il utilise le décorateur @uplink .get  pour créer une requête HTTP GET pour l’API JSONPlaceholder afin de récupérer une publication spécifique. Le paramètre post_id est inclus dynamiquement dans le point de terminaison avec ce décorateur : @uplink .get (« /posts/ {post_id} »). Le site https://jsonplaceholder.typicode.com simule une API REST, fournissant des réponses JSON pour les tests et le développement.

Uplink prend en charge le protocole SSL et gère automatiquement les redirections pour récupérer la réponse finale. Il propose également des fonctionnalités avancées telles que Bring Your Own HTTP Library.

Cependant, Uplink ne propose pas de support intégré pour les réponses en streaming, les requêtes asynchrones, la mise en cache (bien qu’il puisse utiliser requests-cache) et HTTP/2.

Uplink fournit une documentation adéquate pour ses puissantes fonctionnalités, mais il n’est pas activement entretenu (la dernière version était la 0.9.7 en mars 2022) et n’est pas très populaire. Bien que son approche basée sur les classes et sa syntaxe de décorateur puissent plaire aux développeurs orientés objet, il n’offre qu’une facilité d’utilisation modérée pour ceux qui préfèrent le style de script de Python.

Les utilisateurs choisissent généralement Uplink lorsqu’ils ont besoin de collecter des données principalement à partir de différents points de terminaison de l’API RESTful et non de pages HTML.

GRequests

GRequests est une extension de la célèbre bibliothèque Requests, qui prend en charge les requêtes asynchrones. Elle permet de récupérer simultanément des données à partir de plusieurs sites Web ou API.

Contrairement aux requêtes séquentielles, qui attendent chaque réponse avant d’envoyer la suivante, GRequests améliore l’efficacité en envoyant des demandes simultanément. Cela est particulièrement utile pour récupérer des données à partir de plusieurs sites Web ou API.

Regardez cet exemple :

import grequests

print("Testing `grequests` library...")
# Fetching data from multiple URLs
urls = [
    'https://www.python.org/',
    'http://httpbin.org/get',
    'http://httpbin.org/ip',
]

responses = grequests.map((grequests.get(url) for url in urls))
for resp in responses:
    print(f"Response for: {resp.url} ==> HTTP-{resp.status_code}")

Dans ce code, GRequests envoie simultanément trois requêtes GET en utilisant grequests.map (...) à différentes URL et rassemble les réponses dans une liste nommée réponses. Ensuite, elle passe en revue ces réponses pour les afficher. En interne, GRequests utilise gevent, une bibliothèque réseau basée sur des coroutines, pour les requêtes HTTP asynchrones. Cela vous permet d’envoyer plusieurs requêtes HTTP simultanément sans gérer une simultanéité complexe. Une application pratique de cette méthode pourrait consister à extraire des actualités de différents sites Web pour un sujet ou une catégorie en particulier.

GRequests prend également en charge des fonctionnalités telles que la gestion automatique des redirections, la prise en charge du protocole SSL et le traitement des réponses en streaming sans les charger toutes en mémoire en même temps. Cependant, gardez à l’esprit que GRequests ne possède pas de support HTTP/2 intégré ni de fonctionnalités de mise en cache, bien qu’il puisse utiliser requests-cache.

GRequests simplifie les requêtes HTTP asynchrones grâce à des méthodes intuitives similaires à sa bibliothèque de base, Requests. Il élimine le besoin de constructions complexes async/wait pour gérer la simultanéité, ce qui le rend facile à utiliser. Cependant, sa documentation  est minimale en raison de sa petite base de code (213 lignes dans sa version 0.7.0) et de ses activités de développement réduites. Ces facteurs contribuent à sa baisse de popularité.

Vous devriez envisager GRequests pour ses fonctionnalités asynchrones faciles à utiliser lorsque vous devez collecter des données provenant de plusieurs sources simultanément.

HTTPS

HTTPX est un client HTTP moderne et riche en fonctionnalités pour Python, largement utilisé pour tous les types de projets de Web scraping. Elle est conçue pour remplacer la bibliothèque Requests de Python tout en fournissant un support asynchrone et de meilleures performances.

L’exemple suivant illustre une requête HTTP GET asynchrone utilisant HTTPX :

import httpx
import asyncio

async def fetch_posts():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://jsonplaceholder.typicode.com/posts')
        return response.json()

async def httpx_demo():
    print("Testing `httpx` library...")
    posts = await fetch_posts()
    for idx, post in enumerate(posts):
        print(f"Post #{idx+1}: {post['title']}")

# async entry point to execute the code
asyncio.run(httpx_demo())

Ce code définit une fonction asynchrone appelée fetch_posts (), qui extrait des articles de blog factices depuis l’API https://jsonplaceholder.typicode.com/posts à l’aide de Httpx.asyncClient (). Une autre fonction asynchrone, httpx_demo (), attend que fetch_posts () renvoie ces publications, puis affiche leurs titres en boucle. Enfin, asyncio.run (httpx_demo ()) sert de point d’entrée pour exécuter httpx_demo () de manière asynchrone.

Outre son support intégré pour les clients HTTP asynchrones, HTTPX propose également un support HTTP/2 intégré. Cela permet de charger plus rapidement plusieurs ressources simultanément via une seule connexion TCP, ce qui rend plus difficile pour les sites Web de suivre l’empreinte de votre navigateur lors du Web scraping.

Pour envoyer une requête HTTP/2, définissez simplement le paramètre http2=True lors de la création d’un client HTTPX :

import httpx

client = httpx.Client(http2=True)
response = client.get("https://http2.github.io/")
print(response)

Gardez à l’esprit que pour utiliser HTTP/2, vous devez installer HTTPX avec son support http2 :

pip install httpx[http2]

En outre, HTTPX fournit une excellente prise en charge des réponses en continu, ce qui vous permet de gérer efficacement des réponses ou des flux de données volumineux sans charger la réponse complète en mémoire.

Voici un exemple de réponse textuelle en streaming à l’aide de HTTPX:

with httpx.stream("GET", "https://httpbin.org/stream/10") as resp:
   for text in resp.iter_text():
       print(text)

Bien que HTTPX n’inclut pas de fonctionnalités de mise en cache intégrées, vous pouvez utiliser Hishel à la place.

HTTPX ne suit pas les redirections HTTP par défaut, mais vous pouvez l’activer avec le paramètre follow_redirects :

import httpx

# test http --> https redirect
response = httpx.get('http://github.com/', follow_redirects=True)

Bien que ses fonctionnalités asynchrones ajoutent une certaine complexité, HTTPX fournit des méthodes simples pour la communication HTTP et prend en charge les requêtes synchrones faciles à utiliser. Cela le rend accessible aux débutants comme aux développeurs expérimentés. De plus, son utilisation ne cesse de croître, grâce à sa documentation complète et à une communauté active de développeurs qui créent des outils pour l’intégration HTTPX.

Si vous recherchez un client HTTP asynchrone riche en fonctionnalités, pensez à HTTPX.

aiotttp

Tout comme HTTPX, aiohttp propose un support asynchrone intégré pour les requêtes HTTP. Cependant, aiohttp est conçu exclusivement pour la programmation asynchrone, ce qui lui permet d’exceller dans les scénarios nécessitant des requêtes simultanées et non bloquantes. Il est donc parfaitement adapté aux projets de Web scraping performants et il est facile à utiliser avec des proxys.

Voici comment utiliser aiohttp pour extraire plusieurs URL simultanément :

import asyncio
import aiohttp

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()    

async def demo_aiohttp():
    print("Testing `aiohttp` library...")
    urls = [
        'https://www.python.org/',
        'http://httpbin.org/get',
        'http://httpbin.org/ip',
    ]
    tasks = [fetch_data(url) for url in urls]
    responses = await asyncio.gather(*tasks)
    for resp_text in responses:
        print(f"Response: {resp_text}")

# async entry point to execute the code      
asyncio.run(demo_aiohttp())

La fonction asynchrone fetch_data (...) crée un AIOHttp.ClientSession () et envoie une requête GET à l’URL spécifiée. Il crée ensuite une liste de tâches pour chaque URL et les exécute simultanément avec asyncio.gather (...). Une fois toutes les tâches exécutées, les données extraites (dans ce cas, le texte de réponse) sont collectées et affichées. L’exécution proprement dite est lancée avec asyncio.run (demo_aiohttp ()).

aiohttp gère automatiquement les redirections HTTP et prend en charge les réponses en streaming, garantissant ainsi une gestion efficace des fichiers volumineux ou des flux de données sans utilisation excessive de la mémoire. Il offre également de la flexibilité grâce à une large gamme d’intergiciels et d’extensions tiers.

En outre, aiohttp peut servir de serveur de développement  si nécessaire, bien que cet article se concentre uniquement sur ses fonctionnalités de client HTTP.

Cependant, aiohttp ne prend pas en charge le HTTP/2 et ne dispose pas de fonctionnalités de mise en cache intégrées. Néanmoins, vous pouvez intégrer la mise en cache à l’aide de bibliothèques telles que aiohttp-client-cache si nécessaire.

aiohttp peut être plus complexe à utiliser que des clients HTTP plus simples tels que Requests, en particulier pour les débutants. Sa nature asynchrone et ses fonctionnalités supplémentaires nécessitent une bonne compréhension de la programmation asynchrone en Python. Cependant, il est très populaire, avec 14 700 étoiles sur GitHub et de nombreuses bibliothèques tierces bâties dessus. aiohttp propose également une documentation complète pour les développeurs.

Si vous recherchez un support asynchrone complet, pensez à aiohttp. Ses performances asynchrones en font un outil idéal pour les tâches de collecte de données en temps réel, telles que la surveillance des cours boursiers ou le suivi d’événements en direct tels que les élections au fur et à mesure de leur déroulement.

Consultez le tableau suivant pour un aperçu rapide des principaux clients HTTP Python:

Conclusion

Dans cet article, vous avez tout appris sur quelques clients HTTP Python populaires, notamment Requests, urllib3, Uplink, GRequests, HTTPX et aiohttp, chacun doté de fonctionnalités uniques telles que la simplicité, le support asynchrone, le streaming et HTTP/2.

Bien que Requests, Uplink et GRequests soient connus pour leur simplicité, aiohttp et HTTPX offrent de puissantes fonctionnalités asynchrones. Bien que Requests reste le plus populaire, aiohttp et HTTPX gagnent du terrain grâce à leurs capacités asynchrones. En fin de compte, vous devrez passer en revue chacune d’entre elles pour choisir celle qui répond le mieux à vos besoins.

En ce qui concerne le Web scraping dans la vie réelle, vous devez prendre en compte bien plus que votre client HTTP, par exemple en contournant les mesures anti-bots et en utilisant des proxys. Heureusement, Bright Data peut vous aider.

Bright Data facilite le Web scraping grâce à des outils tels que l’IDE Web Scraper, qui propose des fonctions et des modèles JavaScript prêts à l’emploi, et le Web Unlocker, qui contourne les CAPTCHA et les mesures anti-bots. Le navigateur Bright Data Scraping s’intègre à Puppeteer, Playwright et Selenium pour la collecte de données en plusieurs étapes. En outre, les réseaux proxy et les servicesde Bright Data  autorisent l’accès depuis différents emplacements. Ces outils gèrent des tâches complexes, telles que la gestion des proxys et la résolution des CAPTCHA, afin que vous puissiez vous concentrer sur l’obtention des données dont vous avez besoin.

Commencez votre essai gratuit dès aujourd’hui et découvrez tout ce que Bright Data a à offrir.