Un guide complet de la bibliothèque Python Requests

Dans ce guide complet, vous découvrirez :

• Qu’est-ce que Requests, comment l’installer et pourquoi c’est la bibliothèque cliente HTTP Python la plus populaire.
• Comment l’utiliser avec différentes méthodes HTTP.
• Ce qu’elle propose pour gérer les réponses des serveurs.
• Quelles sont les personnalisations de requêtes qu’elle prend en charge.
• Les scénarios avancés couverts par la bibliothèque Python Requests

C’est parti !

Présentation de la bibliothèque Requests

Découvrez ce qu’est Requests, comment l’installer, quand l’utiliser et ce que cette bibliothèque procure.

Définition

Requests est une bibliothèque HTTP simple et élégante pour Python. En détail, elle fournit une API intuitive pour effectuer des requêtes HTTP et gérer les réponses de manière simple et lisible par les personnes. Avec plus de 50 000 étoiles sur GitHub et des millions de téléchargements quotidiens, Requests est le client HTTP le plus populaire en Python.

Certaines des fonctionnalités clés proposées par cette bibliothèque incluent une API complète couvrant toutes les méthodes HTTP, la gestion des réponses, la personnalisation des requêtes, l’authentification, la gestion des certificats SSL, etc. De plus, le module Python Requests prend en charge HTTP/1.1 par défaut.

Configuration

La méthode la plus simple et la plus recommandée pour installer Requests consiste à utiliser pip. En particulier, le package pip associé à la bibliothèque Requests est requests. Vous pouvez donc installer le client HTTP à l’aide de la commande suivante :

pip install requests

Pour utiliser requests dans votre script Python, importez-le avec la ligne ci-dessous :

import requests

Génial ! Le package Requests est maintenant installé et prêt à être utilisé.

Cas d’utilisation

Les principaux cas d’utilisation de la bibliothèque Python requests incluent :

• Effectuer des requêtes HTTP vers des serveurs Web : récupérez des données depuis des serveurs Web en envoyant des requêtes GET.
• Utiliser des API : envoyez des requêtes aux endpoints des API et gérez leurs réponses, interagissez avec divers services Web et accédez à leurs données.
• Web scraping : récupérez les documents HTML associés aux pages Web, qui peuvent ensuite être analysés à l’aide de bibliothèques telles que BeautifulSoup pour extraire des informations spécifiques. Pour en savoir plus, consultez notre guide sur le web scraping en Python.
• Tester des applications Web : simulez des requêtes HTTP et vérifiez les réponses, automatisez le processus de test et garantissez le bon fonctionnement des services Web.
• Télécharger des fichiers : récupérez des fichiers depuis des serveurs Web, tels que des images, des documents ou d’autres fichiers multimédias, en envoyant des requêtes HTTP GET aux URL respectives.

Méthodes

Examinez les méthodes publiques exposées par la bibliothèque requests dans le tableau suivant :

Comme vous pouvez le constater, celles-ci couvrent les méthodes de requête HTTP les plus utiles. Pour en savoir plus sur leur utilisation, consultez la documentation officielle des API.

Il est temps de les voir en action !

Méthodes HTTP

Observez la bibliothèque Python requests en action lorsque vous utilisez les méthodes GET, POST, PUT, DELETE et HEAD en HTTP.

GET

En HTTP, la méthode GET est utilisée pour demander une ressource spécifique à un serveur. Voici comment effectuer une requête HTTP GET avec requests.get() :

import requests

# send a GET request to the specified URL

response = requests.get('https://api.example.com/data')

De même, vous pouvez obtenir le même résultat avec requests.request() comme illustré ci-dessous :

import requests

response = requests.request('GET', 'https://api.example.com/data')

Dans ce cas, vous devez spécifier manuellement la méthode HTTP à utiliser avec une variable de chaîne supplémentaire.

POST

La méthode HTTP POST est utilisée pour envoyer des données à un serveur en vue d’un traitement ultérieur. Voici comment effectuer une requête POST avec requests.post() :

import requests

# data to be sent in the POST request

product = {

'name': 'Limitor 500',

'description': 'The Limitor 500 is a high-performance electronic device designed to regulate power consumption in industrial settings. It offers advanced features such as real-time monitoring, adjustable settings, and remote access for efficient energy management.',

'price': 199.99,

'manufacturer': 'TechCorp Inc.',

'category': 'Electronics',

'availability': 'In Stock'

}

