Premiers pas avec les requêtes HTTP Python pour les API REST

Réponse rapide : Faire des requêtes GET et POST en Python

Vous êtes pressé ? Voici la syntaxe Python pour effectuer une simple requête GET et POST:

1. Demande GET

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/1"

# A GET request to the API
response = requests.get(url)

# Print the response
print(response.json())

2. Demande POST

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts"

# Data to be sent
data = {
    "userID": 1,
    "title": "Making a POST request",
    "body": "This is the data we created."
}

# A POST request to the API
response = requests.post(url, json=data)

# Print the response
print(response.json())

Si vous souhaitez approfondir vos connaissances en matière de requêtes HTTP avec Python et en savoir plus sur les API REST, continuez à lire !

Qu'est-ce qu'une API REST ?

Nous avons établi que les API sont des médiateurs logiciels. On peut également les considérer comme un type d'interface logicielle qui permet à d'autres applications d'accéder à des données et à des méthodes spécifiques. 

L'une des architectures les plus populaires utilisées pour créer des API est le modèle REST (REpresentational State Transfer). La conception architecturale REST permet au client et au serveur d'être mis en œuvre indépendamment l'un de l'autre sans être conscients l'un de l'autre. Cela signifie que l'on peut modifier le code d'un côté ou de l'autre sans se préoccuper de la manière dont le changement affectera l'autre côté. 

Les API REST suivent donc un ensemble de lignes directrices conçues pour simplifier les communications entre les logiciels, rendant ainsi le processus d'accès aux données plus simple et plus logique. Ne vous inquiétez pas si vous ne connaissez pas ces lignes directrices ; vous n'avez pas besoin de les connaître pour commencer - ce que vous devez savoir, c'est comment les données sont exposées à partir des services REST. 

Les données des services web REST sont exposées à l'internet par le biais d'une URL publique, à laquelle on peut accéder en envoyant une requête HTTP.  

Aperçu des méthodes de requête HTTP

Reprenons notre analogie avec le restaurant : pour commander de la nourriture dans un restaurant, le serveur s'approche de vous et vous dites ce que vous voulez. Le serveur transmet ensuite votre demande au chef cuisinier, qui prépare le repas et le transmet au serveur pour qu'il vous le rende. En d'autres termes, le chef ne préparera pas votre repas tant que votre demande n'aura pas été envoyée. 

Les API REST sont identiques : elles écoutent les méthodes de requête HTTP avant d'agir. Le protocole HTTP définit un ensemble de méthodes de requête qui indiquent à l'API les opérations à effectuer pour une ressource donnée. Il spécifie comment interagir avec les ressources situées au point d'accès fourni. 

Il existe plusieurs méthodes HTTP, mais cinq sont couramment utilisées avec les API REST : 

Il est très probable que vous effectuiez des requêtes GET plus souvent que toute autre méthode dans le cadre de l'analyse et de la science des données. En effet, c'est la méthode nécessaire pour accéder à certains ensembles de données. Apprenez-en plus à ce sujet avec la formation Intermédiaire Importation de données en Python de DataCamp.

Lorsque vous adressez une demande à un serveur web, l'API renvoie une réponse. La réponse est accompagnée d'un code d'état HTTP. Le code d'état a pour but de fournir des informations supplémentaires sur la réponse afin que le client sache quel type de demande il a reçu.

Qu'est-ce qu'un point final d'API ?

Une URL définit les données avec lesquelles vous interagissez sur un serveur web. Tout comme l'URL d'une page web est liée à une page unique, l'URL d'un point de terminaison est liée à des ressources particulières au sein d'une API. Par conséquent, un point de terminaison peut être décrit comme un emplacement numérique où une API reçoit des demandes concernant une ressource particulière sur son serveur - considérez-le comme l'autre extrémité d'un canal de communication. 

Pour ajouter au contexte, les API REST exposent un ensemble d'URL publiques qui peuvent être demandées par les applications clientes pour accéder aux ressources du service web. Les URL publiques exposées par l'API REST sont appelées "points de terminaison".

Utiliser Python pour effectuer des requêtes HTTP

Le module Python requests permet aux développeurs d'écrire du code pour interagir avec les API REST. Il leur permet d'envoyer des requêtes HTTP à l'aide de Python sans avoir à se préoccuper des complexités qui accompagnent généralement ce type de tâches (c'est-à-dire ajouter manuellement des chaînes de requête aux URL, coder les formulaires PUT et POST, etc.) 

