Comment créer rapidement des API en Python

Les API constituent l'épine dorsale de la plupart des applications qui reposent sur l'échange de données ou des intégrations externes.

Apprendre à créer des API en Python peut ouvrir de nombreuses opportunités pour connecter votre application à d'autres systèmes et créer un backend polyvalent.

Ici, je vais vous expliquer les bases des API, la création d'API REST et leur construction avec Flask et FastAPI, deux frameworks Python populaires.

1. Introduction aux API

Dans le monde numérique d’aujourd’hui, les API sont partout.

Ils permettent à différents systèmes et applications de communiquer entre eux, partageant des données et des fonctionnalités de manière transparente.

Par exemple, lorsque vous utilisez une application pour vérifier la météo, elle appelle en fait une API qui renvoie les données météorologiques.

Les API facilitent la vie en agissant comme des intermédiaires qui traitent les requêtes et renvoient les données de manière standardisée.

Il convient également de noter que les API ne servent pas uniquement aux applications clientes (telles que les sites Web ou les applications mobiles).

Les API peuvent être utilisées entre des systèmes backend ou des microservices au sein de la même infrastructure pour gérer les données plus efficacement.

2. API REST

REST (Representational State Transfer) est l'un des moyens les plus populaires de créer des API en raison de sa simplicité et de sa compatibilité avec HTTP.

Les API RESTful sont structurées pour permettre aux méthodes HTTP standard (telles que GET, POST, PUT, DELETE) de manipuler les ressources.

Ils sont souvent utilisés pour gérer les opérations CRUD (Créer, Lire, Mettre à jour et Supprimer), où chaque méthode de requête effectue une opération sur les données de ressources.

Si vous créez un service Web, REST est probablement le format le plus accessible et le plus largement pris en charge pour commencer.

Les API REST sont également sans état, ce qui signifie que chaque requête fonctionne indépendamment, ce qui permet aux API REST d'évoluer plus facilement.

3. Construire une API avec Flask

Flask est mon choix pour les projets de petite ou moyenne taille, car il est léger et facile à mettre en œuvre.

Flask vous permet de contrôler presque tous les aspects de votre API, mais cela nécessite également un peu plus de travail sur la validation des données et la gestion des erreurs.

Cette flexibilité, cependant, est idéale pour ceux qui souhaitent plus de contrôle sur le fonctionnement de chaque partie de l'API.

Exemple de création d'une API Flask

Voici à quoi peut ressembler une API de gestion des tâches dans Flask.

Tout d'abord, assurez-vous d'installer flask avec pip :

pip install flask

Cet exemple montre comment configurer rapidement des points de terminaison pour obtenir et créer des tâches, ainsi que pour mettre à jour et supprimer.

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Ce code Python configure une API REST utilisant Flask pour gérer une liste de tâches, permettant aux clients de créer, récupérer, mettre à jour et supprimer des tâches.

Les tâches sont stockées dans une liste où chaque tâche est un dictionnaire avec un identifiant, une tâche et un statut terminé.

Le point de terminaison /tasks prend en charge les requêtes GET pour renvoyer la liste complète des tâches et les requêtes POST pour ajouter de nouvelles tâches, attribuant automatiquement à chaque tâche un identifiant unique.

Des points de terminaison supplémentaires, /tasks/, permettent aux utilisateurs d'interagir avec des tâches individuelles : GET récupère une tâche spécifique par ID, PUT la met à jour et DELETE la supprime de la liste.

Si une tâche avec l'ID spécifié n'est pas trouvée, ces points de terminaison renvoient une erreur 404 avec un message approprié.

L'API fonctionne en mode débogage, ce qui la rend idéale à des fins de développement et de test.

Sachez simplement que pour les projets plus importants, vous devrez peut-être ajouter des mécanismes de routage et de validation plus structurés.

4. Construire une API avec FastAPI

FastAPI est un excellent choix pour les applications ou les projets sensibles aux performances qui nécessitent un peu plus de structure et de sécurité de type.

FastAPI est conçu pour être plus rapide par défaut (grâce à ses capacités asynchrones) et offre une validation de données robuste prête à l'emploi à l'aide de Pydantic.

J'ai trouvé FastAPI très intuitif et facile à utiliser, en particulier pour les projets où j'ai besoin de fonctionnalités asynchrones et où je souhaite une validation intégrée sans packages tiers.

