Python Academy · Leçon

Paramètres de chemin, paramètres de requête et corps des requêtes

Définissez des paramètres typés et des schémas de corps de requête avec Pydantic.

Paramètres de chemin, paramètres de requête et corps des requêtes est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Validation des paramètres de chemin

Ajoutez des validateurs aux paramètres de chemin avec Path() : définissez les contraintes ge, le, gt et lt.

from fastapi import FastAPI, Path
app = FastAPI()

@app.get("/items/{item_id}")
def get_item(item_id: int = Path(ge=1, le=1000)):
    return {"item_id": item_id}

# GET /items/0  → 422 (must be >= 1)

Validation des paramètres de requête

Utilisez Query() pour ajouter une validation, des valeurs par défaut, des alias et des descriptions aux paramètres de requête.

from fastapi import FastAPI, Query
app = FastAPI()

@app.get("/search")
def search(
    q: str = Query(min_length=2, max_length=50),
    page: int = Query(default=1, ge=1),
):
    return {"q": q, "page": page}

Paramètres de requête facultatifs

Utilisez | None = None (Python 3.10 ou version ultérieure) ou Optional[str] = None pour rendre un paramètre de requête facultatif.

from fastapi import FastAPI
app = FastAPI()

@app.get("/users")
def list_users(
    dept: str | None = None,
    active: bool = True
):
    return {"dept": dept, "active": active}

# GET /users → dept=None, active=True
# GET /users?dept=HR&active=false

Plusieurs valeurs pour un même paramètre de requête

Acceptez une liste de valeurs pour un seul paramètre de requête avec list[str] et Query().

from fastapi import FastAPI, Query
from typing import Annotated
app = FastAPI()

@app.get("/filter")
def filter_items(tags: Annotated[list[str], Query()] = []):
    return {"tags": tags}

# GET /filter?tags=python&tags=web

Corps de requête imbriqués

Les modèles Pydantic peuvent être imbriqués. FastAPI gère automatiquement les données JSON imbriquées.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class Address(BaseModel):
    street: str
    city: str

class User(BaseModel):
    name: str
    address: Address

@app.post("/users")
def create_user(user: User):
    return user.model_dump()

Contraintes de champ dans Pydantic

Utilisez Field() à l’intérieur d’un modèle pour ajouter des contraintes, des valeurs par défaut et des descriptions aux champs individuels.

from pydantic import BaseModel, Field

class Product(BaseModel):
    name: str = Field(min_length=1, max_length=100)
    price: float = Field(gt=0)
    quantity: int = Field(ge=0, default=0, description="Items in stock")

Corps de requête + chemin + requête réunis

Combinez les trois types de paramètres dans un même point de terminaison. FastAPI les distingue selon leur emplacement : le chemin se trouve dans l’URL, les types simples sont des paramètres de requête et les modèles constituent le corps.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class ItemUpdate(BaseModel):
    name: str
    price: float

@app.put("/shops/{shop_id}/items/{item_id}")
def update_item(
    shop_id: int,
    item_id: int,
    item: ItemUpdate,
    notify: bool = False,
):
    return {"shop": shop_id, "item": item_id,
            "data": item.model_dump(), "notify": notify}

Téléversements de fichiers

Utilisez UploadFile et File() pour accepter les téléversements de fichiers. Accédez au contenu avec await file.read().

from fastapi import FastAPI, UploadFile, File
app = FastAPI()

@app.post("/upload")
async def upload(file: UploadFile = File(...)):
    content = await file.read()
    return {"filename": file.filename, "size": len(content)}

Données de formulaire

Utilisez Form() pour accepter les données de formulaire HTML (application/x-www-form-urlencoded ou multipart/form-data).

# pip install python-multipart
from fastapi import FastAPI, Form
app = FastAPI()

@app.post("/login")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

Récapitulatif de la validation des requêtes

FastAPI valide automatiquement tous les types de paramètres. Les entrées non valides renvoient une erreur HTTP 422 accompagnée d’un message détaillé avant l’appel de votre gestionnaire.

# Auto-validated:
# - Path params: type coercion, Path() constraints
# - Query params: Query() constraints, type coercion
# - Request body: Pydantic model validation
# - All errors → HTTP 422 Unprocessable Entity
# - No manual validation needed

Alias et dépréciation

Utilisez alias= dans Query() ou Field() pour accepter un autre nom dans la requête, et deprecated=True pour marquer les anciens paramètres.

from fastapi import FastAPI, Query
app = FastAPI()

@app.get("/items")
def get_items(
    q: str | None = Query(default=None, alias="search-query"),
    old: str | None = Query(default=None, deprecated=True),
):
    return {"q": q, "old": old}

# GET /items?search-query=python

Vérification rapide

Comment FastAPI distingue-t-il un paramètre de chemin, un paramètre de requête et un corps de requête ?

Récapitulatif

Utilisez Path()/Query() pour définir des contraintes sur les paramètres. Imbriquez les modèles Pydantic pour les corps complexes. Combinez librement les paramètres de chemin, de requête et de corps. UploadFile gère les fichiers ; Form() gère les formulaires HTML. FastAPI valide tout avant l’exécution de votre gestionnaire.

Questions Fréquemment Posées

La leçon « Paramètres de chemin, paramètres de requête et corps des requêtes » est-elle gratuite ?

Oui — le texte complet de « Paramètres de chemin, paramètres de requête et corps des requêtes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Paramètres de chemin, paramètres de requête et corps des requêtes » ?

Définissez des paramètres typés et des schémas de corps de requête avec Pydantic. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Paramètres de chemin, paramètres de requête et corps des requêtes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration d’un projet FastAPI et premier endpoint
Paramètres de chemin, paramètres de requête et corps des requêtes
Injection de dépendances et authentification
Endpoints asynchrones et intégration à une base de données

← Retour à Python Academy