Requests : requêtes HTTP

Qu'est-ce que requests ? Simplifier les requêtes HTTP

La bibliothèque `requests` est une bibliothèque Python très populaire qui permet d'effectuer des requêtes HTTP de manière simple et élégante.

HTTP (Hypertext Transfer Protocol) est le protocole utilisé pour communiquer sur le Web. Il définit la manière dont les clients (par exemple, les navigateurs web) et les serveurs échangent des informations.

Avec `requests`, vous pouvez :

• Télécharger des pages web.
• Interagir avec des API web (Application Programming Interfaces).
• Envoyer des données à des serveurs.
• Gérer les cookies, les en-têtes HTTP, les sessions, etc.

`requests` n'est pas incluse dans la bibliothèque standard Python. Vous devez l'installer séparément (généralement avec `pip`).

La bibliothèque `requests` est construite sur la bibliothèque `urllib3`, mais elle offre une API beaucoup plus conviviale et intuitive.

Elle est conçue pour être simple d'utilisation, tout en offrant des fonctionnalités avancées pour les utilisateurs expérimentés.

La devise de `requests` est "HTTP for Humans" (HTTP pour les humains).

Installation et importation

Pour installer `requests`, utilisez `pip` :

pip install requests

Pour importer `requests` dans votre code Python :

import requests

Effectuer une requête GET : récupérer des données

La méthode la plus courante pour récupérer des données sur le Web est d'utiliser une requête GET.

Avec `requests`, vous pouvez effectuer une requête GET en utilisant la fonction `requests.get()` :

import requests

# Effectuer une requête GET à l'URL spécifiée
reponse = requests.get("https://www.example.com")

# Vérifier le code de statut HTTP (200 signifie OK)
print(reponse.status_code)

# Afficher le contenu de la réponse (le code HTML de la page, par exemple)
# print(reponse.text)

Dans cet exemple :

• `requests.get("https://www.example.com")` envoie une requête GET à l'URL spécifiée.
• La fonction `get()` retourne un objet `Response` qui contient la réponse du serveur.
• `reponse.status_code` contient le code de statut HTTP de la réponse (200 signifie OK, 404 signifie "Not Found", etc.).
• `reponse.text` contient le contenu de la réponse, sous forme de chaîne de caractères (utile pour les pages HTML, le texte, etc.). Si la réponse est binaire utiliser plutot `reponse.content`

L'objet Response : accéder aux informations de la réponse

L'objet `Response` retourné par les fonctions de `requests` (comme `get()`, `post()`, etc.) contient de nombreuses informations utiles :

• `status_code` : Le code de statut HTTP (par exemple, 200, 404, 500).
• `text` : Le contenu de la réponse, décodé en chaîne de caractères (en utilisant l'encodage détecté automatiquement, ou un encodage spécifié).
• `content` : Le contenu de la réponse, sous forme de bytes (utile pour les données binaires, comme les images).
• `encoding` : L'encodage utilisé pour décoder le contenu en texte.
• `headers` : Un dictionnaire contenant les en-têtes HTTP de la réponse.
• `url` : L'URL de la réponse (peut être différent de l'URL de la requête si des redirections ont eu lieu).
• `ok` : `True` si le code est inférieur à 400, `False` sinon.
• `json()` : Si la réponse contient du JSON, cette méthode décode le JSON et retourne un objet Python (généralement un dictionnaire ou une liste).
• `raise_for_status()` : Lève une exception (HTTPError) si le code de statut indique une erreur (4xx ou 5xx).
• Et d'autres...

Exemple :

import requests

reponse = requests.get("https://www.example.com")

print("Code de statut :", reponse.status_code)  # 200
print("Encodage :", reponse.encoding)          # UTF-8 (par exemple)
print("En-têtes :", reponse.headers)
# print("Contenu (texte) :", reponse.text)

#Si le contenu est du JSON:
# data = reponse.json()

Gérer les erreurs : exceptions et raise_for_status()

Il est important de gérer les erreurs qui peuvent se produire lors d'une requête HTTP (par exemple, si le serveur ne répond pas, si l'URL est invalide, si vous n'avez pas de connexion réseau, etc.).