# send a POST request to the specified URL

response = requests.post('https://api.example.com/product', data=product)

Par rapport à une requête GET, cette fois, vous devez également spécifier les données à envoyer au serveur via l’option data. requests ajoutera ces données au corps de la requête HTTP.

Pour les corps JSON, transmettez votre objet de données à l’option json au lieu de data :

response = requests.post('https://api.example.com/product', json=product)

De manière équivalente, vous pouvez effectuer la même requête avec request.request() comme suit :

import requests

product = {

'name': 'Limitor 500',

'description': 'The Limitor 500 is a high-performance electronic device designed to regulate power consumption in industrial settings. It offers advanced features such as real-time monitoring, adjustable settings, and remote access for efficient energy management.',

'price': 199.99,

'manufacturer': 'TechCorp Inc.',

'category': 'Electronics',

'availability': 'In Stock'

}

response = requests.request('POST', 'https://api.example.com/product', data=product)

PUT

La méthode PUT est utilisée pour mettre à jour ou remplacer une ressource sur le serveur. L’envoi d’une requête PUT avec le module Python requests est facile et suit un schéma similaire à celui des requêtes POST. Ce qui change, c’est que la méthode à utiliser est requests.put(). De plus, la chaîne de méthode HTTP dans requests.request() sera PUT.

PATCH

La méthode PATCH est utilisée pour appliquer des modifications partielles à une ressource en ligne. Tout comme pour les requêtes PUT, l’envoi de requêtes PATCH dans la bibliothèque Python requests est similaire aux requêtes POST. Ce qui change, c’est que la méthode à utiliser est requests.patch() et que la chaîne de méthodes HTTP dans requests.request() est 'PATCH'.

DELETE

La méthode DELETE est utilisée pour supprimer une ressource identifiée par un URI donné. Voici comment effectuer une requête HTTP DELETE dans requests à l’aide de la méthode delete() :

import requests

# send a DELETE request for the product with id = 75

response = requests.delete('https://api.example.com/products/75')

De manière équivalente, vous pouvez effectuer une requête DELETE avec requests.request() :

import requests

response = requests.request('DELETE', 'https://api.example.com/products/75')

HEAD

La méthode HEAD est similaire à GET, mais elle ne demande que les en-têtes de la réponse, sans le contenu réel du corps. Ainsi, la réponse renvoyée par le serveur pour une requête HEAD sera équivalente à celle d’une requête GET, mais sans aucune donnée sur le corps.

Utilisez requests.head() pour effectuer une requête HTTP HEAD en Python :

import requests

# send a HEAD request to the specified URL

response = requests.head('https://api.example.com/resource')

De la même manière, vous pouvez effectuer une requête HEAD avec requests.request () :

import requests

response = requests.request('HEAD', 'https://api.example.com/resource')

Décomposer un objet de réponse à partir de Requests

Maintenant que vous savez comment effectuer des requêtes HTTP avec requests, il est temps de voir comment traiter les objets Response.

Objet Response

Après avoir effectué une requête HTTP, requests recevra la réponse du serveur et la mappera dans un objet spécial Response.

Regardez l’exemple Python requests ci-dessous :

import requests

response = requests.get('http://lumtest.com/myip.json')

print(response)

Cela renvoie :

<Response [200]>

response est un objet Response qui expose certaines méthodes et propriétés utiles. Découvrez les plus importantes dans les sections suivantes !

Avertissement : requests ne renvoie pas toujours une réponse. En cas d’erreur (par exemple, une URL non valide), il déclenche une RequestException. Protégez-vous contre cette exception à l’aide de la logique ci-dessous :

try:

response = requests.get('http://lumtest.com/myip.json')

# handle the response

except requests.exceptions.RequestException as e:

print('An error occurred during the request:', e)

Codes d’état

En matière de HTTP, les codes d’état de réponse sont des valeurs normalisées renvoyées par le serveur pour indiquer le succès, l’échec ou toute autre condition de la requête. Ces codes d’état sont très importants, car ils fournissent des informations immédiates permettant de savoir si la requête a été acceptée ou non et, dans le cas contraire, quelles ont été les erreurs.

Ils sont particulièrement utiles pour la gestion des erreurs, car ils permettent au client d’identifier et de traiter les différents types d’erreurs de manière appropriée. Par exemple, un code d’état 4xx indique une erreur côté client (par exemple, une requête non valide), tandis qu’un code d’état 5xx indique une erreur côté serveur.

