F01 — Python und NumPy
← Diagnose & Lernpfad · F02 — Tensoren & Shapes → · Glossar
Lernziel
Du verwandelst eine kleine Datentransformation in ein getestetes NumPy-Programm und erklärst jeden erzeugten Wert. Dieser Block ist Pflicht, wenn die Diagnose Python und Entwicklung als Pflicht markiert hat.
Schreibst du schon Python, überfliege die Schritte vor „Bauen“; das Bauen dauert 45–60 Minuten. Ist Programmieren neu, plane etwa 60–90 Minuten für alles vor „Bauen“ (einschließlich des Testschritts) und weitere 60–120 Minuten für das Bauen ein, verteilt auf mehrere Sitzungen. Die Zeiten sind Orientierung, keine Frist.
Wenn dies dein erstes Python-Programm ist
Schließe zuerst die Einrichtung ab. Erstelle mit dem Dateimanager
artifacts/my-work und darin eine reine Textdatei hello.py (nicht hello.py.txt).
Schreibe diesen Python-Code hinein:
name = "tiny model"
print("Hello", name)Starte im Terminal aus dem Kursordner python artifacts/my-work/hello.py.
Erwartet: Hello tiny model. = weist einem Namen einen Wert zu; Text in
Anführungszeichen ist ein String; print(...) gibt seine Argumente aus.
# beginnt einen Kommentar. Fehler nennen Datei und Zeile: Behebe den ersten
relevanten Fehler, bevor du weitergehst.
Listen, Positionen und Ausschnitte
Eine Idee nach der anderen. Jeder Block unten bittet dich, eine Sache
vorherzusagen, bevor du ihn ausführst; der Kommentar in jeder Zeile ist die
Antwort, also decke ihn zuerst ab. Sammle die Blöcke bis „Einer Berechnung
einen Namen geben“ in einer Datei, artifacts/my-work/lists.py, jeden unter dem
vorigen, und starte nach jedem python artifacts/my-work/lists.py.
tokens = ["a", "b", "c", "d"]
print(tokens[0]) # a: Python zählt Positionen ab null
print(tokens[1:3]) # ['b', 'c']: Start inklusive, Ende exklusiv
print(tokens[:-1]) # ['a', 'b', 'c']: letztes Element weglassen
print(tokens[1:]) # ['b', 'c', 'd']: erstes Element weglassenEckige Klammern erzeugen eine Liste oder wählen daraus aus. Eine einzelne Zahl
wählt eine Position. Ein Doppelpunkt wählt einen Ausschnitt (Slice): Der
Start ist enthalten, das Ende nicht, und -1 zählt vom Ende. Eine leere Seite
heißt „vom Anfang“ oder „bis zum Ende“. Sage die vier ausgegebenen Zeilen
voraus, dann führe die Datei aus.
Für jedes Element wiederholen
for token in tokens:
print(token)for wiederholt die eingerückten Zeilen einmal pro Element; token hält dabei
das aktuelle. Der Block nutzt tokens aus dem ersten Block, der muss also
darüber stehen. Sage voraus, wie viele Zeilen erscheinen, dann prüfe.
Zwei Listen paaren
zip geht zwei Listen nebeneinander durch und gibt dir je ein Element aus
beiden:
pairs = list(zip(["a", "b", "c"], ["b", "c", "d"], strict=True))
print(pairs) # [('a', 'b'), ('b', 'c'), ('c', 'd')]list(...) sammelt die Paare, damit du sie ausgeben kannst. Jedes Paar steht in
runden Klammern: ein Tupel, eine feste Folge, die sich nicht ändert.
strict=True lässt zip mit einem Fehler abbrechen, wenn die Listen
verschieden lang sind, statt übrige Elemente stillschweigend wegzulassen. Lege
jetzt die zwei Ausschnitte von oben nebeneinander und zippe sie:
left = tokens[:-1] # ['a', 'b', 'c']
right = tokens[1:] # ['b', 'c', 'd']
print(list(zip(left, right, strict=True)))Sage die Paare vorher. Jedes Paar ist ein Zeichen und das Zeichen, das darauf folgt — genau das, was ein Bigramm-Modell zählt. Du hast gerade die Idee hinter T01 in zwei Zeilen geschrieben.
Interaktiv · Ausschnitte und Paare
tokens = ["a", "b", "c", "d"]
Welche Positionen wählt ein Ausschnitt?
Die Liste aus der Lektion. Tippe einen Ausschnitt oder wähle einen, und sage voraus, welche Kästchen aufleuchten, bevor du hinsiehst.
- 'a'
- 'b'
- 'c'
- 'd'
Ausgewählt: ['b', 'c']
Einer Berechnung einen Namen geben
Eine Funktion gibt einer Berechnung einen Namen, damit du sie wiederverwenden kannst:
def next_item_pairs(sequence):
if len(sequence) < 2:
return []
return list(zip(sequence[:-1], sequence[1:], strict=True))def definiert die Funktion, sequence ist ihre Eingabe. return gibt ein
Ergebnis zurück. if führt seinen eingerückten Zweig nur aus, wenn die Bedingung
wahr ist; < vergleicht Zahlen. Sage voraus, was next_item_pairs(["a"])
zurückgibt, dann füge die Funktion und print(next_item_pairs(["a"])) in
lists.py ein und führe es aus. Sage dann voraus: Wäre die Funktion für
["a"] und [] noch korrekt, wenn du die if-Zeile und das return []
darunter entfernst?
Antwort
Ja. Für ["a"] und für [] sind sequence[:-1] und sequence[1:] beide
leer, also findet zip keine Paare, und die Funktion gibt ohnehin []
zurück. Das if macht die Regel für kurze Eingaben nur für Lesende sichtbar.
Prüfen
Speichere Funktion und Test zusammen als artifacts/my-work/test_pairs.py:
def next_item_pairs(sequence):
if len(sequence) < 2:
return []
return list(zip(sequence[:-1], sequence[1:], strict=True))
def test_pairs():
assert next_item_pairs(["a", "b", "c"]) == [("a", "b"), ("b", "c")]
assert next_item_pairs([]) == []
assert next_item_pairs(["a"]) == []== prüft Gleichheit und ist keine Zuweisung. assert stoppt mit einem
AssertionError, wenn seine Bedingung falsch ist, und tut nichts, wenn sie wahr
ist. pytest führt jede Funktion aus, deren Name mit test_ beginnt, in Dateien,
deren Name mit test_ beginnt. Starte
python -m pytest artifacts/my-work/test_pairs.py; die letzte Zeile zeigt
1 passed, eingerahmt von =-Zeichen und gefolgt von der benötigten Zeit.
Grün heißt, dass diese Assertions bestehen; es beweist nichts über ungeprüfte
Eingaben.
Ändere ein erwartetes Paar und prüfe, dass die Assertion den Fehler wirklich findet — sage voraus, welche Zeile zuerst scheitert —, dann stelle es wieder her.
Zwei Dinge, die du im Kurscode sehen wirst, aber noch nicht brauchst:
Typannotationen wie sequence: list[str] beschreiben den erwarteten Typ für
Menschen und Werkzeuge, und Python erzwingt sie nicht; ein Docstring ist eine
Erklärung in dreifachen Anführungszeichen direkt innerhalb einer Funktion.
NumPy-Begriffe vor der nächsten Aufgabe
import numpy as np lädt die Zahlenbibliothek unter dem Kurznamen np.
Ein Array enthält Werte mit gemeinsamem Zahlentyp (dtype): Ganzzahlen für
IDs, Gleitkommazahlen für Wahrscheinlichkeiten. shape zählt Elemente entlang
jeder Achse. Bei [[1,4,2],[3,0,2]] bedeutet (2,3) zwei Zeilen mit drei Zahlen.
np.all(condition) prüft, ob alle Elemente die Bedingung erfüllen. Eine Funktion
kann mit raise ValueError("reason") ungültige Eingaben erklären, statt mit ihnen
weiterzurechnen. Beginne mit dem Beispiel unten und baue dann den Validator.
Vorhersagen → Verfolgen → Bauen → Brechen → Messen → Erklären
Beginne mit benachbarten Paaren:
tokens = ["a", "b", "c", "d"]
pairs = list(zip(tokens[:-1], tokens[1:], strict=True))
assert pairs == [("a", "b"), ("b", "c"), ("c", "d")]Sage die drei Paare vor dem Lauf voraus und verfolge beide Slices. Kapsle die Transformation anschließend in einer Funktion und teste leere, einteilige und normale Eingaben. Die Schleife besucht jedes Element höchstens einmal; Laufzeit und Ausgabespeicher wachsen linear mit der Eingabelänge.
NumPy macht numerische Verträge sichtbar
import numpy as np
token_ids = np.array([[1, 4, 2], [3, 0, 2]], dtype=np.int64)
assert token_ids.shape == (2, 3)
assert token_ids.dtype == np.int64
assert np.all(token_ids >= 0)Der Shape beschreibt zwei Beispiele mit je drei Positionen. Speichere den Block
als artifacts/my-work/contract.py und starte
python artifacts/my-work/contract.py; es erscheint nichts, weil jede Assertion
hält. Brich den Vertrag, indem du eine ID durch -1 ersetzt (zum Beispiel
[[1, -1, 2], [3, 0, 2]]), sage voraus, welche Assertion scheitert, und starte
erneut: Die np.all-Zeile löst einen AssertionError aus. Repariere dann die
Daten, statt die Assertion zu entfernen.
Testen, dass falsche Eingaben abgelehnt werden
Beim Bauen sollen Fehlermeldungen den fehlerhaften Wert nennen, und Tests sollen belegen, dass falsche Eingaben abgelehnt werden. Dafür gibt es zwei Werkzeuge; nimm dir etwa 15 Minuten.
Ein f-String setzt Werte in Text ein. Speichere dies als
artifacts/my-work/fstring.py und führe es aus:
token_id = -1
message = f"negative ID: {token_id}"
print(message) # negative ID: -1Das f vor dem öffnenden Anführungszeichen lässt Python jedes {...} durch den
Wert des Namens darin ersetzen.
Normalerweise scheitert ein Test, wenn ein Fehler auftritt. Innerhalb von
with pytest.raises(ValueError): gilt das Gegenteil: Der Test besteht nur, wenn
der eingerückte Code einen ValueError auslöst. Speichere dies als
artifacts/my-work/test_raises.py:
import pytest
def check_id(token_id):
if token_id < 0:
raise ValueError(f"negative ID: {token_id}")
def test_check_id_rejects_negative():
with pytest.raises(ValueError) as error:
check_id(-1)
assert "-1" in str(error.value)import pytest lädt die Testbibliothek. as error behält den abgefangenen
Fehler, str(error.value) ist seine Meldung, und in prüft, dass "-1" darin
vorkommt. Starte python -m pytest artifacts/my-work/test_raises.py; die letzte
Zeile zeigt 1 passed. Ändere jetzt check_id(-1) in check_id(1), sage
voraus, was pytest meldet, und starte dann. Erwartet:
Failed: DID NOT RAISE <class 'ValueError'> — nichts wurde abgelehnt, also
scheitert der Test. Stelle es wieder her.
Jeder Test für ungültige Eingaben beim Bauen hat dieselben vier Teile: falsche
Eingabe, pytest.raises, der Aufruf und die Prüfung der Meldung.
def test_rejects_negative_ids():
batch = np.array([[1, -1, 2]], dtype=np.int64)
with pytest.raises(ValueError) as error:
validate_token_batch(batch)
assert "-1" in str(error.value)Er braucht import numpy as np und import pytest oben in der Datei. Kopiere ihn
einmal pro ungültigem Fall und ändere Namen, falsche Eingabe und den Text, den du
in der Meldung erwartest. Zwei Tests mit demselben Namen meldet ruff als F811, und
nur der letzte läuft.
Bauen
Arbeite in einer Datei, artifacts/my-work/test_f01.py: oben die Imports, dann
deine Funktionen, dann die Tests, wie in test_pairs.py. Implementiere
next_item_pairs(sequence) ohne Kurscode zu importieren. Ergänze Typangaben,
einen kurzen Docstring und drei Tests: leer, ein Element, normal. Implementiere
danach validate_token_batch(array), das bei nicht-ganzzahligen, negativen oder
nicht-2D-Eingaben einen ValueError auslöst. Jede Fehlermeldung nennt den
fehlerhaften Wert, und jede der drei Ablehnungen bekommt einen eigenen Test nach
der Vorlage oben. Hängst du fest? Öffne unten den „Hinweis zum Validator“.
Abschlussnachweis
- Tests decken leere, einteilige, normale und ungültige Eingaben ab;
- die Ausgabe ist deterministisch;
- du erklärst Slicing, Iteration, dtype und jede Assertion;
ruff check artifacts/my-workundpython -m pytest artifacts/my-workbestehen. Nenne den Ordner: Ein bloßesruff check .undpytestprüfen den Kurscode, nicht deinen.
Wie geht es weiter?
Weiter mit F02 — Tensoren und Shapes. Kehre zu F01 zurück, wenn Python-Ablauf, Tests, Exceptions oder NumPy-dtypes Verhalten verdecken.
Hinweis zum Validator
Prüfe array.ndim != 2, np.issubdtype(array.dtype, np.integer) und
np.any(array < 0). Das prüft getrennt Rang, Typ und Werte.
Referenzvalidator
import numpy as np
def validate_token_batch(array):
if array.ndim != 2:
raise ValueError(f"expected 2D, got shape {array.shape}")
if not np.issubdtype(array.dtype, np.integer):
raise ValueError(f"expected integer IDs, got {array.dtype}")
if np.any(array < 0):
raise ValueError(f"negative IDs: {array[array < 0].tolist()}")