Les 3 meilleurs clients HTTP Python pour le Web Scraping

Mihnea-Octavian Manolache le 02 Dec 2022

Lorsqu'il s'agit de scraper le web, la variété des clients HTTP python disponibles fait de Python l'un des choix les plus populaires. Mais que sont exactement ces clients HTTP et comment pouvez-vous les utiliser pour construire un scraper web ? Dans l'article d'aujourd'hui, nous allons discuter précisément de ce sujet. À la fin de cet article, vous devriez avoir une bonne compréhension de ce que sont les clients HTTP :

• Qu'est-ce qu'un client HTTP en général ?
• Quels sont les meilleurs clients HTTP en python en 2022 ?
• Pourquoi Python est un excellent choix pour le web scraping ?
• Comment créer un scraper web à l'aide de clients HTTP ?

Que sont les clients HTTP Python et comment les utiliser ?

Pour mieux comprendre comment Internet communique, il faut se familiariser avec le protocole de transfert hypertexte (HTTP). Cependant, nous nous concentrerons aujourd'hui sur les clients HTTP en python. Je partirai donc du principe que vous êtes déjà familiarisé avec HTTP.

D'une manière générale, un client HTTP désigne une instance ou un programme qui facilite la communication avec un serveur. Par exemple, un navigateur web peut être considéré comme un client HTTP. Cependant, en tant que programmeurs, nous utilisons rarement un navigateur réel lorsque nous construisons une application, sauf lorsque nous travaillons sur un scraper web ou lorsque nous faisons nos recherches.

Ceci étant dit, lorsque nous faisons référence aux clients HTTP d'une manière plus programmatique, nous parlons généralement d'une méthode ou d'une instance d'une classe utilisée pour exécuter des requêtes HTTP. Comme Python est sans aucun doute l'un des langages de programmation les plus populaires (et aussi mon préféré), nous allons aujourd'hui discuter des meilleurs clients HTTP Python et de la manière de les mettre en œuvre dans un projet réel.

Comprendre le protocole HTTP

Avant d'aller plus loin, même si je recommande de consulter la documentation HTTP, permettez-moi de passer rapidement en revue certains concepts de base du protocole HTTP. Tout d'abord, HTTP est peut-être l'un des protocoles Internet les plus utilisés. Nous l'utilisons tous les jours pour échanger des informations entre clients et serveurs. 

Pour ce faire, le protocole HTTP utilise des méthodes de requête. Ces méthodes indiquent l'action qu'un client souhaite effectuer sur un serveur. Par exemple, si vous souhaitez obtenir des informations d'un serveur, vous utiliserez la méthode GET. Si vous voulez envoyer quelque chose au serveur, vous utiliserez POST. Voici une liste des méthodes de requête HTTP les plus courantes :

• GET - récupérer des données sur le serveur
• HEAD - ne récupère que l'en-tête, sans le corps (les données proprement dites)
• POST - Envoi d'informations au serveur
• PUT - Envoyer des informations au serveur et remplacer toutes les représentations actuelles de la ressource.
• PATCH - Envoi d'informations au serveur et modification partielle de la ressource
• DELETE - Supprimer la ressource du serveur

Pourquoi Python pour les requêtes HTTP ?

Tout d'abord, Python possède une excellente syntaxe et une communauté encore plus importante. Il est donc parfait pour l'apprentissage. Lorsque j'ai commencé à programmer, j'ai moi-même choisi Python. En fait, les clients HTTP Python ont été parmi les premières technologies que j'ai rencontrées. Mais il s'agit là d'un autre sujet. 

Mon objectif pour l'article d'aujourd'hui est de m'assurer que vous repartirez non seulement avec une compréhension théorique de base, mais aussi avec une vue d'ensemble de la mise en œuvre pratique. 

Et Python est parfait pour les deux, pour un certain nombre de raisons. Pour n'en citer que quelques-unes :

• Syntaxe - Écrire Python, c'est un peu comme écrire l'anglais. La lecture d'un script Python vous aidera donc à faire le lien entre les concepts théoriques et leur mise en œuvre réelle. 
• Support - Python dispose d'une très large communauté. La plupart du temps, si vous êtes bloqué, une simple question sur StackOverflow vous apportera la réponse à votre problème. 
• Disponibilité - La bibliothèque de paquets de Python est l'une des plus complètes. Par exemple, rien que pour les clients HTTP de Python, il existe plus d'une douzaine de paquets. Mais nous nous concentrerons aujourd'hui sur les plus populaires. 

3(+1) Meilleurs clients HTTP Python

