Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pydantic BaseModel en détail

Nodarbība 6 no 12 Atjaunota 2026. gada 30. jūlijs Programmētājs
Šajā lapā
  1. Pydantic : le partenaire idéal
  2. Les bases de Pydantic pour les sorties structurées
  3. Types Python pris en charge
  4. Modèles imbriqués
  5. Énumérations avec Pydantic
  6. Utilisation de parse()
  7. Utilisation de response_format
  8. Valeurs par défaut et documentation
  9. Galvenās atziņas

Pydantic : le partenaire idéal

Pydantic est la bibliothèque Python standard pour la validation des données. Avec les sorties structurées de Grok, elle devient un outil essentiel : tu définis tes schémas sous forme de classes Python, et le modèle remplit automatiquement ces classes.

Les bases de Pydantic pour les sorties structurées

Tu crées un modèle Pydantic en héritant de BaseModel. Chaque attribut doté d’une annotation de type devient un champ dans le schéma JSON :

from pydantic import BaseModel

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

Ce modèle génère automatiquement le schéma JSON équivalent. Tu n’as rien d’autre à écrire.

Types Python pris en charge

Voici la correspondance entre les types Python et les types de schéma JSON :

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

    # Optionnels
    note: str | None              # → anyOf string/null

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

    # Énumérations
    niveau: str                   # + enum in Field

Modèles imbriqués

La véritable puissance de Pydantic réside dans l’imbrication des modèles :

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

Lorsque tu passes Candidat comme response_format, le modèle remplit toute la hiérarchie : l’adresse complète, chaque compétence avec ses détails, et ainsi de suite.

Énumérations avec Pydantic

Pour imposer des valeurs prédéfinies, utilise Literal de Python :

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"]

Le modèle ne peut retourner que les valeurs listées. Toute autre valeur est impossible.

Utilisation de 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"

Utilisation de 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
)

Valeurs par défaut et documentation

Tu peux ajouter des descriptions à tes champs avec Field. Ces descriptions aident le modèle à mieux comprendre ce que tu attends :

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"
    )

Les descriptions dans Field sont incluses dans le schéma JSON envoyé au modèle. Elles améliorent la qualité des réponses.

Galvenās atziņas

  • Pydantic convertit automatiquement tes classes Python en schémas JSON
  • L’imbrication de modèles permet de structurer des données complexes
  • Literal remplace enum pour imposer des valeurs prédéfinies
  • str | None rend un champ optionnel (peut être null)
  • Field(description=...) améliore la qualité des réponses du modèle
  • Fonctionne avec parse() (automatique) et response_format (manuel)