---
title: "F01 — Python und NumPy"
sidebar:
  label: "F01 — Python & NumPy"
---

<span id="f01-python-und-numpy" />


[← Diagnose & Lernpfad](/de/diagnostic) · [F02 — Tensoren & Shapes →](/de/foundations-02-shapes) · [Glossar](/de/glossary)

## Lernziel [#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 [#wenn-dies-dein-erstes-python-programm-ist]

Schließe zuerst die [Einrichtung](/de/setup) ab. Erstelle mit dem Dateimanager
`artifacts/my-work` und darin eine reine Textdatei `hello.py` (nicht `hello.py.txt`).
Schreibe diesen Python-Code hinein:

```python
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 [#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`.

```python
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 weglassen
```

Eckige 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 [#fur-jedes-element-wiederholen]

```python
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 [#zwei-listen-paaren]

`zip` geht zwei Listen nebeneinander durch und gibt dir je ein Element aus
beiden:

```python
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*:

```python
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

**Interaktiver Ausschnitt-Visualizer.** `tokens = ["a", "b", "c", "d"]`: `tokens[1:3]` → ['b', 'c']; `tokens[:-1]` → ['a', 'b', 'c']; `tokens[1:]` → ['b', 'c', 'd']. Ein Ausschnitt `[start:stop]` enthält den Start und lässt das Ende weg; `-1` zählt vom Ende. `zip(tokens[:-1], tokens[1:])` ergibt [('a', 'b'), ('b', 'c'), ('c', 'd')] — jedes Zeichen mit seinem Nachfolger. Im Browser tippst du einen eigenen Ausschnitt und siehst, welche Positionen aufleuchten.

### Einer Berechnung einen Namen geben [#einer-berechnung-einen-namen-geben]

Eine **Funktion** gibt einer Berechnung einen Namen, damit du sie wiederverwenden
kannst:

```python
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?

<details>
<summary>Antwort</summary>

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.


</details>

### Prüfen [#prufen]

Speichere Funktion und Test zusammen als `artifacts/my-work/test_pairs.py`:

```python
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 [#numpy-begriffe-vor-der-nachsten-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 [#vorhersagen-verfolgen-bauen-brechen-messen-erklaren]

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 [#numpy-macht-numerische-vertrage-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 [#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:

```python
token_id = -1
message = f"negative ID: {token_id}"
print(message)   # negative ID: -1
```

Das `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`:

```python
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.

```python
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 [#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 [#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-work` und `python -m pytest artifacts/my-work`
  bestehen. Nenne den Ordner: Ein bloßes `ruff check .` und `pytest` prüfen den
  Kurscode, nicht deinen.

## Wie geht es weiter? [#wie-geht-es-weiter]

Weiter mit [F02 — Tensoren und Shapes](/de/foundations-02-shapes). Kehre zu F01
zurück, wenn Python-Ablauf, Tests, Exceptions oder NumPy-dtypes Verhalten
verdecken.

[← Diagnose](/de/diagnostic) · [→ F02](/de/foundations-02-shapes)

<details>
<summary>Hinweis zum Validator</summary>

Prüfe `array.ndim != 2`, `np.issubdtype(array.dtype, np.integer)` und
`np.any(array < 0)`. Das prüft getrennt Rang, Typ und Werte.


</details>

<details>
<summary>Referenzvalidator</summary>

```python
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()}")
```


</details>

[← Diagnose & Lernpfad](/de/diagnostic) · [F02 — Tensoren & Shapes →](/de/foundations-02-shapes) · [Glossar](/de/glossary)