Lorsqu'il s'agit de classer les paquets pour obtenir un top 3 des meilleurs clients HTTP Python, je pense que c'est à la fois une question de fonctionnalité et de préférence personnelle. Il est donc correct de dire que ce qui suit représente mon top 3 des bibliothèques de clients HTTP pour Python, plutôt qu'un classement général.

1. Demandes - Simplicité puissante

Requests est probablement l'un des clients HTTP les plus appréciés de la communauté Python. Je ne fais pas d'exception. Chaque fois que je teste un nouveau scraper web, j'utilise Python avec Requests. C'est aussi simple que de dire .get et aussi puissant qu'un véritable navigateur web. 

La bibliothèque des demandes offre, entre autres, les services suivants

• Vérification SSL 
• Prise en charge du proxy pour HTTPS
• Persistance des cookies et sessions
• Fonction de maintien en vie
• Authentification personnalisée

Et ce ne sont là que quelques exemples. Vous pouvez consulter la liste complète des fonctionnalités ici. Laissez-moi maintenant vous montrer comment travailler avec les demandes :

import requests
r = requests.get("http://google.com") 
print(r.test)

Comme vous pouvez le voir, avec seulement 3 lignes de code, la bibliothèque requests nous aide à collecter la ligne HTML d'un serveur. Dans l'exemple ci-dessus, nous faisons une requête GET au serveur et nous imprimons le résultat. Mais comme je l'ai dit, cette bibliothèque est beaucoup plus diversifiée. Construisons un exemple plus complexe, qui utilise des fonctionnalités telles que les proxies et les requêtes POST :

import requests

def get_params(object):
    params = ''
    for key,value in object.items():
        if list(object).index(key) < len(object) - 1:
            params += f"{key}={value}."
        else:
            params += f"{key}={value}"
    return params

API_KEY = '<YOUR_API_KEY>'

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

PARAMETERS = {
    "proxy_type":"datacenter",
    "device":"desktop"
}

PROXY = {
    "http": f"http://webscrapingapi.{ get_params(PARAMETERS) }:{ API_KEY }@proxy.webscrapingapi.com:80",
    "https": f"https://webscrapingapi.{ get_params(PARAMETERS) }:{ API_KEY }@proxy.webscrapingapi.com:8000"
}

response = requests.post(
    url=TARGET_URL,
    data=DATA,
    proxies=PROXY,
    verify=False
)

print(response.text)

Voyons ce que nous faisons ici :

1. Nous définissons la fonction `get_params`, qui prend un objet et le renvoie comme une chaîne de paramètres URL.
2. Nous définissons nos variables :
   undefinedundefinedundefinedundefinedundefinedundefined
3. Nous utilisons la méthode `post` de Requests pour envoyer une requête HTTP post.
4. Nous imprimons le corps de la réponse

2. HTTPX - Les requêtes réinventées

HTTPX est relativement nouveau sur la scène. Cependant, en très peu de temps, il est devenu l'un des clients HTTP Python les plus recommandés. Par exemple, Flask (l'un des plus grands frameworks web pour Python) recommande l'utilisation de HTTPX dans sa documentation officielle. 

Lorsque j'ai dit que HTTPX était une réinvention de requests, c'est parce que les deux bibliothèques sont très similaires en termes de syntaxe. En fait, HTTPX vise une compatibilité totale avec requests. Il n'y a que quelques différences mineures de conception entre les deux, qui sont soulignées ici. 

Voici à quoi ressemble une requête POST de base en HTTPX :

import httpx

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

r = httpx.post(
   url=TARGET_URL,
   data=DATA,
)

print(r.text)

Comme vous pouvez le voir, c'est principalement le nom du paquet que nous changeons par rapport à l'exemple de Requests. Et puisqu'ils sont si similaires, la question reste de savoir pourquoi choisir HTTPX plutôt que Requests. Pour une fois, HTTPX est l'un des rares clients HTTP Python à offrir un support asynchrone. Pour résumer, HTTPX est un excellent choix si vous voulez refactoriser votre code basé sur des requêtes. 

3. urllib3 - Connexions sans risque pour les fils

Python dispose de plusieurs "urllibs", ce qui déroute généralement les nouveaux programmeurs. La principale différence entre urllib, urllib2 et urllib3 réside dans les fonctionnalités de chaque paquetage. urllib était le client HTTP original de Python, inclus dans la bibliothèque standard de Python 1.2. urllib2 était la version améliorée, introduite dans Python 1.6 et destinée à remplacer l'urllib original.

En ce qui concerne urllib3, il s'agit en fait d'un client HTTP Python tiers. Malgré son nom, cette bibliothèque n'a rien à voir avec ses deux "prédécesseurs". De plus, la communauté Python dit qu'il n'est pas prévu d'inclure urllib3 dans la bibliothèque standard. Du moins dans un avenir proche. 

