Hoofdstuk 4
Gestructureerde uitvoer
Tekst is lastig voor een programma
Tot nu toe was elk antwoord tekst die een mens leest. Je studiechat drukt het af en jij leest het. Dit hoofdstuk gaat over antwoorden die een programma leest: een quiz-app die de vraag, de keuzes en het goede antwoord als losse waarden nodig heeft, zodat hij ze kan tonen, een antwoord kan controleren en de score kan bijhouden. Die waarden betrouwbaar uit het antwoord van een model halen heet gestructureerde uitvoer (structured output).
Je project voor dit hoofdstuk
Open structured.py in de projecteditor. Het bestand begint met deze imports:
import json
import requests
from pydantic import ValidationError
from conversation import note_message
from llm_basics import MODEL, answer_text, send_body
from prompts import INVALID_PREFIX, QUIZ_PROMPT, QUIZ_SYSTEM, QUIZ_TEXT_PROMPT
from quiz_models import QuizQuestion, QuizSet
conversation.py is de afgeronde code van hoofdstuk 2 en llm_basics.py die van hoofdstuk 1. Net als eerder gebruikt de controle van je werk eigen kopieën ervan, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen. Twee bestanden zijn nieuw. prompts.py bevat de vaste prompts die dit hoofdstuk verstuurt. quiz_models.py bevat de datamodellen van de quiz; je leest het in les 4 en maakt het af in les 5. pydantic, de bibliotheek waar die modellen uit komen, is al geïnstalleerd in je sandbox, en requirements.txt noemt de versie.
Elk request in dit hoofdstuk wacht op het hele antwoord, zoals in hoofdstuk 1 en 2. Een programma kan niets met een halve quiz, dus streamen levert hier niets op.
Onder de imports staan één afgeronde functie, numbered_lines, en tien onafgemaakte, één of twee per les. python structured.py voert het bestand uit, en de demonstratie onderaan roept elke functie aan zodra die bestaat.
Vraag om een quiz als tekst
prompts.py bevat de eerste prompt:
QUIZ_TEXT_PROMPT = "Write three quiz questions about Python lists."
Voer in de Shell nu python structured.py uit, voordat je iets verandert. De demonstratie verstuurt die prompt als enige bericht, drukt het antwoord af en drukt daarna af wat numbered_lines erin vindt:
A quiz written as text:
1. What does scores[-1] give for scores = [90, 72, 85]?
a) 90 b) 72 c) 85
Answer: c
2. What does scores.append(60) return?
a) The new list b) None c) 60
Answer: b
3. Which line makes an independent copy of scores?
a) backup = scores.copy() b) backup = scores c) backup = scores.append(0)
Answer: a
What numbered_lines finds in it:
['What does scores[-1] give for scores = [90, 72, 85]?', 'What does scores.append(60) return?', 'Which line makes an independent copy of scores?']
The questions in a JSON reply, checked by read_quiz_json:
Run stopped at the next function to build: quiz_request is built in Lesson 2.
Het gescripte model beantwoordt deze prompt met drie genummerde vragen, onder elke vraag een regel met keuzes met letters, en een regel Answer:. numbered_lines is een snelle parser die voor die opmaak is geschreven:
def numbered_lines(text):
found = []
for line in text.split("\n"):
if line[:1].isdigit() and line[1:3] == ". ":
found.append(line[3:].strip())
return found
Hij splitst het antwoord in regels en houdt elke regel die begint met een cijfer gevolgd door een punt en een spatie, zonder die drie tekens. In het gescripte antwoord vindt hij precies de drie vragen. De keuzes en antwoorden uit de andere regels halen zou nog een paar stringmethoden van dezelfde soort kosten.
Dezelfde prompt naar een live model
Op 2026-11-08 ging dezelfde prompt als enige bericht naar openai/gpt-oss-20b, het model achter pl-live. Dit is het antwoord, onbewerkt:
**Quiz: Python Lists**
1. **Basic Operations**
Which of the following statements correctly appends the value `42` to the end of the list `my_list`?
a) `my_list + 42`
b) `my_list.append(42)`
c) `my_list.insert(0, 42)`
d) `my_list = my_list + [42]`
2. **Indexing and Slicing**
Given `numbers = [10, 20, 30, 40, 50]`, what will `numbers[1:4]` return?
a) `[20, 30, 40]`
b) `[10, 20, 30]`
c) `[20, 30, 40, 50]`
d) `[30, 40, 50]`
3. **List Comprehension**
Which list comprehension will produce the list `[1, 4, 9, 16]`?
a) `[i*i for i in range(1, 5)]`
b) `[i**2 for i in [1, 2, 3, 4]]`
c) `[(i-1)**2 for i in range(1, 5)]`
d) Both a) and b) are correct.
Een mens leest dat zonder moeite. Het is misschien zelfs een betere quiz. Geef het nu aan numbered_lines:
['**Basic Operations**', '**Indexing and Slicing**', '**List Comprehension**']
Het live model nummerde voor elke vraag een kopje met het onderwerp, vetgedrukt in Markdown (de ** eromheen), en zette de vraag zelf ingesprongen op de volgende regel. De regels die met een getal beginnen zijn dus de kopjes. De keuzes zijn ook ingesprongen, ze hebben vier letters in plaats van drie, en nergens in het antwoord staat het goede antwoord. Een tweede request met dezelfde prompt, een paar seconden later, gaf weer een andere opmaak: vetgedrukte keuzes **A)**, een label *Question:* op een eigen regel, en een codeblok in de derde vraag.
Een fout antwoord is erger dan een crash
Kijk wat numbered_lines met het live antwoord deed. Hij gaf geen foutmelding. Hij gaf een lijst van drie strings terug, precies het type dat de rest van een programma verwacht. Een quiz-app die erop gebouwd is, zou drie kopjes als vragen tonen, geen keuzes aanbieden en geen antwoorden hebben om mee te vergelijken, en niets zou je vertellen waarom. Een fout stopt een programma op de regel waar het misging. Een geloofwaardige foute waarde reist verder en richt ergens anders schade aan.
Het gescripte model gebruikt altijd één opmaak, en daarom werkte de parser erop. Een live model schrijft tekst voor mensen en kan dezelfde inhoud elke keer anders opmaken. Een mens past zich aan zonder het te merken. Een programma doet precies wat er geschreven staat.
Wat een programma nodig heeft
Een programma heeft een antwoord nodig met een vorm waarop het kan rekenen: elke keer dezelfde benoemde onderdelen, elk met het soort waarde dat het verwacht, en een manier om te zien wanneer een antwoord die vorm niet heeft. Een formaat dat precies hiervoor gemaakt is ken je uit Python in de praktijk: JSON. Een JSON-object heeft benoemde sleutels, de waarden hebben types zoals strings, getallen en lijsten, en json.loads decodeert het of geeft een foutmelding.
Een slimmere tekstparser schrijven is een race die je verliest. Het volgende live antwoord kan een opmaak gebruiken waar je niet op had gerekend, en de parser geeft dan weer zonder klagen iets fouts terug. De oplossing ligt aan de andere kant: vraag het model om een formaat dat een programma kan controleren.
Het plan voor dit hoofdstuk
Les 2 vraagt het model om JSON en controleert de sleutels met de hand. Les 3 tot en met 5 introduceren de middelen om de gewenste vorm te beschrijven: type hints, en een pydantic-model, een klasse die elk veld met zijn type opsomt. Les 6 gebruikt dat pydantic-model om een antwoord in één stap te controleren, les 7 stuurt de vorm mee met het request, en les 8 vraagt het nog één keer als een antwoord niet past. Het project maakt van elke cursusnotitie een gecontroleerde quiz en drukt die af.
Wat gaf numbered_lines terug voor het live antwoord, en waarom?
Wat heeft een programma nodig van een antwoord dat een mens die het leest niet nodig heeft?
Zou een strengere tekstparser, die ook vette kopjes en ingesprongen vragen begrijpt, het probleem oplossen?