Bien qu'il soit considéré comme la norme de facto pour effectuer des requêtes HTTP en Python, le module requests ne fait pas partie de la bibliothèque standard de Python - il doit être installé. 

La manière la plus simple d'installer le module de requêtes est d'utiliser pip : 

python -m pip install requests

Il est toujours recommandé de gérer les paquets Python nécessaires aux différents projets à l'aide d'environnements virtuels. De cette manière, les paquets d'un projet ne risquent pas d'interférer et de casser les outils système des autres projets, car ils sont isolés - au lieu d'être installés globalement. 

Maintenant que nous avons installé le module de requêtes, voyons comment il fonctionne. Suivez le code dans ce classeur DataLab. 

Faire une requête GET en Python

Nous avons déjà établi que GET est l'une des méthodes de requête HTTP les plus courantes que vous rencontrerez lorsque vous travaillerez avec des API REST. Il vous permet (en tant que client) de récupérer des données sur des serveurs web. 

Il est important de noter que GET est une opération en lecture seule, ce qui signifie qu'elle ne convient que pour accéder aux ressources existantes et ne doit pas être utilisée pour les modifier. 

Pour démontrer le fonctionnement du module de requête, nous utiliserons JSONPlaceholder, une fausse API disponible gratuitement et utilisée à des fins de test et de prototypage. 

import requests

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/1"

# A GET request to the API
response = requests.get(url)

# Print the response
response_json = response.json()
print(response_json)

"""
{'userId': 1, 'id': 1, 'title': 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit', 'body': 'quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto'}
"""

Dans le code ci-dessus, nous avons effectué les opérations suivantes : 

1. Définit le point de terminaison de l'API à partir duquel les données doivent être récupérées.
2. Utilisez la méthode requests.get(url) pour récupérer les données du point final défini. 
3. Nous avons utilisé la méthode response.json() pour stocker les données de la réponse dans un objet dictionnaire ; notez que cela ne fonctionne que parce que le résultat est écrit au format JSON - une erreur aurait été soulevée dans le cas contraire.   
4. La dernière étape consiste à imprimer les données de la réponse JSON. 

Nous pouvons également vérifier le code d'état renvoyé par l'API comme suit : 

# Print status code from original response (not JSON)
print(response.status_code)

"""
200
"""

Vous pouvez également transmettre des arguments à une requête GET de Python. Pour ce faire, nous devons modifier légèrement le code ci-dessus. Voici à quoi ressemble le nouveau code :

# The API endpoint
url = "https://jsonplaceholder.typicode.com/posts/"

# Adding a payload
payload = {"id": [1, 2, 3], "userId":1}

# A get request to the API
response = requests.get(url, params=payload)

# Print the response
response_json = response.json()

for i in response_json:
    print(i, "\n")

"""
{'userId': 1, 'id': 1, 'title': 'sunt aut facere repellat provident occaecati excepturi optio reprehenderit', 'body': 'quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto'}

{'userId': 1, 'id': 2, 'title': 'qui est esse', 'body': 'est rerum tempore vitae\nsequi sint nihil reprehenderit dolor beatae ea dolores neque\nfugiat blanditiis voluptate porro vel nihil molestiae ut reiciendis\nqui aperiam non debitis possimus qui neque nisi nulla'}

{'userId': 1, 'id': 3, 'title': 'ea molestias quasi exercitationem repellat qui ipsa sit aut', 'body': 'et iusto sed quo iure\nvoluptatem occaecati omnis eligendi aut ad\nvoluptatem doloribus vel accusantium quis pariatur\nmolestiae porro eius odio et labore et velit aut'}
"""

Voici ce que nous avons fait différemment : 

1. Modification du point d'arrivée de l'API. Remarquez qu'il n'y a plus de "1" à la fin. 
2. Définition de la charge utile dans un dictionnaire.  
3. Transmettre la charge utile à l'argument param de la méthode requests.get(). 
4. Cette opération renvoie un objet liste, nous parcourons donc la liste en boucle et imprimons chaque élément sur une nouvelle ligne.  

Faire une requête POST en Python

GET vous permettent de récupérer des données ; les requêtes POST vous permettront de créer de nouvelles données. Voyons comment nous pouvons créer de nouvelles données sur le serveur JSONPlaceholder.

# Define new data to create
new_data = {
    "userID": 1,
    "id": 1,
    "title": "Making a POST request",
    "body": "This is the data we created."
}

