PricingLoginStart free
Python Academy · Les

Pathparameters, queryparameters en requestbodies

Definieer getypeerde parameters en schema's voor requestbodies met Pydantic.

Les 2 van 413 stappen

Pathparameters, queryparameters en requestbodies is een gratis Python Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

Validatie van padparameters

Voeg validatie toe aan padparameters met Path(): stel beperkingen in met ge, le, gt en 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)

Validatie van queryparameters

Gebruik Query() om validatie, standaardwaarden, aliassen en beschrijvingen aan queryparameters toe te voegen.

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}

Optionele queryparameters

Gebruik | None = None (Python 3.10+) of Optional[str] = None om een queryparameter optioneel te maken.

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

Meerdere waarden voor één queryparameter

Accepteer een lijst met waarden voor één queryparameter met list[str] en 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

Geneste aanvraagbody's

Pydantic-modellen kunnen genest zijn. FastAPI verwerkt geneste JSON automatisch.

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()

Veldbeperkingen in Pydantic

Gebruik Field() binnen een model om beperkingen, standaardwaarden en beschrijvingen aan afzonderlijke velden toe te voegen.

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")

Aanvraagbody + pad + query samen

Combineer alle drie de parametertypen in één eindpunt. FastAPI onderscheidt ze op basis van hun positie: het pad staat in de URL, eenvoudige typen zijn queryparameters en modellen vormen de aanvraagbody.

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}

Bestandsuploads

Gebruik UploadFile en File() om bestandsuploads te accepteren. Open de inhoud met 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)}

Formuliergegevens

Gebruik Form() om HTML-formuliergegevens te accepteren (application/x-www-form-urlencoded of 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}

Samenvatting van aanvraagvalidatie

FastAPI valideert alle parametertypen automatisch. Ongeldige invoer geeft HTTP 422 met een gedetailleerde foutmelding voordat je routefunctie wordt aangeroepen.

# 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 en uitfasering

Gebruik alias= in Query() of Field() om in de aanvraag een andere naam te accepteren, en deprecated=True om oude parameters te markeren.

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

Korte controle

Hoe maakt FastAPI onderscheid tussen een padparameter, een queryparameter en een aanvraagbody?

Beantwoord dit in de interactieve les

Samenvatting

Gebruik Path()/Query() voor parameterbeperkingen. Nest Pydantic-modellen voor complexe aanvraagbody's. Combineer pad-, query- en aanvraagbodyparameters naar wens. UploadFile verwerkt bestanden; Form() verwerkt HTML-formulieren. FastAPI valideert alles voordat je routefunctie wordt uitgevoerd.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
76
Lessen
320
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Pathparameters, queryparameters en requestbodies” gratis?

Ja — de volledige tekst van “Pathparameters, queryparameters en requestbodies” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “Pathparameters, queryparameters en requestbodies”?

Definieer getypeerde parameters en schema's voor requestbodies met Pydantic. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Pathparameters, queryparameters en requestbodies”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. FastAPI-project opzetten en eerste endpoint
  2. Pathparameters, queryparameters en requestbodies
  3. Dependency injection en authenticatie
  4. Async-endpoints en database-integratie
← Terug naar Python Academy