Bien que ce paquetage ne soit pas officiellement lié à la bibliothèque standard de Python, de nombreux développeurs l'utilisent parce qu'il offre :

• Sécurité des fils
• Vérification SSL / TLS côté client
• Prise en charge de proxy pour HTTP et SOCKS
• Couverture complète des tests

Maintenant que nous avons couvert la partie théorique, voyons l'exemple de mise en œuvre :

import urllib3,json

TARGET_URL = 'https://httpbin.org/post'

DATA = {"foo":"bar"}

http = urllib3.PoolManager()

encoded_data = json.dumps(DATA)

r = http.request('POST', TARGET_URL, body=encoded_data)   

print(r.data.decode('utf-8'))

Examinons les différences identifiées dans urllib3, par rapport à Requests :

• `http` - une instance de la méthode `PoolManager`, qui gère les détails de la sécurité des threads et de la mise en commun des connexions.
• `encoded_data` - une chaîne JSON convertie, contenant la charge utile que nous envoyons
• `r` - la requête POST que nous faisons avec l'aide d'urllib3. Ici, nous utilisons la méthode `request` de l'instance `PoolManager`.

Et à la fin, nous devons décoder les données que nous recevons en retour de notre requête. Comme vous pouvez le voir, il y a deux ou trois choses que nous faisons différemment qu'avec Requests.

Mention honorable : http.client - Client HTTP traditionnel en Python

http.client fait également partie de la bibliothèque standard de Python. Traditionnellement, elle n'est pas utilisée directement par les programmeurs. Par exemple, urllib l'utilise en tant que dépendance, afin de gérer les requêtes HTTP et HTTPS. Je l'ai inclus dans notre classement parce que je pense qu'en tant que programmeurs, il est bon de connaître les "os" des paquets que nous utilisons.

Même si vous ne créez pas de projet avec http.client, voici un exemple d'implémentation qui, j'en suis sûr, vous aidera à mieux comprendre le fonctionnement des clients HTTP Python :

import http.client

TARGET_URL = 'www.httpbin.org'

http = http.client.HTTPSConnection(TARGET_URL)
http.request("GET", "/get")

r = http.getresponse()

print(r.read().decode('utf-8'))

L'instance `HTTPSConnection` prend quelques paramètres, que vous pouvez vérifier ici. Dans notre exemple, nous ne définissons que la `method` et le `url` (ou plus précisément, le point de terminaison). De plus, comme pour urllib3, http.client renvoie une réponse encodée. Nous devons donc la décoder avant de l'imprimer.

Cas d'utilisation : Construction d'un scraper avec des requêtes

Maintenant que nous savons comment utiliser les clients HTTP, assignons-nous un petit projet. Il sera utile non seulement de mettre en pratique ce que vous avez appris, mais aussi d'ajouter de la valeur à votre propre portfolio de programmation. 

Les clients HTTP Python étant couramment utilisés pour collecter des informations à partir de serveurs, l'utilisation la plus courante de ces technologies est la création d'un scraper web. Nous allons donc nous concentrer sur la création d'un scraper web à l'aide de clients HTTP en Python. Parce que j'ai un favori personnel - requests - je l'utiliserai pour ce projet. Cependant, vous pouvez l'utiliser comme point de départ et même le modifier pour utiliser certaines des autres technologies que nous avons discutées. Sans plus attendre, commençons à coder :

1. Mise en place du projet

Commençons par créer un nouveau répertoire dans lequel nous placerons les fichiers de notre scraper web. Ouvrez une nouvelle fenêtre de terminal et `cd` dans ce répertoire. Ici, nous voulons initier un nouvel environnement virtuel. Si vous êtes sur un système d'exploitation de type UNIX, vous pouvez utiliser :

~ " python3 -m venv env && source env/bin/activate              

Il suffit maintenant de créer un nouveau fichier Python qui contiendra notre logique et de l'ouvrir dans l'IDE de votre choix. Si vous souhaitez utiliser le terminal, collez simplement la commande suivante :

~ " touch scraper.py && code .                                         

2. Installation des dépendances

Nous utiliserons pip pour installer les paquets dont nous avons besoin pour ce projet. Pour l'instant, nous avons établi que nous allions utiliser Requests, mais ce n'est pas suffisant pour un web scraper. Un scraper web implique également de traiter les données. Cela signifie que nous devons analyser le code HTML collecté sur les serveurs. Heureusement, la bibliothèque Python offre une grande variété de packages. Pour ce projet, nous utiliserons BeautifulSoup. Pour installer les paquets, il suffit de coller la commande suivante :

~ " python3 -m pip install requests bs4                                    

3. Rédaction de la logique

