Maîtriser les API Python : Un guide complet pour construire et utiliser des API en Python

Les API, ou interfaces de programmation d'applications, sont les véritables héros du développement logiciel moderne. Ils permettent à différents systèmes logiciels de communiquer entre eux, ce qui rend possible l'intégration de services et la création d'applications. La maîtrise des API est une compétence importante pour quiconque cherche à travailler avec des données en Python, en particulier si vous êtes développeur. Vous pourriez être surpris par les portes qui s'ouvrent à vous, car lorsque vous aurez acquis ces compétences, vous pourrez créer des applications web, vous connecter à des services externes ou même utiliser des données en temps réel dans des projets d'apprentissage automatique.

Dans ce guide, nous allons explorer le monde des API, apprendre à les utiliser en Python, à construire les vôtres avec FastAPI et à gérer les défis courants qui ne manqueront pas de se présenter. À la fin de ce tutoriel, vous aurez acquis une solide compréhension de l'utilisation des API dans vos projets, ce qui rendra votre processus de développement plus efficace et vos applications plus puissantes. Si jamais vous vous sentez bloqué par toutes ces informations, essayez notre cours Introduction aux API en Python, qui passe en revue chaque partie en détail.

Qu'est-ce qu'une API ?

Une API est comme un pont entre différentes applications logicielles. Il permet à ces applications de communiquer et de partager des informations entre elles.

Imaginez une API comme un serveur dans un restaurant. Vous dites au serveur ce que vous voulez (votre commande) et il transmet votre demande à la cuisine. La cuisine prépare votre repas et le serveur vous le rapporte. De même, vous envoyez une demande à une API, qui traite votre demande et renvoie les résultats.

Pour rendre cela plus concret, examinons quelques utilisations réelles : Vous pouvez, par exemple, utiliser une API publique pour récupérer des données financières en vue d'une analyse du marché boursier ou pour accéder à des données météorologiques en temps réel pour un modèle de prévision climatique. Comme vous le remarquez peut-être, les API sont particulièrement importantes pour travailler avec de grands ensembles de données et/ou lorsque vous avez besoin de données en temps réel ; sinon, vous n'auriez peut-être pas de problème avec l'intégration.

Comment fonctionne une API Python. Image par Napkin.AI

Utiliser les API en Python

L'utilisation des API en Python est un moyen puissant d'interagir avec des services externes, de récupérer des données et d'intégrer diverses fonctionnalités dans vos applications. Python rend le travail avec les API simple et efficace, principalement grâce à la bibliothèque derequêtes , qui vous permet d'envoyer des requêtes HTTP pour interagir avec les API.

Introduction aux API en Python

En Python, l'interaction avec les API est un processus simple grâce à la bibliothèque requests. Cette bibliothèque simplifie le processus d'envoi de requêtes HTTP, vous permettant de communiquer avec des API et de récupérer ou d'envoyer des données.

Faire des demandes d'API en Python

Avant de commencer à effectuer des demandes d'API en Python, vous aurez besoin de la bibliothèquerequests. Vous pouvez l'installer à l'aide de cette commande :

pip install requests

Les bases des requêtes API

Marions notre exemple conceptuel impliquant le restaurant avec ce qui se passe réellement dans Python. Voici la répartition simplifiée :

1. Trouvez le bon endroit : Identifiez le point de terminaison de l'API, c'est-à-dire l'adresse web spécifique à laquelle vous enverrez votre demande.

2. Passez votre commande : Utilisez la bibliothèque Python requests pour envoyer la demande à l'API. Vous indiquerez le type d'action que vous souhaitez entreprendre (comme l'obtention ou l'envoi de données).

3. Obtenez votre nourriture : L'API renvoie une réponse que vous pouvez traiter pour en extraire les informations dont vous avez besoin.

Demandes GET

Une requête GET est le type de requête HTTP le plus courant, utilisé pour récupérer des données auprès d'un serveur, comme pour demander des informations. Lorsque vous tapez une URL dans votre navigateur et que vous appuyez sur Entrée, vous envoyez essentiellement une requête GET à ce serveur, en spécifiant la ressource souhaitée, que le serveur traite pour trouver et préparer les données demandées avant de les renvoyer dans un format tel que JSON ou XML.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

