Vad är Pydantic-modeller i FastAPI?

Question

Accepted Answer

**Pydantic-modeller** är klasser (som ärver från `BaseModel`) som definierar **strukturen, typerna och valideringsreglerna** för data. FastAPI använder dem överallt — för begärandenramar, svarsformat och inställningar — vilket gör dem till hjärtat i dess typdriven design.

## Definiera en modell

```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
```

Varje fält deklarerar en typ och valfria begränsningar/standardvärden. Pydantic validerar data mot denna definition och konverterar typer där det är lämpligt.

## Automatisk validering och analys

```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
```

När den används som en parametertyp, analyserar FastAPI JSON-begärandetexten till modellen, **validerar** varje fält och returnerar ett strukturerat 422-fel som listar exakt vad som är fel — allt automatiskt.

## Vad Pydantic ger dig

```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
```

## En enda källa till sanning

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

## Varför det är viktigt

Pydantic-modeller är hörnstenen i FastAPI — de är hur du definierar och validerar de data som ditt API accepterar och returnerar, och nästan alla FastAPI-funktioner flödar genom dem.

Att förstå dem är viktigt eftersom de ger automatisk **validering** (kritisk för säkerhet och robusthet — aldrig lita på rå inmatning), analys/koercion, serialisering och redigerare support, allt från en enda deklarativ klass.

De fungerar som en **enda källa till sanning**: en modell styr begärande validering, svarsformen och den auto-genererade dokumentationen.

Denna typdriven, validera-som-standard-metod — få robust indatavalidering och tydliga felmeddelanden i princip gratis — är en stor anledning till varför FastAPI är så produktiv och säker, vilket gör Pydantic-modeller till grundläggande, måste-behärskning kunskap.