Was sind Pydantic-Modelle in FastAPI?

Question

Accepted Answer

**Pydantic-Modelle** sind Klassen (die von `BaseModel` erben), die die **Struktur, Typen und Validierungsregeln** für Daten definieren. FastAPI verwendet sie überall — für Request Bodies, Response Shapes und Einstellungen — und macht sie damit zum Herzstück seines typgesteuerten Designs.

## Definieren eines Modells

```python
from pydantic import BaseModel, EmailStr, Field

class User(BaseModel):
    name: str
    email: EmailStr                          # validates email format
    age: int = Field(ge=0, le=120)            # constraint: 0 <= age <= 120
    is_active: bool = True                    # default value
    tags: list[str] = []                      # typed list with a default
```

Jedes Feld deklariert einen Typ und optionale Constraints/Defaults. Pydantic validiert Daten anhand dieser Definition und konvertiert Typen, wo es sinnvoll ist.

## Automatische Validierung und Parsing

```python
@app.post("/users")
def create_user(user: User):                  # FastAPI builds & validates a User from the body
    return user                               # already validated here
# valid JSON → a typed User object; invalid → automatic 422 with field-level errors
```

Wenn es als Parametertyp verwendet wird, parsed FastAPI den JSON Request Body in das Modell, **validiert** jedes Feld und gibt einen strukturierten 422-Fehler zurück, der genau auflistet, was falsch ist — alles automatisch.

## Was Pydantic dir bietet

```text
✓ Validation — type checks + constraints (lengths, ranges, formats), clear errors
✓ Parsing/coercion — "5" → 5, ISO string → datetime, etc.
✓ Serialization — model.model_dump() / model_dump_json() → dict/JSON
✓ Editor support — full autocomplete & type checking on model attributes
✓ Self-documenting — the model defines the schema used in the auto-generated docs
```

## Eine einzige Quelle der Wahrheit

```text
One Pydantic model drives: request validation, the response schema, the OpenAPI docs,
and typed access in your code → define the data shape ONCE.
```

## Warum es wichtig ist

Pydantic-Modelle sind der Eckstein von FastAPI — sie sind, wie du die Daten definierst und validierst, die deine API akzeptiert und zurückgibt, und fast jede FastAPI-Funktion läuft durch sie hindurch.

Sie zu verstehen ist essentiell, weil sie automatische **Validierung** bieten (kritisch für Sicherheit und Robustheit — niemals ungefilterte Eingaben vertrauen), Parsing/Coercion, Serialisierung und Editor-Unterstützung, alles aus einer einzigen deklarativen Klasse.

Sie dienen als **einzige Quelle der Wahrheit**: ein Modell treibt Request-Validierung, Response Shape und auto-generierte Dokumentation an.

Dieser typgesteuerte, standardmäßig-validiert-Ansatz — robuste Input-Validierung und klare Fehlermeldungen im Grunde kostenlos zu erhalten — ist ein Hauptgrund, warum FastAPI so produktiv und sicher ist, was Pydantic-Modelle zu grundlegenden, unverzichtbar beherrschten Kenntnissen macht.