Pydantic-modellen voor request bodies
Gebruik Pydantic om dataschema's te definiëren voor binnenkomende POST-, PUT- en DELETE-requests en zorg voor robuuste gegevensvalidatie.
Pydantic-modellen voor request bodies is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Aanvraagbodems van API's
Wanneer je gegevens naar een API stuurt, bijvoorbeeld om een nieuwe gebruiker of een nieuw item te maken, worden die gegevens vaak in de aanvraagbody verstuurd.
Een aanvraag om een nieuw product te maken kan bijvoorbeeld de naam, prijs en beschrijving bevatten. Het is cruciaal voor de stabiliteit en beveiliging van je applicatie dat deze binnenkomende gegevens correct en geldig zijn.
Waarom aanvraaggegevens valideren?
Het valideren van binnenkomende gegevens is om verschillende redenen essentieel:
- Gegevensintegriteit: zorgt ervoor dat je database alleen correct opgemaakte en betekenisvolle informatie ontvangt.
- Beveiliging: voorkomt dat kwaadwillende of verkeerd opgemaakte gegevens fouten of kwetsbaarheden veroorzaken.
- Gebruikerservaring: geeft gebruikers duidelijke foutmeldingen wanneer hun invoer onjuist is.
- Betrouwbaarheid van de code: vermindert bugs doordat je garandeert dat je applicatielogica met verwachte gegevenstypen werkt.
Maak kennis met Pydantic
Pydantic is een Python-bibliotheek die gegevensvalidatie en instellingenbeheer biedt met behulp van Python-typehints. De bibliotheek is bijzonder snel en integreert naadloos met FastAPI.
FastAPI gebruikt Pydantic op de achtergrond om:
- aanvraagbodems om te zetten in Python-objecten.
- gegevenstypen en beperkingen te valideren.
- duidelijke foutmeldingen te genereren wanneer de validatie mislukt.
Je eerste Pydantic-model maken
Om een gegevensstructuur voor je aanvraagbody te definiëren, maak je een klasse die erft van Pydantic's BaseModel. Vervolgens declareer je velden met standaard Python-typehints.
Dit model werkt als een schema dat vastlegt welke gegevens je API verwacht.
Pydantic-model in actie
Laten we een eenvoudig Item-model definiëren. Let erop hoe we name als tekenreeks en price als kommagetal definiëren. We laten ook zien hoe validatie wordt verwerkt.
from pydantic import BaseModel, ValidationError
class Item(BaseModel):
name: str
price: float
description: str | None = None # Optional field
def main():
print("--- Valid Item ---")
try:
item1 = Item(name="Laptop", price=1200.50)
print(item1.model_dump_json(indent=2))
except ValidationError as e:
print(e.json())
print("\n--- Invalid Item (missing price) ---")
try:
item2 = Item(name="Keyboard")
print(item2.model_dump_json(indent=2))
except ValidationError as e:
print(e.json())
if __name__ == "__main__":
main()FastAPI en Pydantic werken samen
FastAPI herkent Pydantic-BaseModel-objecten automatisch in de parameters van je eindpuntfunctie. Wanneer er een aanvraag binnenkomt, doet FastAPI het volgende:
- leest de JSON-aanvraagbody.
- gebruikt je Pydantic-model om de gegevens te parseren en te valideren.
- geeft de gevalideerde gegevens als een instantie van je model door aan je functie.
Het lijkt wel magie!
Een POST-eindpunt bouwen
Zo definieer je in FastAPI een POST-eindpunt dat een Item in de aanvraagbody verwacht. FastAPI regelt het parseren en valideren voor je.
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
price: float
description: str | None = None
tax: float | None = None
@app.post("/items/")
async def create_item(item: Item):
# The 'item' variable is now an Item object,
# already validated by Pydantic!
return {"message": "Item received successfully!", "item": item.model_dump()}
# To run this application:
# 1. Save the code as main.py
# 2. Run in terminal: uvicorn main:app --reload
# 3. Send a POST request to http://127.0.0.1:8000/items/
# with a JSON body like: {"name": "Book", "price": 29.99}Automatische validatie en fouten
Als een client gegevens verstuurt die niet overeenkomen met je Pydantic-model, bijvoorbeeld omdat een verplicht veld ontbreekt of het gegevenstype onjuist is, retourneert FastAPI automatisch een gedetailleerd foutantwoord: 422 Unprocessable Entity.
Deze foutmelding wordt automatisch gegenereerd en is erg nuttig bij het opsporen van problemen aan zowel de clientkant als in de API.
Optionele velden en standaardwaarden
Niet elk veld in je aanvraagbody hoeft verplicht te zijn. Je kunt velden optioneel maken of standaardwaarden opgeven:
- Gebruik
field: str | None = Nonevoor optionele velden metNoneals standaardwaarde. - Gebruik
field: int = 0om een specifieke standaardwaarde in te stellen wanneer het veld niet wordt opgegeven.
Dankzij deze flexibiliteit kun je robuuste en gebruiksvriendelijke API-schema's ontwerpen.
Controle over Pydantic-modellen
Welke van de volgende uitspraken over Pydantic-modellen in FastAPI zijn WAAR?
Samenvatting: de kracht van Pydantic
Je hebt geleerd hoe fundamenteel Pydantic-modellen zijn voor het verwerken van aanvraagbodems in FastAPI. Ze bieden robuuste gegevensvalidatie, automatisch parseren en duidelijke foutmeldingen, waardoor API-ontwikkeling veel soepeler en betrouwbaarder wordt.
Vervolgens bekijken we hoe je expliciete antwoordmodellen definieert en HTTP-statuscodes verwerkt voor verschillende API-bewerkingen.
Leer Bootcamp backendontwikkeling met FastAPI 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
- 21
- Lessen
- 84
Veelgestelde vragen
Is de les “Pydantic-modellen voor request bodies” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “Pydantic-modellen voor request bodies”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.
Wat leer ik in “Pydantic-modellen voor request bodies”?
Gebruik Pydantic om dataschema's te definiëren voor binnenkomende POST-, PUT- en DELETE-requests en zorg voor robuuste gegevensvalidatie. Je oefent met Bootcamp backendontwikkeling met FastAPI 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 Bootcamp backendontwikkeling met FastAPI te beginnen?
Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI 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 1 van 4.
Hoe lang duurt de les “Pydantic-modellen voor request bodies”?
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 Bootcamp backendontwikkeling met FastAPI?
Ja. Elke les over Bootcamp backendontwikkeling met FastAPI 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
- Pydantic-modellen voor request bodies
- Responsemodellen en statuscodes
- Formuliergegevens en bestandsuploads
- Headers, cookies en aangepaste responses