Vous pouvez utiliser un bloc `try...except` pour capturer les exceptions levées par `requests` :

import requests

try:
    reponse = requests.get("https://une.url.invalide.com")
    reponse.raise_for_status()  # Lève une exception si le code de statut est une erreur (4xx ou 5xx)
    # ... Traiter la réponse ...
except requests.exceptions.RequestException as e:
    print("Erreur lors de la requête :", e)

Dans cet exemple :

• `requests.exceptions.RequestException` est une exception de base pour toutes les exceptions levées par `requests`.
• `reponse.raise_for_status()` est une méthode pratique qui lève une exception (`HTTPError`) si le code de statut de la réponse indique une erreur (4xx ou 5xx). C'est un moyen simple de vérifier si la requête a réussi.

Vous pouvez capturer des exceptions plus spécifiques si vous voulez gérer différents types d'erreurs différemment (par exemple, `requests.exceptions.ConnectionError`, `requests.exceptions.Timeout`, `requests.exceptions.HTTPError`, etc.).

Autres types de requêtes : POST, PUT, DELETE, etc.

`requests` ne se limite pas aux requêtes GET. Il permet d'effectuer tous les types de requêtes HTTP :

• `requests.post(url, data=..., json=...)` : Envoie une requête POST (pour envoyer des données à un serveur).
• `requests.put(url, data=...)` : Envoie une requête PUT (pour mettre à jour une ressource).
• `requests.delete(url)` : Envoie une requête DELETE (pour supprimer une ressource).
• `requests.head(url)` : Envoie une requête HEAD (similaire à GET, mais ne retourne que les en-têtes, pas le contenu).
• `requests.patch(url, data=...)` : Envoie une requête PATCH (pour mettre à jour partiellement une ressource).
• `requests.options(url)` : Envoie une requête OPTIONS (pour obtenir des informations sur les méthodes HTTP supportées par le serveur).

Exemple (POST) :

import requests

donnees = {'cle1': 'valeur1', 'cle2': 'valeur2'}
reponse = requests.post("https://www.example.com/api", data=donnees)

# Ou, pour envoyer des données JSON :
# reponse = requests.post("https://www.example.com/api", json=donnees)

Les fonctions `post`, `put`, `patch`, etc., prennent des arguments optionnels pour spécifier les données à envoyer (`data` pour les données de formulaire, `json` pour les données JSON), les en-têtes HTTP, les cookies, etc.

Personnaliser les requêtes : en-têtes, paramètres, authentification, etc.

`requests` offre de nombreuses options pour personnaliser les requêtes HTTP :

• En-têtes (headers) : Vous pouvez spécifier des en-têtes HTTP personnalisés en utilisant l'argument `headers` (un dictionnaire).
• Paramètres d'URL (query string) : Vous pouvez passer des paramètres d'URL en utilisant l'argument `params` (un dictionnaire).
• Données (data) : Pour les requêtes POST, PUT, et PATCH, vous pouvez envoyer des données avec l'argument `data` (pour les données de formulaire) ou `json` (pour les données JSON).
• Authentification : `requests` supporte plusieurs mécanismes d'authentification (Basic Auth, Digest Auth, OAuth, etc.). Vous pouvez utiliser l'argument `auth`.
• Cookies : Vous pouvez envoyer et recevoir des cookies.
• Timeouts : Vous pouvez spécifier un délai d'attente (timeout) pour la requête.
• Redirections : `requests` suit les redirections par défaut, mais vous pouvez contrôler ce comportement.
• Sessions : Vous pouvez utiliser un objet `Session` pour conserver les paramètres (cookies, en-têtes, etc.) entre plusieurs requêtes.
• Proxies : Vous pouvez utiliser des proxies.
• Certificats SSL : Vous pouvez vérifier les certificats SSL ou utiliser des certificats clients.
• Et bien plus encore...

Exemple (en-têtes et paramètres) :

import requests

url = "https://www.example.com/recherche"
parametres = {"q": "python", "lang": "fr"}
en_tetes = {"User-Agent": "MonBot/1.0"}

reponse = requests.get(url, params=parametres, headers=en_tetes)

Consultez la documentation de `requests` pour plus de détails sur toutes les options disponibles.