0%

Kapitel 4

Strukturierte Ausgabe

Mit Text kann ein Programm wenig anfangen

Bisher war jede Antwort Text, den ein Mensch liest. Dein Lern-Chat gibt ihn aus, und du liest ihn. In diesem Kapitel geht es um Antworten, die stattdessen ein Programm liest: eine Quiz-App, die die Frage, die Auswahlmöglichkeiten und die richtige Antwort als getrennte Werte braucht, damit sie sie anzeigen, eine Antwort prüfen und Punkte zählen kann. Diese Werte zuverlässig aus der Antwort eines Modells herauszuholen, nennt man strukturierte Ausgabe (structured output).

Dein Projekt für dieses Kapitel

Öffne structured.py im Projekteditor. Die Datei beginnt mit diesen 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 ist der fertige Code aus Kapitel 2 und llm_basics.py der aus Kapitel 1. Wie bisher verwendet die Prüfung deiner Arbeit eigene Kopien davon. Eine Änderung dort kann also keine Bewertung beeinflussen, aber sie kann die Demonstration lahmlegen. Zwei Dateien sind neu. prompts.py enthält die festen Prompt-Texte, die dieses Kapitel sendet. quiz_models.py enthält die Datenmodelle des Quiz; du liest die Datei in Lektion 4 und stellst sie in Lektion 5 fertig. pydantic, die Bibliothek, aus der diese Modelle stammen, ist in deiner Sandbox bereits installiert, und requirements.txt nennt die Version.

Jede Anfrage in diesem Kapitel wartet auf die vollständige Antwort, so wie in Kapitel 1 und 2. Mit einem halben Quiz kann ein Programm nichts anfangen, Streaming würde hier also nichts bringen.

Unter den Imports stehen eine fertige Funktion, numbered_lines, und zehn unfertige, eine oder zwei pro Lektion. python structured.py führt die Datei aus, und die Demonstration am Ende ruft jede Funktion auf, sobald es sie gibt.

Fordere ein Quiz als Text an

prompts.py enthält den ersten Prompt:

QUIZ_TEXT_PROMPT = "Write three quiz questions about Python lists."

Führe jetzt in der Shell python structured.py aus, bevor du etwas änderst. Die Demonstration sendet diesen Prompt als einzige Nachricht, gibt die Antwort aus und danach, was numbered_lines darin findet:

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.

Das geskriptete Modell beantwortet diesen Prompt mit drei nummerierten Fragen, unter jeder eine Zeile mit Auswahlmöglichkeiten, die mit Buchstaben gekennzeichnet sind, und einer Answer:-Zeile. numbered_lines ist ein schneller Parser, der für genau dieses Layout geschrieben wurde:

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

Er teilt die Antwort in Zeilen auf und behält jede Zeile, die mit einer Ziffer, einem Punkt und einem Leerzeichen beginnt, ohne diese drei Zeichen. In der geskripteten Antwort findet er genau die drei Fragen. Die Auswahlmöglichkeiten und Antworten aus den anderen Zeilen zu holen, wären nur ein paar weitere String-Methoden derselben Art.

Derselbe Prompt an ein Live-Modell

Am 08.11.2026 ging derselbe Prompt als einzige Nachricht an openai/gpt-oss-20b, das Modell hinter pl-live. Das ist seine Antwort, unbearbeitet:

**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.

Ein Mensch liest das mühelos. Man könnte sogar sagen, dass es das bessere Quiz ist. Gib es jetzt an numbered_lines:

['**Basic Operations**', '**Indexing and Slicing**', '**List Comprehension**']

Das Live-Modell hat für jede Frage eine Themenüberschrift nummeriert, in fettem Markdown (die ** darum herum), und die eigentliche Frage eingerückt in die nächste Zeile gesetzt. Die Zeilen, die mit einer Zahl beginnen, sind also die Überschriften. Die Auswahlmöglichkeiten sind ebenfalls eingerückt, es sind vier Buchstaben statt drei, und nirgends in der Antwort steht eine Lösung. Eine zweite Anfrage mit demselben Prompt, ein paar Sekunden später, lieferte wieder ein anderes Layout: fette **A)**-Auswahlmöglichkeiten, ein *Question:*-Label in einer eigenen Zeile und einen Codeblock in der dritten Frage.

Eine falsche Antwort ist schlimmer als ein Absturz

Sieh dir an, was numbered_lines mit der Live-Antwort gemacht hat. Die Funktion hat keinen Fehler ausgelöst. Sie hat eine Liste mit drei Strings zurückgegeben, genau den Typ, den der Rest eines Programms erwartet. Eine darauf aufgebaute Quiz-App würde drei Überschriften als Fragen anzeigen, keine Auswahlmöglichkeiten anbieten und keine Lösungen zum Vergleichen haben, und nichts würde dir sagen, warum. Ein Fehler hält ein Programm in der Zeile an, in der etwas schiefging. Ein plausibler falscher Wert wandert weiter und richtet seinen Schaden an einer anderen Stelle an.

Das geskriptete Modell verwendet immer dasselbe Layout, deshalb hat der Parser dort funktioniert. Ein Live-Modell schreibt Text für Menschen und kann denselben Inhalt jedes Mal anders anordnen. Ein Mensch passt sich an, ohne es zu merken. Ein Programm tut genau das, wofür es geschrieben wurde.

Was ein Programm braucht

Ein Programm braucht eine Antwort mit einer Form, auf die es sich verlassen kann: jedes Mal dieselben benannten Teile, jeder mit der Art von Wert, die es erwartet, und eine Möglichkeit zu erkennen, wenn eine Antwort diese Form nicht hat. Ein Format, das genau dafür gebaut ist, kennst du aus Python in der Praxis: JSON. Ein JSON-Objekt hat benannte Schlüssel, seine Werte haben Typen wie Strings, Zahlen und Listen, und json.loads dekodiert es entweder oder löst einen Fehler aus.

Einen schlaueren Text-Parser zu schreiben, ist ein Wettlauf, den du verlierst. Die nächste Live-Antwort kann ein Layout verwenden, mit dem du nicht gerechnet hast, und der Parser gibt wieder ohne Beschwerde etwas Falsches zurück. Die Lösung liegt auf der anderen Seite: Bitte das Modell um ein Format, das ein Programm prüfen kann.

Der Plan für dieses Kapitel

Lektion 2 bittet das Modell um JSON und prüft die Schlüssel von Hand. Die Lektionen 3 bis 5 führen die Werkzeuge ein, mit denen du die gewünschte Form beschreibst: Type Hints und ein Pydantic-Modell, eine Klasse, die jedes Feld und seinen Typ auflistet. Lektion 6 prüft mit diesem Pydantic-Modell eine Antwort in einem Schritt, Lektion 7 schickt die Form mit der Anfrage mit, und Lektion 8 fragt ein einziges Mal erneut, wenn eine Antwort nicht passt. Das Abschlussprojekt macht aus jeder Kursnotiz ein geprüftes Quiz und gibt es aus.

Was hat numbered_lines für die Live-Antwort zurückgegeben, und warum?

Was braucht ein Programm von einer Antwort, das ein Mensch beim Lesen nicht braucht?

Würde ein strengerer Text-Parser, der auch fette Überschriften und eingerückte Fragen versteht, das Problem lösen?