Créez des API en inutes avec Python

"Créez des API en 5 minutes avec FastAPI. Framework Python moderne et performant, FastAPI facilite la création d'applications Web puissantes."

Installation
Installez FastAPI et uvicorn (serveur ASGI) en utilisant pip :

pip installer fastapi uvicorn
pip installer fastapi

Créons notre API

Ouvrez le bloc-notes et collez le contenu ci-dessous, enregistrez le fichier sous data.json (nous ajouterons des données à ce fichier en utilisant la méthode POST et récupérerons les enregistrements en utilisant la méthode GET

data.json

[
   {
      "name": "John",
      "age": 25
   },
   {  "name": "Smith",
      "age": 27
   }
]

Créez maintenant un nouveau fichier python, nommez-le app.py et collez le code ci-dessous

# This section imports necessary modules and classes from the FastAPI library and Python's standard library. It imports FastAPI for creating the web application, HTTPException for raising HTTP exceptions, List for type hints, and json for working with JSON data.

from fastapi import FastAPI, HTTPException
from typing import List
import json

# This creates an instance of the FastAPI class, which will be the main application instance for handling HTTP requests.
app = FastAPI()

# This block reads the content of the "data.json" file using a context manager (with statement) and loads the JSON data into the initial_data variable.
with open("data.json", "r") as file:
    initial_data = json.load(file)

# This line initializes the data variable with the loaded JSON data, effectively creating a list of dictionaries containing user information.
data = initial_data

# This decorator (@app.get(...)) defines a GET endpoint at the "/users" URL. It uses the get_users function to handle the request. The response_model parameter specifies the expected response model, which is a list of dictionaries in this case.
@app.get("/users", response_model=List[dict])
async def get_users():
    return data

# This decorator (@app.post(...)) defines a POST endpoint at the "/users" URL. It uses the create_user function to handle the request. The response_model parameter specifies the expected response model, which is a single dictionary in this case.
# The create_user function attempts to append the received user dictionary to the data list. If successful, it constructs a response dictionary indicating the success. If an exception occurs during the attempt (e.g., due to invalid data), it constructs a response dictionary indicating an error.
@app.post("/users", response_model=dict)
async def create_user(user: dict):
    try:
        data.append(user)
        response_data = {"message": "User created successfully", "user": user}
    except:
        response_data = {"message": "Error creating user", "user": user}
    return response_data

# This function uses a context manager to open the "data.json" file in write mode and then uses json.dump to write the contents of the data list back to the file, formatting it with an indentation of 4 spaces.
def save_data():
    with open("data.json", "w") as file:
        json.dump(data, file, indent=4)

# This decorator (@app.on_event(...)) defines a function that will be executed when the FastAPI application is shutting down. In this case, it calls the save_data function to save the data back to the JSON file before the application exits.
@app.on_event("shutdown")
async def shutdown_event():
    save_data()

# This block checks if the script is being run directly (not imported as a module). If it is, it uses the uvicorn.run function to start the FastAPI application on host "0.0.0.0" and port 8000. This is how you launch the application using the Uvicorn ASGI server.
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Exécutez app.py, le serveur Uvicorn démarrera un nouveau processus pour gérer les requêtes HTTP entrantes. une fois le serveur opérationnel, ouvrez Postman, créez une nouvelle requête GET avec l'URL : http://0.0.0.0:8000/users et cliquez sur envoyer

Vous verrez une réponse JSON avec la liste des utilisateurs du fichier data.json.

Ajoutons maintenant un utilisateur à ce fichier avec la méthode POST. Créez une nouvelle requête, sélectionnez la méthode POST, cliquez sur le corps, sélectionnez brut, sélectionnez JSON dans la liste déroulante et collez le JSON ci-dessous en tant que charge utile pour ajouter un nouvel utilisateur

{
    "name": "Tina",
    "age": 22
}

Une fois que vous aurez cliqué sur envoyer, vous recevrez une réponse si l'utilisateur est ajouté avec succès avec un code d'état de 200 OK

Et voilà, nous avons créé avec succès une API avec la méthode GET/POST pour afficher et ajouter des utilisateurs à un fichier. revenez à la requête GET et cliquez sur envoyer, vous devriez maintenant voir l'utilisateur Tina également répertorié dans la réponse de l'API.

Une chose étonnante à propos de FastAPI est qu'il génère automatiquement la documentation Swagger pour les points de terminaison de votre API, ce qui permet aux développeurs de comprendre et d'utiliser plus facilement votre API de manière efficace.

Si vous ouvrez un navigateur et tapez http://localhost:8000/docs, vous verrez un document swagger pour l'API

Veuillez noter qu'il ne s'agit que d'un exemple de base de création d'une API rapide avec Python, vous devrez en outre faire plus de configuration ou de codage, notamment en termes de gestion des erreurs, de validation des données et de sécurité.

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!