Nous allons diviser notre code en deux sections : l'une pour l'extraction des données et l'autre pour la manipulation des données. La première partie est couverte par le paquet Requests, tandis que la seconde est couverte par BeautifulSoup. Sans plus attendre, passons au codage, en commençant par la partie extraction :

import requests

def scrape( url = None ) :
  # s'il n'y a pas d'URL, il n'est pas nécessaire d'utiliser les clients HTTP Python
 # Nous allons imprimer un message et arrêter l'exécution
 if url == None :
 print('[ !] Please add a target!')
 return

 response = requests.get( url ) 
 return response

Dans cette section, nous définissons une fonction avec un seul paramètre : l'URL ciblée. Si l'URL n'est pas fournie, nous allons imprimer un message et arrêter l'exécution. Sinon, nous utilisons la méthode get de Request pour renvoyer la réponse. Maintenant, nous savons que les cliniques HTTP de Python couvrent plus de méthodes, alors ajoutons un paramètre conditionnel :

import requests

def scrape( method = 'get', url = None, data = None ) :
  # s'il n'y a pas d'URL, il n'est pas nécessaire d'utiliser les clients HTTP Python
 # Nous allons afficher un message et arrêter l'exécution
 if url == None :
 print('[ !] Please add a target!')
 return

 if method.lower() == 'get' :
 response = requests.get( url )

 elif method.lower() == 'post' :
 if data == None :
 print('[ !] Please add a payload to your POST request!')
 return
 response = requests.post( url, data )
      
 return response

Comme vous pouvez le voir, nous avons ajouté quelques paramètres supplémentaires à notre fonction. Le paramètre `method` spécifie la méthode à utiliser pour notre requête. Le paramètre `data` représente la charge utile que nous envoyons avec la requête POST. Par défaut, la méthode est GET, donc le paramètre `method` n'est pas nécessaire. 

Défi: Ajouter d'autres méthodes à cette fonction et enrichir les capacités de notre scraper. Non seulement c'est amusant, mais c'est aussi une bonne méthode d'apprentissage. De plus, vous pouvez vous approprier le code et l'ajouter à votre portfolio.

Jusqu'à présent, nous avons couvert l'extraction des données. Analysons le code HTML et faisons quelque chose avec :

from bs4 import BeautifulSoup

def extract_elements(data = None, el = None) :
 if data == None :
 print('[ !] Please add some data!')
 return

 if el == None :
 print('[ !] Please specify which elements you are targeting!')
 return

 soup = BeautifulSoup(data.text, 'html.parser')
 elements = soup.find_all(el)

 return elements

Mais un scraper web devrait être capable d'extraire des données plus spécifiques. Par exemple, il devrait pouvoir localiser et renvoyer des éléments sur la base de leur sélecteur CSS. Ajoutons donc la logique qui gère cette partie :

from bs4 import BeautifulSoup

def extract_elements(data = None, el = None, attr = None, attr_value = None):
   if data == None:
       print('[!] Please add some data!')
       return

   if el == None:
       print('[!] Please specify which elements you are targeting!')
       return

   soup = BeautifulSoup(data.text, 'html.parser')
   elements = soup.find_all(el, { attr : attr_value })

   return elements

BeautifulSoup nous permet d'extraire des données spécifiques basées sur leurs attributs. Nous avons donc ajouté deux nouveaux paramètres qui nous aideront à localiser et à extraire des éléments en fonction de leurs attributs.

Nous avons maintenant tout ce dont nous avons besoin. Il ne reste plus qu'à combiner les deux sections et nous aurons notre scraper web. Une fois que vous avez assemblé votre code, il vous suffit de :

1. Créer une nouvelle variable qui contiendra les données extraites avec Requests 
2. Imprimer les éléments retournés par BeautifulSoup

Voici les deux parties manquantes de votre code :

data = scrape('GET', 'https://webscrapingapi.com')
print( extract_elements(data, 'ul') )

Je suis sûr que vous avez déjà compris ce que tout cela fait et qu'il n'y a pas besoin d'une traduction à ce stade. Tout comme avec notre scraper, je vous mets au défi de jouer avec la fonction `extract_elements` et de lui faire faire plus que simplement retourner des éléments. 

Conclusion

Lorsque l'on apprend un nouveau concept de programmation, je pense qu'il est préférable de tester les différentes technologies disponibles. Cependant, lorsqu'il s'agit de construire l'infrastructure d'un projet plus vaste, il est préférable d'apprendre les forces et les faiblesses de chaque technologie avant d'en choisir une. 

J'espère que cet article vous a aidé d'une manière ou d'une autre et que vous avez maintenant une solide compréhension du fonctionnement des clients HTTP Python. Je vous encourage également à vous amuser, car je suis sûr que vous découvrirez le paquetage qui vous convient le mieux.