# Python requests : envoyer des requêtes HTTP avec Python

Python `requests` est une bibliothèque très appréciée qui permet d’envoyer des requêtes HTTP et d’en vérifier les réponses. Même si `.get()` est la méthode la plus importante du module, il existe de nombreuses autres options.

## Python `requests`, c’est quoi au juste ?

Python `requests` est une bibliothèque tierce largement utilisée pour **envoyer des requêtes HTTP** au sein du [langage de programmation](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quel-langage-de-programmation-apprendre/). La pierre angulaire de ce système est une interface claire et efficace qui facilite grandement l’intégration de fonctionnalités tierces. La bibliothèque Python `requests` met à disposition une série d’outils qui permettent d’envoyer des requêtes HTTP et d’en recevoir les réponses. Même si le module Python `requests` est largement utilisé et fortement conseillé, **il ne fait pas partie de l’installation standard** de Python.

## Installation et démarrage de la bibliothèque Python `requests`

Avant d’installer Python `requests`, il est recommandé de **mettre en place une [machine virtuelle](https://www.ionos.fr/digitalguide/serveur/know-how/machine-virtuelle/)** dans laquelle vous pourrez essayer la bibliothèque sans crainte. Pour l’installation, utilisez `pip`. Voici à quoi ressemble le code :

```bash
$ python -m pip install requests
```

Pour utiliser la bibliothèque après l’avoir installée avec succès, vous avez besoin de ce code :

```python
import requests
```

## Fonctionnement, syntaxe et méthodes

Comme d’autres outils comparables, Python `requests` envoie une requête HTTP qui reçoit une réponse à la suite d’une transmission réussie. Cette réponse est un objet qui contient toutes les informations importantes telles que **contenu, codage et statut**. La syntaxe d’une telle requête se présente toujours comme suit :

```python
requests.methode(url, **kwargs)
```

Note `**kwargs` représente des méthodes optionnelles que vous pouvez remettre à des méthodes comme `headers`, `files` ou `cookies`.

Même si `.get()` est la fonction que vous utiliserez le plus souvent, Python `requests` propose également d’autres méthodes. Voici les principales fonctions disponibles :

- **`.delete(url,** kwargs)`** : supprime une source spécifique.
- **`.get(url, parameter=None,** kwargs)`** : sert à demander des informations à un serveur.
- **`.head(url,** kwargs)`** : effectue une requête au serveur, mais se limite à l’en-tête.
- **`.patch(url, data=None,** kwargs)`** : optimise les performances en envoyant uniquement les modifications à la source.
- **`.post(url, data=None, json=None,** kwargs)`** : utilisé principalement pour transmettre des données de formulaire à un serveur.
- **`.put(url, data=None,** kwargs)`** : modifie une source existante ou crée de nouvelles données sur le serveur.
- **`.request(method, url,** kwargs)`** : envoie une requête avec une méthode spécifique à une URL donnée.

## Exemple concernant la méthode `.get()`

La syntaxe de `.get()` est très claire, ce qui fait de Python `requests` une bibliothèque très pratique. Il vous suffit de la méthode et de l’URL à laquelle vous voulez accéder. Celle-ci est indiquée entre guillemets. Voici un exemple d’un code de ce type :

```python
import requests
requests.get("https://exemple.com")
```

Le serveur cible vous envoie une réponse. Pour illustrer cela, vous pouvez aussi l’afficher dans une variable. Dans notre exemple, cela ressemblerait à ceci :

```python
import requests
response = requests.get("https://exemple.com")
```

## Consulter les codes de statut

La réponse la plus simple qui vous est donnée à une requête est un [code de statut HTTP](https://www.ionos.fr/digitalguide/hebergement/aspects-techniques/apercu-des-codes-de-statut-http-principaux/). Celui-ci vous indique si votre demande a abouti ou non. Le code de statut est composé de **trois chiffres**. Il existe de nombreuses variantes qui vous informent de l’évolution de votre demande. Les principales catégories sont les suivantes :

- **1XX** : contient des informations complémentaires.
- **2XX** : atteste d’une requête réussie.
- **3XX** : vous informe d’une redirection de votre requête.
- **4XX** : signale une erreur côté client.
- **5XX** : notifie une erreur côté serveur.

Remarque L’un des codes de statut les plus connus est « 200 – OK » (pour une requête réussie) et « [404 – Not Found](https://www.ionos.fr/digitalguide/sites-internet/creation-de-sites-internet/que-signifie-la-page-404-not-found/) » (si les données demandées n’ont pas été trouvées sur le serveur).

Après votre demande via Python `requests`, vous pouvez consulter le statut avec `.status_code`. Pour ce faire, utilisez le code suivant :

```python
response.status_code
```

Si votre requête a abouti, vous recevrez le message suivant :

```python
200
```

Le code suivant est utile pour une meilleure présentation :

```python
if response.status_code == 200:
	print("La requête a abouti.")
elif response.status_code == 404:
	print("La requête n’a pas abouti.")
```

## Consulter l’en-tête avec Python `requests`

L’en-tête d’une réponse HTTP contient de nombreuses informations utiles. Vous y trouverez entre autres le **type de données envoyées, un délai de mise en cache** et d’autres indications. La bibliothèque Python `requests` permet aussi d’afficher facilement l’en-tête. Pour ce faire, exécutez d’abord la fonction `.get()`, puis `.headers` :

```python
import requests
response = requests.get("https://exemple.com")
response.headers
```

En sortie, vous obtenez ainsi un objet qui contient les valeurs de l’en-tête. Vous pouvez aussi les consulter individuellement en spécifiant la commande. Si vous souhaitez, par exemple, en savoir plus sur le type de données, voici la bonne commande :

```python
response.headers["content-type"]
```

## Accéder à la charge utile

Le paquet de données **envoyé entre le serveur et le client** est également connu sous le nom de « charge utile » (*payload*). Il se trouve dans le corps de la réponse. `response` permet d’accéder aux informations qui s’y trouvent. Pour obtenir une représentation en octets, l’instruction suivante est indiquée :

```python
import requests
response = requests.get("https://exemple.com")
response.content
type(response.content)
```

Si vous souhaitez convertir les informations collectées en chaîne de caractères (*string*), utilisez le code suivant :

```python
response.text
type(response.text)
```

Python `requests` extrait l’encodage de l’en-tête. Vous pouvez également demander au système d’utiliser une autre méthode. Ce code est un exemple :

```python
response.encoding = "utf-8"
response.text
```

## Vérifier la progression

Lorsque vous envoyez une requête, celle-ci est préparée par Python `requests` afin d’éviter des erreurs. En ce faisant, **l’en-tête est vérifiée**, entre autres. Vous pouvez inspecter les détails de la requête envoyée à l’aide de la fonction `.request`. Pour cela, utilisez le code suivant :

```python
import requests
response = requests.post("https://exemple.com", json={"key": "value"})
print(response.request.headers["content-type"])
print(response.request.url)
print(response.request.body)
```

Vous obtenez ainsi des informations sur la charge utile, l’en-tête, l’URL et plus encore.

## Vérification d’authenticité via le module Python `requests`

Le paramètre `auth` est utilisé dans Python `requests` pour envoyer une authentification au serveur. Celui-ci peut effectuer une vérification d’authenticité et contrôler, ainsi, avec qui il interagit réellement. Pour utiliser cette vérification, appliquer un code comme celui-ci :

```python
import requests
from requests.auth import HTTPBasicAuth
response = requests.get("https://votre_page.com/basic-auth/user/passwd", 
	auth=HTTPBasicAuth("user", "passwd"))
print(response.status_code)
print(response.request.headers["Authorization"])
```

## Utiliser un certificat SSL

En principe, l’utilisation d’un [certificat SSL](https://www.ionos.fr/digitalguide/sites-internet/creation-de-sites-internet/certificat-ssl/) est utile pour éviter la perte de données et les intrusions indésirables. Python `requests` propose cette option par défaut. Si vous souhaitez toutefois **empêcher la vérification mutuelle pour une requête**, vous pouvez désactiver SSL grâce au code suivant :

```python
import requests
requests.get("https://exemple.com", verify=False)
```

Vous recevrez alors un message d’avertissement explicite.

Note Désactiver la vérification SSL peut **compromettre la sécurité de votre application** en la rendant vulnérable face aux cyberattaques. Utilisez cette option uniquement pour des tests ou dans des environnements de développement où la sécurité n’est pas critique.

## Déclencher un timeout avec Python `requests`

Python `requests` permet entre autres de limiter **le temps maximum pour une réponse**. Par défaut, le client attend une réponse sans restriction. En l’absence de celle-ci, les demandes peuvent s’accumuler et les performances en pâtir. Le paramètre `timeout` permet d’éviter ce problème. Dans le code suivant, nous indiquons à Python `requests` d’interrompre la requête au bout de deux secondes :

```python
requests.get("https://exemple.com", timeout=2)
```

Conseil Déployez votre site Internet ou votre application directement via GitHub : avec [Deploy Now](https://www.ionos.fr/hebergement/deploy-now "Deploy Now » Déployez vos projets via GitHub | IONOS") de IONOS, vous disposez de la solution optimale pour les applications à page unique comme pour les sites Internet statiques. Choisissez le tarif le plus adapté à vos besoins et profitez d’une installation plus rapide, de workflows optimisés et d’une conception sécurisée !


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-requests/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-requests/) for AI/LLM consumption.