Le contrôle du code d’état est généralement la première étape de la gestion d’une réponse en Python à l’aide de la bibliothèque requests. Après avoir fait une requête, vous devez toujours vérifier le code d’état de la réponse pour déterminer si elle a abouti ou non. Accédez au code d’état via l’attribut status_code de l’objet de réponse :

response.status_code # 200

En fonction du code d’état reçu, vous devez utiliser des instructions conditionnelles pour gérer les différents scénarios de manière appropriée :

import requests

response = requests.get('http://lumtest.com/myip.json')

# check if the request was successful (status code 200)

if response.status_code == 200:

print('Successful request!')

# handle the response...

elif response.status_code == 404:

print('Resource not found!')

else:

print(f'Request failed with status code: {response.status_code}')

Dans la plupart des scénarios, il suffit de faire la distinction entre une requête réussie et une réponse d’erreur. requests simplifie ce processus grâce à une surcharge personnalisée __bool () __. Plus précisément, vous pouvez utiliser un objet Response directement dans une expression conditionnelle. Cela évaluera True si le code d’état est compris entre 200 et 399, et ce sera False sinon.

En d’autres termes, il est possible de vérifier le succès d’une requête avec cette logique :

if response:

print('Successful request!')

# handle the response...

else:

print(f'Request failed with status code: {response.status_code}')

En-têtes de réponse

Accédez aux en-têtes d’une réponse de serveur via l’attribut headers :

import requests

response = requests.get('http://lumtest.com/myip.json')

response_headers = response.headers

print(response_headers)

Cela affichera :

{'Server': 'nginx', 'Date': 'Thu, 09 May 2024 12:51:08 GMT', 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': '279', 'Connection': 'keep-alive', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': '*'}

Comme vous pouvez le constater, response.headers renvoie un objet semblable à un dictionnaire. Cela signifie que vous pouvez accéder aux valeurs d’en-tête par clé. Supposons, par exemple, que vous souhaitiez accéder à l’en-tête Content-Type de la réponse. Voici comment procéder:

response_headers['Content-Type'] # 'application/json; charset=utf-8'

Étant donné que la spécification HTTP définit les en-têtes comme ne faisant pas la distinction entre majuscules et minuscules, requests vous permet d’y accéder sans vous soucier de la casse :

response_headers['content-type'] # 'application/json; charset=utf-8'

Contenu de la réponse

requests fournit différents attributs et méthodes pour accéder à la charge utile d’une réponse :

• response.content : renvoie le contenu de la réponse en octets.
• response.text : renvoie le contenu de la réponse sous forme de chaîne en Unicode.
• response.json() : renvoie le contenu codé en JSON de la réponse dans un dictionnaire.

Regardez-les en action dans l’exemple suivant :

import requests

response = requests.get('http://lumtest.com/myip.json')

# access the response as bytes

response_bytes = response.content

print(type(response_bytes))

print(response_bytes)

print()

# retrieve the response as text

response_text = response.text

print(type(response_text))

print(response_text)

print()

# retrieve the response as a JSON-encoded dictionary

response_json = response.json()

print(type(response_json))

print(response_json)

print()

http://lumtest.com/myip.json est un endpoint spécial qui renvoie des informations sur l’adresse IP de l’appelant. Le résultat de l’extrait ci-dessus sera quelque chose comme :

<class 'bytes'>

b'{"ip":"45.85.135.110","country":"US","asn":{"asnum":62240,"org_name":"Clouvider Limited"},"geo":{"city":"Ashburn","region":"VA","region_name":"Virginia","postal_code":"20149","latitude":39.0469,"longitude":-77.4903,"tz":"America/New_York","lum_city":"ashburn","lum_region":"va"}}'

<class 'str'>

{"ip":"45.85.135.110","country":"US","asn":{"asnum":62240,"org_name":"Clouvider Limited"},"geo":{"city":"Ashburn","region":"VA","region_name":"Virginia","postal_code":"20149","latitude":39.0469,"longitude":-77.4903,"tz":"America/New_York","lum_city":"ashburn","lum_region":"va"}}

<class 'dict'>

{'ip': '45.85.135.110', 'country': 'US', 'asn': {'asnum': 62240, 'org_name': 'Clouvider Limited'}, 'geo': {'city': 'Ashburn', 'region': 'VA', 'region_name': 'Virginia', 'postal_code': '20149', 'latitude': 39.0469, 'longitude': -77.4903, 'tz': 'America/New_York', 'lum_city': 'ashburn', 'lum_region': 'va'}}

