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

Manuālais response_format

Nodarbība 5 no 12 Atjaunota 2026. gada 30. jūlijs Programmētājs
Šajā lapā
  1. Lielāka kontrole ar response_format
  2. Darbplūsma
  3. Pilns piemērs
  4. Atšķirības no parse()
  5. Parsēšana bez Pydantic
  6. Kad izvēlēties response_format
  7. Kļūdu apstrāde
  8. Galvenās atziņas

Lielāka kontrole ar response_format

Manuālā metode, izmantojot response_format, dod tev pilnīgu kontroli pār parsēšanu. Atšķirībā no parse(), kas atgriež tipizētu objektu, šī pieeja atgriež JSON virkni, ko tu parsē pats — Pydantic modelis tikai nodrošina shēmu (model_json_schema()) un veic validāciju pēc tam. Izvēlies šo metodi, kad tev nepieciešama elastība vai strādājot vidē bez Pydantic.

Darbplūsma

Izmantojot response_format, process norisinās divos soļos:

  1. API atgriež JSON kā virkni laukā response.choices[0].message.content
  2. Tu parsē šo virkni, izmantojot savu izvēlēto metodi

Pilns piemērs

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI(
    api_key="your-xai-key",
    base_url="https://api.x.ai/v1"
)

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str
    recommend: bool

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "Review the movie Inception"
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "movie_review",
            "schema": MovieReview.model_json_schema()
        }
    }
)

# Saturs ir JSON virkne
json_string = response.choices[0].message.content
print(type(json_string))  # <class 'str'>
print(json_string)
# {"title": "Inception", "rating": 9.2, "summary": "...", "recommend": true}

# Manuāla parsēšana ar Pydantic
parsed = MovieReview.model_validate_json(json_string)
print(parsed.title)  # "Inception"

Atšķirības no parse()

Aspektsparse()response_format
Atgriežamā vērtība(Response, ParsedModel)Tikai Response
ParsēšanaAutomātiskaManuāla
Datu piekļuveparsed.fieldjson.loads() vai model_validate_json()
ElastībaStandartaMaksimāla
Kļūdu apstrādeIebūvētaTava atbildība

Parsēšana bez Pydantic

Tev nav jāizmanto Pydantic, lai parsētu rezultātu. Der arī standarta json modulis:

import json

response = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[{
        "role": "user",
        "content": "Analyze this text and extract entities"
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "entities",
            "schema": {
                "type": "object",
                "properties": {
                    "people": {
                        "type": "array",
                        "items": { "type": "string" }
                    },
                    "places": {
                        "type": "array",
                        "items": { "type": "string" }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data["people"])  # ["Marie Curie", "Pierre Curie"]
print(data["places"])      # ["Paris", "Warsaw"]

Kad izvēlēties response_format

response_format ir neaizstājams, kad tev jāredz vai jāpārbauda JSON, pirms tas kļūst par objektu. Visbiežākais gadījums ir žurnālu veidošana (logging): ražošanas vidē izejdatņu JSON saglabāšana pirms transformācijas bieži ir revīzijas vai atkļūdošanas prasība, un parse() šo iejaukšanās punktu nenodrošina. Nākamais ir jautājums par shēmu: ja tava saskarnes līgums ir neapstrādāta JSON shēma — koplietota ar citām komandām, ģenerēta ar rīku vai versijota neatkarīgi no Python koda — tās tieša piemērošana ir precīzāka nekā tās atjaunošana kā Pydantic modelis. Visbeidzot, ne katrs projekts darbojas Pydantic ekosistēmā: ja tava validācija notiek caur citu ietvaru vai caur starpposma apstrādes soli, kas specifisks tavai cauruļvada arhitektūrai, response_format nodod tev JSON tādu, kāds tas ir, un ļauj tev pašam lemt, kas notiks tālāk.

Kļūdu apstrāde

Izmantojot manuālo metodi, tev pašam jāapstrādā parsēšanas kļūdas:

import json

try:
    data = json.loads(response.choices[0].message.content)
except json.JSONDecodeError as e:
    print(f"Parsing error: {e}")

Praksē šī kļūda nekad nevajadzētu rasties, jo API garantē derīgu JSON. Tomēr aizsardzības nolūkos paredzēta apstrāde ražošanas vidē joprojām ir laba prakse.

Galvenās atziņas

  • response_format atgriež JSON virkni laukā response.choices[0].message.content
  • Parsēšana ir tava atbildība: json.loads(), model_validate_json() vai cita metode
  • Vari izmantot neapstrādātu JSON shēmu Pydantic modeļa vietā
  • Lielāka elastība nekā parse(), taču jāraksta vairāk koda
  • Atgrieztais JSON ir garantēti derīgs — parsēšanas kļūdām nevajadzētu rasties