De plus, la documentation automatique (via l'interface utilisateur Swagger) la rend extrêmement pratique.

Exemple de création d'une API FastAPI

Voici à quoi pourrait ressembler l'API de gestion des tâches dans FastAPI.

N'oubliez pas d'installer d'abord fastapi et uvicorn avec pip :

pip install flask

Ensuite vous pouvez créer l'API :

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Ce code Python crée une API de gestion des tâches à l'aide de FastAPI, en exploitant les modèles Pydantic pour la validation des données et l'application du type.

Il définit un modèle de tâche avec un identifiant, une tâche et un statut terminé, et initialise une liste de tâches.

L'API inclut des points de terminaison pour effectuer des opérations CRUD sur les tâches : le point de terminaison /tasks permet aux requêtes GET de récupérer la liste des tâches et aux requêtes POST d'ajouter une nouvelle tâche, validant automatiquement les données entrantes.

Le point de terminaison /tasks/{task_id} permet la récupération de tâches spécifiques avec GET, la mise à jour avec PUT et la suppression avec DELETE, renvoyant une erreur 404 si une tâche avec l'identifiant spécifié n'est pas trouvée.

Les capacités asynchrones et la documentation intégrée de FastAPI rendent cette API efficace et facile à tester, idéale pour un développement rapide.

5. Test des API

Les tests sont essentiels, en particulier lors de la création d'une API que d'autres applications consommeront.

Flask et FastAPI offrent une excellente prise en charge des tests unitaires, ce qui facilite la vérification du comportement de chaque point de terminaison.

Pour faciliter les tests, je vous recommande d'utiliser pytest pour la structure générale des tests, car il est compatible avec Flask et FastAPI.

Pour FastAPI en particulier, TestClient est un outil utile pour simuler les requêtes HTTP et vérifier les réponses.

Vous devrez installer httpx avec pip :

pip install flask

Voici un exemple pour tester un point de terminaison FastAPI :

from flask import Flask, jsonify, request

app = Flask(__name__)

tasks = [
    {"id": 1, "task": "Learn Flask", "done": False},
    {"id": 2, "task": "Build API", "done": False}
]

@app.route('/tasks', methods=['GET'])
def get_tasks():
    return jsonify({"tasks": tasks})

@app.route('/tasks', methods=['POST'])
def create_task():
    new_task = {
        "id": len(tasks) + 1,
        "task": request.json["task"],
        "done": False
    }
    tasks.append(new_task)
    return jsonify(new_task), 201

@app.route('/tasks/<int:task_id>', methods=['GET'])
def get_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        task.update(request.json)
        return jsonify(task)
    return jsonify({"message": "Task not found"}), 404

@app.route('/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    task = next((task for task in tasks if task["id"] == task_id), None)
    if task:
        tasks.remove(task)
        return jsonify({"message": "Task deleted"})
    return jsonify({"message": "Task not found"}), 404

if __name__ == '__main__':
    app.run(debug=True)

Avec les deux frameworks, les tests sont simples et vous permettent de vérifier que votre API se comporte comme prévu, notamment au fur et à mesure de son évolution.

6. Comparaison entre Flask et FastAPI

Voyons une comparaison entre Flask et FastAPI

Si vous travaillez sur un prototype rapide ou un projet plus petit, la simplicité de Flask pourrait être tout ce dont vous avez besoin.

Pour les projets qui nécessitent une simultanéité élevée, une validation des données ou une documentation automatique, FastAPI fournit un environnement plus puissant et riche en fonctionnalités.

7. Conclusion

Flask et FastAPI ont tous deux des atouts qui les rendent adaptés à différents types de projets.

Si vous débutez dans le développement Web Python, commencer par Flask peut vous aider à comprendre les bases avant de passer à quelque chose de plus avancé.

FastAPI, en revanche, est un choix idéal si vous recherchez un développement d'API moderne et hautes performances avec validation et documentation intégrées.

Quel que soit votre choix, Python offre un écosystème robuste pour le développement d'API.

Les deux frameworks vous permettront de créer des API capables d'alimenter diverses applications, des simples sites Web aux microservices complexes.

La clé est d'expérimenter, de comprendre les points forts de chaque framework et de choisir l'outil adapté à vos besoins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!