Wie schreibst du benutzerdefinierte Validierung in Pydantic?

Question

Accepted Answer

Über die integrierten Constraints hinaus ermöglicht Pydantic dir, **benutzerdefinierte Validierungslogik** mit Field-Validatoren (ein Feld validieren) und Model-Validatoren (über mehrere Felder hinweg validieren) zu schreiben — für Regeln, die einfache Constraints nicht ausdrücken können. (Gezeigte Syntax ist Pydantic v2.)

## Field-Validatoren — ein einzelnes Feld validieren/transformieren

```python
from pydantic import BaseModel, field_validator

class User(BaseModel):
    username: str
    password: str

@field_validator("username")
    @classmethod
    def username_alphanumeric(cls, v: str) -> str:
        if not v.isalnum():
            raise ValueError("username must be alphanumeric")   # → a 422 error
        return v.lower()                                         # can also TRANSFORM the value
```

Ein `@field_validator` führt benutzerdefinierte Logik auf einem Feld aus: Wirf `ValueError` auf, um ungültige Eingaben abzulehnen (FastAPI konvertiert das in eine klare 422), oder gib einen transformierten Wert zurück (z. B. Normalisierung zu Kleinbuchstaben).

## Model-Validatoren — feldübergreifende Validierung

```python
from pydantic import model_validator

class SignupForm(BaseModel):
    password: str
    confirm_password: str

@model_validator(mode="after")
    def passwords_match(self):
        if self.password != self.confirm_password:    # compare MULTIPLE fields
            raise ValueError("passwords do not match")
        return self
```

Ein `@model_validator(mode="after")` läuft nach der Validierung aller Felder ab und hat Zugriff auf das gesamte Modell — wird für Regeln mit **mehreren Feldern** verwendet (z. B. Bestätigung, dass Passwörter übereinstimmen, oder dass ein Startdatum vor einem Enddatum liegt).

## Integrierte Validierung reicht oft zunächst aus

```python
class Product(BaseModel):
    price: float = Field(gt=0)          # use Field constraints for simple rules
    sku: str = Field(pattern=r"^[A-Z]{3}-\d+$")
    email: EmailStr                      # specialized types for formats
# reach for custom validators only when constraints/types can't express the rule
```

Bevorzuge `Field`-Constraints und spezialisierte Typen für einfache Regeln; nutze benutzerdefinierte Validatoren für echte Geschäftslogik.

## Warum es wichtig ist

Benutzerdefinierte Pydantic-Validierung ist wichtig, um Geschäftsregeln durchzusetzen, die über einfache Typprüfungen und Constraints hinausgehen — und da Validierung für **Sicherheit und Datenintegrität** kritisch ist, ist die Möglichkeit, jede beliebige Regel auszudrücken, wertvoll. **Field-Validatoren** behandeln Single-Field-Logik (benutzerdefinierte Formatprüfungen, Normalisierung/Transformation), während **Model-Validatoren** das häufige Bedürfnis nach **feldübergreifender Validierung** erfüllen (Passwörter stimmen überein, Datumsbereiche, bedingte Anforderungen), die Field-Level-Regeln nicht ausdrücken können.

Die Validatoren integrieren sich nahtlos mit FastAPI — ein geworfener `ValueError` wird automatisch zu einer klaren 422-Antwort.

Zu verstehen, wann integrierte Constraints/Typen (für einfache Regeln) versus benutzerdefinierte Validatoren (für echte Geschäftslogik) verwendet werden, und wie sich Field- und Model-Validatoren unterscheiden, ermöglicht es dir, sicherzustellen, dass eingehende Daten alle Anforderungen deiner Anwendung vollständig erfüllen, was dies zu wichtigem Wissen für die Erstellung robuster und korrekter APIs macht.