# The API endpoint to communicate with
url_post = "https://jsonplaceholder.typicode.com/posts"

# A POST request to tthe API
post_response = requests.post(url_post, json=new_data)

# Print the response
post_response_json = post_response.json()
print(post_response_json)

"""
{'userID': 1, 'id': 101, 'title': 'Making a POST request', 'body': 'This is the data we created.'}
"""

Dans le code ci-dessus, nous avons effectué les opérations suivantes : 

1. Création d'une nouvelle ressource que nous souhaitons ajouter à l'API JSONPlaceholder.
2. Défini le point d'arrivée pour POST les nouvelles données.
3. Envoyez une demande POST en utilisant la méthode requests.post(). Notez que le paramètre json a été défini dans la méthode post(); nous le faisons pour indiquer à l'API que nous envoyons explicitement un objet JSON à l'URL spécifiée. 
4. Utilisez la méthode response.json() pour stocker les données de la réponse dans un objet dictionnaire.
5. La dernière étape consiste à imprimer les données de la réponse JSON. 

Mais attendez !

Avant de lire la suite du code, prenez 20 secondes pour réfléchir au code d'état que l'API renverra. 

Rappelez-vous : cette fois-ci, nous avons créé une nouvelle ressource au lieu de simplement la récupérer. 

D'accord, c'est parti... 

# Print status code from original response (not JSON)
print(post_response.status_code)

"""
201
"""

Avez-vous bien compris ? 

Requêtes HTTP en Python - Sujets avancés

Effectuer des requêtes HTTP avec Python est généralement simple ; cependant, il est parfois inévitable d'avoir recours à une configuration plus avancée ou d'être confronté à des problèmes. Voici quelques défis que vous pourriez rencontrer et comment les résoudre. 

Authentification des requêtes HTTP

Jusqu'à présent, nos interactions avec l'API REST ont été assez simples. L'API JSONPlaceholder ne nécessite aucune authentification pour que vous puissiez commencer à interagir avec elle. Cependant, il existe plusieurs cas où une API REST peut nécessiter une authentification avant que l'accès ne soit accordé à des points d'extrémité spécifiques - en particulier lorsque vous traitez des données sensibles. 

Par exemple, si vous souhaitez créer des intégrations, récupérer des données et automatiser vos flux de travail sur GitHub, vous pouvez le faire avec l'API REST de GitHub. Cependant, de nombreuses opérations sur l'API REST de GitHub nécessitent une authentification, comme la récupération d'informations publiques et privées sur les utilisateurs authentifiés. 

Voici une solution simple utilisant le module Python requests : 

from requests.auth import HTTPBasicAuth

private_url = "https://api.github.com/user"
github_username = "username"
token = "token"

private_url_response = requests.get(
    url=private_url,
    auth=HTTPBasicAuth(github_username, token)
)

private_url_response.status_code

"""
200
"""

Dans le code ci-dessus, nous :

1. Importation de l'objet HTTPBasicAuth à partir de requests.auth. Cet objet associe l'authentification de base HTTP à l'objet de requête donné - c'est essentiellement la même chose que de taper votre nom d'utilisateur et votre mot de passe sur un site web. 
2. Définit le point d'extrémité de l'URL privée à laquelle il faut accéder.
3. Instanciation d'une variable avec un nom d'utilisateur GitHub - nous avons anonymisé le nom d'utilisateur pour des raisons de confidentialité.
4. Instanciation d'une variable GitHub avec un jeton d'accès personnel pour l'authentification.  
5. Récupère les données de notre point d'accès et les stocke dans la variable private_url_response . 
6. Affichage du code d'état.  

Gestion des erreurs de requête HTTP

Il arrive que les demandes adressées à une API ne se déroulent pas comme prévu. Plusieurs facteurs, tant du côté du client que du côté du serveur, peuvent être en cause. Quelle que soit la cause, le résultat est toujours le même : la demande échoue. 

Lorsque vous utilisez des API REST, c'est toujours une bonne idée de rendre votre code résistant. Cependant, avant d'écrire un code robuste, vous devez comprendre comment gérer les erreurs signalées lorsque les choses ne se déroulent pas comme prévu.  

Pour cette démonstration, revenons à l'API JSONPlaceholder. Nous commencerons par écrire un peu de code, puis nous expliquerons ce qui se passe.  

# A deliberate typo is made in the endpoint "postz" instead of "posts"
url = "https://jsonplaceholder.typicode.com/postz"

# Attempt to GET data from provided endpoint
try:
    response = requests.get(url)
    response.raise_for_status()