Notez les trois formats de réponse différents. En tant que dictionnaire, response.json() est particulièrement utile, car il simplifie l’accès aux données :

response_json['country'] # 'US'

Pour plus d’informations, consultez notre guide sur Comment parser JSON avec Python.

Cookies Response

Alors que les cookies HTTP sont définis via des en-têtes, l’objet Response fournit un attribut spécial cookies pour les gérer. Cela renvoie un objet http.cookiejar contenant les cookies renvoyés par le serveur.

Regardez l’exemple ci-dessous qui montre comment accéder aux cookies à partir d’un objet de réponse dans la bibliothèque Python requests :

import requests

# define the login credentials

credentials = {

'username': 'example_user',

'password': 'example_password'

}

# send a POST request to the login endpoint

response = requests.post('https://www.example.com/login', data=credentials)

# access the cookies set by the server

cookies = response.cookies

# print the cookies received from the server

for cookie in cookies:

print(cookie.name, ':', cookie.value)

L’extrait ci-dessus peut produire quelque chose comme ceci :

session_id : be400765483cf840dfbbd39

user_id : 7164

expires : Sat, 01 Jan 2025 14:30:00 GMT

Personnalisation des requêtes avec la bibliothèque Python requests

Les requêtes HTTP impliquent souvent des paramètres de filtrage spéciaux et des en-têtes personnalisés. Voyons comment les spécifier dans requests.

Paramètres de chaîne de requête

Les paramètres de requête, également appelés paramètres d’URL, sont des paramètres supplémentaires ajoutés à la fin d’une URL dans une requête HTTP. Ils fournissent des informations supplémentaires au serveur concernant la requête, généralement sur la manière de filtrer les données et de personnaliser la réponse.

Considérez cette URL :

https://api.example.com/data?key1=value1&key2=value2

Dans cet exemple, ?key1=value1&key2=value2 est la chaîne de requête tandis que key1 et key2 sont les paramètres de la requête.

Une chaîne de requête commence par ? et consiste en une paire clé-valeur séparée par un signe égal (=) et concaténée par &. Il n’est pas toujours facile de spécifier cette chaîne de requête par programmation dans du code Python, en particulier lorsqu’il s’agit de paramètres optionnels. C’est pourquoi requests propose l’option params :

import requests

# define query parameters as a dictionary

params = {

'page': 1,

'limit': 10,

'category': 'electronics'

}

# send a GET request to the following URL:

# 'https://api.example.com/products?page=1&limit=10&category=electronics'

response = requests.get('https://api.example.com/products', params=params)

De manière équivalente, vous pouvez transmettre les paramètres à requests sous forme de liste de tuples :

import requests

# define query parameters as a list of tuples

params = [

('page', '1'),

('limit', '10'),

('category', 'electronics')

]

response = requests.get('https://api.example.com/products', params=params)

Ou sous forme de chaîne d’octets :

import requests

# define query parameters as a bytes string

params = b'page=1&limit=10&category=electronics'

response = requests.get('https://api.example.com/products', params=params)

En-têtes de requête

Pour personnaliser les en-têtes d’une requête HTTP dans requests, transmettez-les sous forme de dictionnaire à l’option headers. Par exemple, vous pouvez définir une chaîne personnalisée User-Agent dans requests avec :

import requests

# define custom headers

custom_headers = {

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',

# other headers...

}

# send a GET request with custom headers

response = requests.get('https://api.example.com/data', headers=custom_headers)

Cookies de requête

Alors que les cookies HTTP sont envoyés au serveur via des en-têtes, requests fournit une option dédiée cookies pour les personnaliser. Utilisez-la comme dans l’exemple suivant :

# define custom cookies

custom_cookies = {

'session_id': 'be400765483cf840dfbbd39',

'user_id': '7164'

}

# send a GET request with custom cookies

response = requests.get('https://www.example.com', cookies=custom_cookies)

Notez que cookies accepte un dictionnaire ou un objet http.cookiejar.

Autres configurations

request propose une API riche et de nombreuses techniques avancées sont disponibles. Découvrez quelques-unes des plus pertinentes !

Configuration du proxy

L’intégration du proxy dans requests vous permet d’acheminer vos requêtes HTTP via un serveur proxy. Il s’agit d’un puissant mécanisme permettant de masquer votre adresse IP, de contourner les limiteurs de débit ou d’accéder à du contenu géo-restreint.

