Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Pydantic BaseModel en dybden

Lektion 6 af 12 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Pydantic: Den ideelle partner
  2. Pydantic-grundlag til strukturerede output
  3. Understøttede Python-typer
  4. Næstede modeller
  5. Enums med Pydantic
  6. Brug af parse()
  7. Brug af response_format
  8. Standardværdier og dokumentation
  9. Vigtige pointer

Pydantic: Den ideelle partner

Pydantic er standardbiblioteket i Python til validering af data. Sammen med Groks strukturerede output bliver det et uundværligt værktøj: Du definerer dine skemaer som Python-klasser, og modellen udfylder disse klasser automatisk.

Pydantic-grundlag til strukturerede output

Du opretter en Pydantic-model ved at arve fra BaseModel. Hver attribut med en typeannotation bliver til et felt i JSON-skemaet:

from pydantic import BaseModel

class Produit(BaseModel):
    nom: str
    prix: float
    en_stock: bool
    categorie: str

Denne model genererer automatisk det tilsvarende JSON-skema. Du behøver ikke skrive noget andet.

Understøttede Python-typer

Her er mappingen mellem Python-typer og JSON Schema-typer:

class ExempleComplet(BaseModel):
    # Skalarer
    texte: str                    # → "type": "string"
    nombre: float                 # → "type": "number"
    entier: int                   # → "type": "number"
    actif: bool                   # → "type": "boolean"

    # Valgfrie felter
    note: str | None              # → anyOf string/null

    # Samlinger
    tags: list[str]               # → array of strings
    scores: list[float]           # → array of numbers

    # Enumerationer
    niveau: str                   # + enum in Field

Næstede modeller

Den virkelige styrke ved Pydantic ligger i at næste modeller:

class Adresse(BaseModel):
    rue: str
    ville: str
    code_postal: str
    pays: str

class Competence(BaseModel):
    nom: str
    niveau: str  # "debutant", "intermediaire", "expert"
    annees: int

class Candidat(BaseModel):
    prenom: str
    nom: str
    email: str
    adresse: Adresse
    competences: list[Competence]
    disponible: bool
    pretention_salariale: float | None

Når du sender Candidat som response_format, vil modellen udfylde hele hierarkiet: den komplette adresse, hver kompetance med sine detaljer og så videre.

Enums med Pydantic

Brug Pythons Literal til at gennemtvinge foruddefinerede værdier:

from typing import Literal

class Ticket(BaseModel):
    titre: str
    description: str
    priorite: Literal["basse", "moyenne", "haute", "critique"]
    statut: Literal["ouvert", "en_cours", "resolu", "ferme"]
    type: Literal["bug", "feature", "documentation"]

Modellen kan kun returnere de listede værdier. Enhver anden værdi er umulig.

Brug af parse()

response, ticket = client.chat.parse(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "The login button does not work on mobile"
    }],
    response_format=Ticket
)

print(ticket.priorite)  # "haute"
print(ticket.type)       # "bug"
print(ticket.statut)     # "ouvert"

Brug af response_format

response = client.chat.create(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "The login button does not work on mobile"
    }],
    response_format=Ticket
)

ticket = Ticket.model_validate_json(
    response.choices[0].message.content
)

Standardværdier og dokumentation

Du kan tilføje beskrivelser til dine felter med Field. Disse beskrivelser hjælper modellen med bedre at forstå, hvad du forventer:

from pydantic import BaseModel, Field

class AnalyseSentiment(BaseModel):
    texte_original: str = Field(
        description="The text analyzed as is"
    )
    sentiment: Literal["positif", "negatif", "neutre"] = Field(
        description="The dominant sentiment of the text"
    )
    score_confiance: float = Field(
        description="Confidence score between 0.0 and 1.0"
    )
    mots_cles: list[str] = Field(
        description="The 3 to 5 most significant keywords"
    )

Beskrivelserne i Field inkluderes i det JSON-skema, der sendes til modellen. De forbedrer kvaliteten af svarene.

Vigtige pointer

  • Pydantic konverterer automatisk dine Python-klasser til JSON-skemaer
  • Næstede modeller giver dig mulighed for at strukturere komplekse data
  • Literal erstatter enum for at gennemtvinge foruddefinerede værdier
  • str | None gør et felt valgfrit (kan være null)
  • Field(description=...) forbedrer kvaliteten af modellens svar
  • Fungerer med parse() (automatisk) og response_format (manuel)