# If the request fails (404) then print the error.
except requests.exceptions.HTTPError as error:
  print(error)

"""
404 Client Error: Not Found for url: https://jsonplaceholder.typicode.com/postz
"""

Dans le code ci-dessus : 

1. Nous avons défini le point de terminaison du détenteur de JSONPlace à partir duquel les données sont récupérées, mais nous avons fait une erreur de frappe délibérée lors de la construction de l'URL - ce qui entraînera une erreur 404. 
2. Nous avons utilisé la gestion des exceptions intégrée à Python pour try et except (attraper) toutes les erreurs qui se produisent lorsque vous essayez de visiter le point de terminaison JSONPlaceholder. Notez que la méthode raise_for_status() est utilisée pour renvoyer un objet HTTPError lorsqu'une erreur se produit au cours du processus.
3. Enfin, nous avons imprimé l'erreur qui a été soulevée. 

Bien que nous ayons montré comment gérer les codes d'état d'erreur 404 dans cet exemple, le même format peut être utilisé pour gérer n'importe quel code d'état HTTP. 

Gérer un trop grand nombre de redirections

Les codes d'état HTTP au format 3xx indiquent que le client a été redirigé et qu'il doit effectuer des actions supplémentaires pour compléter la demande. Cependant, cela peut parfois conduire à une boucle de redirection infinie.

Le module de requêtes de Python fournit l'objet TooManyRedirects pour gérer ce problème, comme suit : 

"""
Note: The code here will not raise an error
but the structure is how you would hand a case where there
are multiple redirects
"""

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url)
  response.raise_for_status()
except requests.exceptions.TooManyRedirects as error:
  print(error)

Vous pouvez également définir le nombre maximum de redirections en tant que paramètre de votre méthode de requête HTTP : 

# Solution 2
url = "https://jsonplaceholder.typicode.com/posts"
session = requests.Session()
session.max_redirects = 3
response = session.get(url)

Une autre option consiste à désactiver complètement les redirections : 

# Solution 3
url = "https://jsonplaceholder.typicode.com/posts"
session = requests.Session()
session.allow_redirects = False
response = session.get(url)

Gestion des erreurs de connexion des requêtes HTTP

Il s'agit d'autres types d'erreurs que vous pouvez rencontrer lorsque vous tentez d'envoyer des requêtes à un serveur. Il y a plusieurs raisons pour lesquelles vous ne recevez pas de réponse du serveur (échec du DNS, connexion refusée, problèmes de connexion internet, etc.), mais le résultat est le même : une erreur de connexion est signalée. 

Vous pouvez utiliser l'objet d'exception requests modules ConnectionError pour détecter ces problèmes et les traiter en conséquence. 

Voici à quoi ressemblerait le code :  

"""
Note: The code here will not raise an error
but the structure is how you would hand a case where there
is a connection error.
"""

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url)
except requests.ConnectionError as error:
  print(error)

Délai de traitement des requêtes HTTP

Lorsque le serveur de l'API accepte votre connexion mais ne peut pas terminer votre demande dans le délai imparti, vous obtenez une "erreur de dépassement de délai".

Nous allons montrer comment traiter ce cas en fixant le paramètre timeout de la méthode requests.get() à un nombre extrêmement petit ; cela provoquera une erreur, que nous traiterons à l'aide de l'objet requests.Timeout . 

url = "https://jsonplaceholder.typicode.com/posts"

try:
  response = requests.get(url, timeout=0.0001)
except requests.Timeout as error:
  print(error)

La solution la plus simple pour remédier aux erreurs de délai est de définir des délais plus longs. D'autres solutions peuvent consister à optimiser vos requêtes, à intégrer une boucle de réessai dans vos scripts ou à effectuer des appels API asynchrones - une technique qui permet à votre logiciel de commencer une activité potentiellement longue tout en réagissant à d'autres événements plutôt que d'attendre que cette tâche soit terminée.

Récapitulation

Dans ce tutoriel, nous avons expliqué ce que sont les API et exploré une architecture d'API commune appelée REST. Nous avons également étudié les méthodes HTTP et la manière dont nous pouvons utiliser la bibliothèque Python requests pour interagir avec les services web. 

Consultez les cours suivants pour développer vos compétences en science des données : 

• Introduction aux API en Python
• Ingestion de données rationalisée avec Pandas 
• Analyser les données des médias sociaux en Python
• Intermédiaire Importer des données en Python