Dans cet exemple, nous envoyons une requête GET à une API fictive et nous imprimons la réponse JSON. Les requêtes GET sont généralement utilisées pour récupérer des données sans les modifier.

Demandes POST

Alors que les requêtes GET récupèrent des données, les requêtes POST envoient des instructions à un serveur. Ils sont souvent utilisés pour créer de nouvelles ressources (comme l'ajout d'un utilisateur) ou pour mettre à jour des ressources existantes (comme la modification d'un profil).

Imaginez que vous remplissiez un formulaire en ligne pour vous inscrire à un service. Lorsque vous cliquez sur soumettre, vous envoyez essentiellement une demande POST avec vos informations. Voici un exemple simplifié :

# Data to send (like user information)data = {'name': 'John Doe', 'email': 'john.doe@example.com'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Cet exemple envoie à l'API un dictionnaire contenant des informations sur l'utilisateur sous forme de données JSON. Nous vérifions ensuite le code d'état de la réponse pour voir si l'utilisateur a été créé avec succès.

Traitement des réponses

Lorsque vous faites une demande d'API, le serveur renvoie une réponse qui contient deux informations essentielles :

• Code d'état : Un nombre indiquant le succès ou l'échec de la demande. Par exemple, 200 signifie généralement un succès, tandis que 404 signifie que la ressource n'a pas été trouvée.
• Données : Les informations que vous avez demandées sont souvent au format JSON. C'est là que se trouve le contenu de valeur.

Voici un exemple en Python :

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

Comprendre les codes d'état de l'API Python

Les codes d'état API sont des réponses standardisées que les serveurs renvoient pour indiquer le résultat de la demande d'un client. Ces codes aident les développeurs à comprendre si une demande a abouti, si une erreur s'est produite ou si une action supplémentaire est nécessaire.

Codes d'état communs

• 200 OK: Ce code d'état indique que la demande a abouti. Par exemple, lorsque vous faites une demande GET pour récupérer des données d'une API, une réponse 200 OK signifie que les données ont été récupérées correctement.  

• 404 Non trouvé: Ce code est renvoyé lorsque le serveur ne trouve pas la ressource demandée. Par exemple, si vous essayez d'accéder à un point de terminaison qui n'existe pas, vous recevrez une erreur 404 Not Found.

• 500 Internal Server Error: Ce code signale que quelque chose s'est mal passé du côté du serveur. Il s'agit d'un message d'erreur générique qui peut survenir en raison de divers problèmes, tels que des bogues dans le code du serveur ou des problèmes avec la base de données.

Traitement des différents codes d'état

La gestion efficace des codes d'état des API dans vos applications Python garantit que votre code se comporte de manière prévisible et qu'il peut gérer les erreurs avec élégance. Si la réponse est 200, procédez au traitement des données renvoyées. Lorsque vous rencontrez une erreur 404, vérifiez si l'URL de l'extrémité est correcte et, si nécessaire, mettez en place une logique de repli ou informez l'utilisateur que la ressource n'est pas disponible. Pour les erreurs 500, envisagez de réessayer la demande après un bref délai ou d'enregistrer l'erreur en vue d'une enquête plus approfondie. Cependant, évitez les tentatives excessives afin de ne pas surcharger le serveur.

Construire des API en Python

La construction d'API avec Python vous permet de créer des interfaces d'application puissantes et efficaces. La simplicité de Python et ses bibliothèques robustes en font un excellent choix pour le développement d'API.

Introduction à FastAPI

Maintenant que vous savez comment utiliser les API, voyons comment nous pouvons créer les nôtres. FastAPI est un framework web moderne et rapide (haute performance) pour construire des API avec Python. Comme son nom l'indique, il est conçu pour être facile à utiliser. Ce que j'apprécie dans FastAPI, c'est qu'il génère automatiquement une documentation interactive.

Configuration de FastAPI

Pour commencer, vous devez installer Python et son gestionnaire de paquets, pip. Ensuite, installez FastAPI et Uvicorn, un serveur ASGI très performant :

pip install fastapi uvicorn

Note complémentaire : Si vous rencontrez des problèmes avec Python ou la configuration de pip, consultez notre tutoriel : Comment mettre à jour Python et Pip sous Windows, MacOS et Linux.

Création d'une API simple

Construisons une API simple qui renvoie un simple message d'accueil :

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Pour lancer cette API, exécutez la commande suivante :

uvicorn main:app --reload

Cette commande lance le serveur Uvicorn, qui sert votre API sur http://127.0.0.1:8000. En accédant à cette URL dans votre navigateur web, vous obtiendrez la réponse suivante: {"Hello": "World"}.

Fonctionnalités avancées de FastAPI

FastAPI ne se contente pas de créer rapidement des API simples ; il offre également une série de fonctionnalités avancées qui le rendent adapté à des applications complexes et très performantes. Voici quelques-unes de ses principales fonctionnalités : 

Paramètres d'interrogation

Dans FastAPI, l'ajout et la gestion des paramètres de requête sont simples, grâce à l'utilisation des indices de type de Python. Les paramètres de requête font partie de l'URL et sont utilisés pour transmettre des données facultatives au point de terminaison de l'API, souvent pour filtrer ou modifier les données renvoyées.

Ajout de paramètres de requête

Pour ajouter un paramètre de requête dans FastAPI, il vous suffit de le définir en tant qu'argument de fonction dans votre fonction d'opération de chemin. Si un paramètre est facultatif, vous pouvez lui attribuer une valeur par défaut, telle que None. Par exemple, supposons que vous ayez un point d'accès qui récupère des éléments d'une base de données. Vous souhaitez permettre aux utilisateurs de filtrer les éléments en fonction d'une requête de recherche :

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

Dans cet exemple, q est un paramètre de requête facultatif. Si vous indiquez une valeur pour q, les résultats sont filtrés en fonction de cette requête. Si q n'est pas fourni, le point d'accès renvoie tous les éléments.

Gestion des paramètres de requête

FastAPI gère automatiquement les paramètres de la requête, y compris la validation et la conversion des types. Par exemple, si vous spécifiez un paramètre de requête comme étant un entier, FastAPI validera que l'entrée est bien un entier. Si l'entrée ne correspond pas au type attendu, FastAPI renvoie un message d'erreur clair.

Voici un exemple avec un paramètre de requête obligatoire et une validation de type :

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

Dans ce cas, item_id est un paramètre de chemin et q est un paramètre de requête facultatif. FastAPI s'assurera que item_id est un nombre entier et traitera le paramètre de requête q s'il est fourni.

Gestion des différentes méthodes HTTP

La mise en œuvre de différentes méthodes HTTP telles que GET, POST, PUT et DELETE est simple et reflète la façon dont vous définissez les routes dans d'autres frameworks. Chaque méthode est liée à un type d'opération spécifique, comme la récupération de données (GET), la création de nouvelles données (POST), la mise à jour de données existantes (PUT) ou la suppression de données (DELETE).

Méthode GET

La méthode GET est utilisée pour récupérer les données du serveur. Dans FastAPI, vous définissez un point de terminaison GET comme suit :

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

Méthode POST

La méthode POST est utilisée pour créer de nouvelles données. Vous pouvez définir un point de terminaison POST et recevoir des données dans le corps de la requête :

@app.post("/items/")def create_item(item: dict):    return {"item": item}

Méthode PUT

La méthode PUT est utilisée pour mettre à jour les données existantes. Elle nécessite généralement un identifiant et les nouvelles données :

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

Méthode DELETE

La méthode DELETE est utilisée pour supprimer les données. Dans FastAPI, un point d'extrémité DELETE est défini comme suit :

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Authentification et sécurité

FastAPI propose plusieurs mécanismes pour mettre en œuvre l'authentification et la sécurité :

• HTTP Basic Auth: Il s'agit d'une méthode simple, mais généralement déconseillée pour les environnements de production en raison de problèmes de sécurité.
• Clés API: Une option plus sûre consiste à générer des clés uniques pour les clients.
• OAuth 2.0: Norme d'autorisation complexe mais robuste, couramment utilisée pour les intégrations de tiers.
• Jetons Web JSON (JWT): Une approche populaire pour représenter les réclamations en toute sécurité entre deux parties.