Vous pouvez intégrer un serveur proxy à la bibliothèque Python requests en utilisant l’option proxies :

import requests

# define the proxy settings

proxy = {

'http': 'http://username:[email protected]:8080',

'https': 'https://username:[email protected]:8080'

}

# Make a request using the proxy

response = requests.get('https://www.example.com', proxies=proxy)

Pour un tutoriel complet, suivez notre guide sur l’Utilisation d’un proxy avec Python Requests.

Authentification de base

L’authentification HTTP, mieux connue sous le nom d’« authentification de base », est un schéma d’authentification simple intégré au protocole HTTP. Cela implique l’envoi d’un nom d’utilisateur et d’un mot de passe codés au format Base64 dans l’en-tête Authorization.

Bien que vous puissiez l’implémenter en définissant manuellement l’en-tête Authorization, requests expose une option auth dédiée pour celui-ci. Cela accepte un tuple avec le nom d’utilisateur et le mot de passe. Utilisez-le pour gérer l’authentification de base dans la bibliothèque Python requests  :

import requests

# define the username and password for basic authentication

username = 'sample_username'

password = 'sample_password'

# send a GET request with basic authentication

response = requests.get('https://api.example.com/private/users', auth=(username, password))

Vérification des certificats SSL

La vérification des certificats SSL est essentielle pour garantir la sécurité des communications entre les clients et les serveurs sur Internet. Dans le même temps, il arrive que vous fassiez confiance au serveur de destination et que vous n’ayez pas besoin d’appliquer la vérification.

En particulier, lors du routage du trafic HTTP via des serveurs proxy, vous pouvez rencontrer des erreurs liées aux certificats SSL. Dans ce cas, vous devrez peut-être désactiver la vérification des certificats SSL. Dans requests, cela est possible via l’option verify  :

import requests

# send a GET request to a website with SSL certificate verification disabled

response = requests.get('https://api.example.com/data', verify=False)

Délais d’attente

Par défaut, les requêtes attendent automatiquement indéfiniment la réponse du serveur. Si le serveur est en surcharge ou en cas de ralentissement du réseau, ce comportement peut devenir un problème.

Pour éviter de ralentir votre application en attendant une réponse qui risque de ne jamais arriver, requests dispose d’une option timeout . Cela accepte un entier ou un nombre flottant représentant le nombre de secondes à attendre pour une réponse :

import requests

# timeout after 2 second

response1 = requests.get("https://api.example.com/data", timeout=2)

Sinon, timeout accepte un tuple avec deux éléments : le délai de connexion et le délai de lecture. Spécifiez-les comme dans l’exemple ci-dessous :

import requests

# timeout after 2.5 seconds for connections and 4 seconds for reading response

response = requests.get("https://api.example.com/data", timeout=(2.5, 4))

Si la requête établit une connexion dans le délai de connexion spécifié et reçoit des données dans le délai de lecture, la réponse sera renvoyée comme d’habitude. Sinon, si la demande expire, une exception Timeout sera déclenchée :

import requests

from requests.exceptions import Timeout

try:

response = requests.get("https://api.example.com/data", timeout=(2.5, 4))

except Timeout:

print("The request timed out")

Conclusion

Dans cet article, vous avez appris des informations sur la bibliothèque requests, vous avez compris en quoi elle consiste, quelles méthodes elle utilise, comment les utiliser, etc. Vous avez appris que le module Python requests est une bibliothèque HTTP utile et populaire qui couvre plusieurs cas d’utilisation.

Le problème est que toute requête HTTP expose votre adresse IP publique. Cela fournit des informations sur qui vous êtes et où vous vivez, ce qui n’est pas bon pour votre confidentialité. Il existe plusieurs méthodes pour masquer votre adresse IP, et le moyen le plus efficace d’améliorer la sécurité et la confidentialité est d’utiliser un serveur proxy.

Bright Data contrôle les meilleurs serveurs proxy au monde, est au service d’entreprises du Fortune 500 et de plus de 20 000 clients. Son offre comprend un large éventail de types de proxys :

• Des proxys de datacenters : plus de 770 000 adresses IP de datacenters.
• Des proxys résidentiels : plus de 72 millions d’adresses IP résidentielles dans plus de 195 pays.
• Des proxys de FAI : plus de 700 000 adresses IP de FAI.
• Des proxys mobiles : plus de 7 millions d’adresses IP mobiles.