Première application FastAPI
Cette section utilise un exemple complet pour vous guider dans la création d'une application FastAPI à partir de zéro et comprendre ce que signifie chaque ligne de code.
Application minimale
Créez un fichier nommémain.py, ajoutez le code suivant :
Exemple
# Étape 1 : Importer la classe FastAPI
# Étape 2 : Créer l'instance de l'application
app = FastAPI()
# Étape 3 : Définir le décorateur d'opération de chemin
# Étape 4 : Définir la fonction d'opération de chemin
@app.get("/")
async def root():
# Étape 5 : Retourner le contenu de la réponse
return {"message": "Hello World"}
Démarrer l'application :
$ uvicorn main:app --reload
Visitezhttp://127.0.0.1:8000, renvoie :
{"message": "Hello World"}
Décomposition du code
1. Importer FastAPI
from fastapi import FastAPI
FastAPIC'est une classe Python qui fournit toutes les fonctionnalités principales de votre API. Elle hérite directement de Starlette, vous pouvez donc aussi utiliser toutes les fonctionnalités de Starlette.
2. Créer l'instance de l'application
app = FastAPI()
créer une instance FastAPI, généralement avec le nom de variableapp. Cette instance est l'objet d'interaction principal pour créer toutes les API. Contrairement à Flask, FastAPI n'a pas besoin de passer__name__paramètres.
3. Définir le décorateur d'opération de chemin
@app.get("/")
Cette ligne de code indique à FastAPI : lorsqu'un utilisateur accède via la méthodeGETau chemin racine/, la fonction ci-dessous est exécutée.
Cela implique deux concepts :
| Concepts | Description | Exemple |
|---|---|---|
| Chemin | à partir du premier ... dans l'URL/la partie finale du chemin, également appelée « endpoint » ou « route » | /items/foo |
| Opération | Les méthodes HTTP correspondent à différentes sémantiques opérationnelles | GET、POST、PUT、DELETE |
FastAPI prend en charge les décorateurs pour toutes les méthodes HTTP :
| décorateur | Méthodes HTTP | Utilisations courantes |
|---|---|---|
@app.get() | GET | Obtenir/lire des données |
@app.post() | POST | Créer de nouvelles données |
@app.put() | PUT | Mettre à jour complètement les données |
@app.patch() | PATCH | Mettre à jour partiellement les données |
@app.delete() | DELETE | Supprimer des données |
4. Définir la fonction d'opération de chemin
async def root():
Ceci est la fonction d'opération de chemin ; chaque fois que FastAPI reçoitGET /une requête, il l'appellera. Vous pouvez nommer la fonction comme vous le souhaitez, mais il est recommandé de choisir un nom significatif.
Vous pouvez utiliserasync defou ordinairedefpour définir la fonction. FastAPI gère automatiquement la différence entre les deux. Si vous n'êtes pas familier avec la programmation async, utilisez une fonction classiquedefet c'est très bien ; les chapitres suivants traiteront async en détail.
5. Retourner le contenu de la réponse
return {"message": "Hello World"}
La fonction renvoie un dictionnaire, et FastAPI le convertit automatiquement en réponse JSON. Vous pouvez renvoyerdict、list、str、intde tels types, et FastAPI gérera automatiquement la conversion JSON.
Ajouter d'autres routes
Ensuite, ajoutons des paramètres de chemin et des paramètres de requête pour enrichir les fonctionnalités de l'application :
Exemple
app = FastAPI()
@app.get("/")
async def root():
"""Chemin racine, renvoie un message de bienvenue"""
return {"message": "Hello World"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
"""Récupérer un élément par ID, avec le paramètre de requête optionnel q"""
return {"item_id": item_id, "q": q}
Description des paramètres pour la route nouvellement ajoutée :
| Paramètre | Type | Source | Description |
|---|---|---|---|
item_id | int | Paramètre de chemin | obtenu à partir du chemin d'URL ; FastAPI convertit automatiquement la chaîne en entier |
q | str | None | Paramètre de requête | À partir de l'URL?q=xxxrécupéré depuis une partie, avec une valeur par défaut deNone, ce qui signifie facultatif |
Test d'accès :
# 访问根路径
GET http://127.0.0.1:8000/
响应: {"message": "Hello World"}
# 访问带路径参数的路由
GET http://127.0.0.1:8000/items/5
响应: {"item_id": 5, "q": null}
# 同时传递路径参数和查询参数
GET http://127.0.0.1:8000/items/5?q=example
响应: {"item_id": 5, "q": "example"}
Remarqueitem_idLa valeur est un entier5Au lieu d'une chaîne de caractères"5"il s'agit de la fonctionnalité de conversion de données de FastAPI basée sur les déclarations de type. Si une valeur non entière est passée (par ex.,/items/foo), FastAPI renvoie un message d'erreur de validation clair.
Ajouter une requête POST
Ci-dessous, nous ajoutons une route POST qui utilise un corps de requête :
Exemple
from pydantic import BaseModel
app = FastAPI()
# Définir le modèle de données du corps de la requête
class Item(BaseModel):
name: str # Requis : Nom du produit
description: str | None = None # Facultatif : description du produit
price: float # Obligatoire : prix du produit
tax: float | None = None # Facultatif : taxe
@app.post("/items/")
async def create_item(item: Item):
"""Créer un nouveau produit, accepte un corps de requête JSON."""
return item
@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
"""Mettre à jour le produit spécifié, en utilisant à la fois les paramètres de chemin et le corps de requête"""
return {"item_id": item_id, "item_name": item.name}
Ici, nous utilisons PydanticBaseModelpour définir la structure du corps de la requête. FastAPI va automatiquement :
- analyser les données JSON de la requête pour les convertir en
ItemObject - Valider les types de données et les champs requis
- afficher la structure du corps de la requête dans la documentation de l’API
Pydantic est une dépendance principale de FastAPI, utilisée pour la validation et la sérialisation des données. Les chapitres suivants couvriront son utilisation en détail.
Règles de reconnaissance des paramètres de FastAPI
FastAPI identifie automatiquement la source des paramètres à l’aide des règles suivantes :
| Source du paramètre | Condition de reconnaissance | Exemple |
|---|---|---|
| Paramètre de chemin | Le nom du paramètre apparaît dans le chemin de la route{}Moyenne | item_idDans/items/{item_id}Moyenne |
| Paramètre de requête | Le paramètre est d'un type simple (int、str、booletc.) | q: str | None = None |
| corps de requête | le type du paramètre est un modèle Pydantic | item: Item |
Vous pouvez mélanger ces trois types de paramètres dans la même fonction, et FastAPI récupérera automatiquement les données au bon endroit.
Résumé
Étapes clés pour créer une application FastAPI :
- Importer
FastAPI - Créer l’instance d’application
app = FastAPI() - Utilisation de décorateurs (tels que
@app.get()) pour définir des opérations de chemin - Définir des fonctions d’opération de chemin et déclarer des paramètres à l’aide d’annotations de type.
- Utilisation
uvicorn main:app --reloadLancer le serveur de développement