Unit Testing | Data Science

Was lernst du in diesem Kapitel?

Von der TÜV-Idee bis zu pytest im Data-Science-Alltag

Du gehst von Motivation über erste Tests, Red-Green-Refactor, Fixtures und Parametrisierung bis zu pandas-Tests und einem testbaren Taschenrechner.

AlltagTÜV, IKEA, Kuchen, Supermarkt, Ampel

DidaktikErst Bild, dann Code, dann Übung, dann Quiz

Transferpytest, pandas testing und testbare Projekte

Aktiver Abschnitt Modul 0 startet hier

← Zurück zur Übersicht

0 Prozent abgeschlossen Rang: TÜV-Azubi

Modul 0 · Warm-up

Warum testen wir überhaupt?

Unit Tests sind wie eine TÜV-Prüfung für Code: Jedes Teil wird einzeln gecheckt, bevor das ganze System auf die Straße darf.

Noch offen. Wähle drei Prüfpunkte aus dem Alltag und sichere damit die Grundidee.

Alltagsgeschichte

Beim TÜV wird nicht nur geschaut, ob das Auto irgendwie fährt. Bremsen, Licht, Reifen und Abgas werden einzeln geprüft. Genau so denkst du beim Testen: Erst die kleinen Bauteile, dann das große Ganze.

Übertragung auf Code

Eine Funktion wie divide() oder impute() ist ein einzelnes Bauteil. Ein Unit Test prüft: Liefert diese eine Funktion das, was sie soll?

TÜV-Inspektor

Wähle die drei Prüfpunkte, die du VOR Vertrauen kontrollieren würdest.

Wähle drei sinnvolle Prüfpunkte. Danach siehst du die Parallele zu Unit Tests.

Modul 1 · Packaging

Code ordentlich verpacken

Wie bei einem IKEA-Regal hilft eine klare Struktur: Python-Pakete, Module und Tests liegen sauber sortiert.

Noch offen. Wähle den richtigen Import und verstehe, warum das Paket sauber strukturiert sein muss.

Projektstruktur

ds-unit-testing/
├── src/
│   ├── example/
│   │   ├── __init__.py
│   │   └── example_file.py
├── tests/
└── notebooks/

Welcher Import passt?

Wähle die Importzeile, die zum Packaging-Notebook passt. Wichtig: Importiert wird aus dem Quellpaket unter src, nicht aus dem Ordner tests.

🏋️ Übung: add_one importieren

Der Startercode kommt direkt aus dem Packaging-Notebook. Ergänze die Importzeile und prüfe danach, ob die Funktion aus 1 eine 2 macht.

📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.

# ??? DEINE LÖSUNG ???
print(add_one(1))

💡 Tipp anzeigen

Im Notebook liegt die Funktion in src.example.example_file. Der Import folgt also dem Paketpfad der Quelldatei, nicht dem Speicherort des Notebooks.

✅ Lösung anzeigen

from src.example.example_file import add_one
print(add_one(1))

Erwartete Ausgabe: `2`

Modul 2 · Erster Test

Vom print zu pytest

Wie bei einem Kuchenrezept werden Prüfungen immer professioneller: erst hinschauen, dann dokumentieren, dann automatisch testen.

Noch offen. Gehe die vier Stufen durch und sichere die richtige Reihenfolge.

Vier Stufen

print()

doctest

assert

pytest

Klicke die Stufen in sinnvoller Reihenfolge an.

divide()-Beispiel

def divide(x, y):
    if y == 0:
        return "Can not divide by zero"
    return x / y

Aus genau so einer kleinen Funktion baust du zuerst einzelne Prüfungen auf. assert ist dabei nur eine einzelne Behauptung. pytest ist das Werkzeug, das viele solcher Tests automatisch findet, startet und auswertet.

🏋️ Übung: Dein erster pytest-Test

Die Funktion ist schon da. Ergänze jetzt die Zeile, die prüft, ob divide(6, 2) wirklich 3 ergibt.

📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.

def divide(x, y):
    if y == 0:
        return "Can not divide by zero"
    return x / y

def test_divide():
    # ??? DEINE LÖSUNG ???

💡 Tipp anzeigen

Ein pytest-Test enthält meist ein klares assert mit Soll und Ist. Der Funktionsname startet oft mit test_, damit pytest ihn automatisch einsammelt.

✅ Lösung anzeigen

def divide(x, y):
    if y == 0:
        return "Can not divide by zero"
    return x / y

def test_divide():
    assert divide(6, 2) == 3

Erwartete Ausgabe: `1 passed`

Modul 3 · TDD

Red-Green-Refactor als Ampelspiel

TDD plant das Verhalten zuerst. Der Test wird rot, dann grün, dann wird der Code sauberer gemacht.

Noch offen. Spiele die Ampelrunde einmal vollständig durch.

Ampelrunde

🔴 Red

🟢 Green

🟡 Refactor

Starte mit Rot: erst Verhalten beschreiben, dann Code schreiben.

Beispiel aus dem Notebook

def test_format_data_for_display():
    people = [{"given_name": "Alfonsa", "family_name": "Ruiz", "title": "Senior Software Engineer"}]
    assert format_data_for_display(people) == [
        "Alfonsa Ruiz: Senior Software Engineer"
    ]

Der Test beschreibt zuerst, was die Funktion liefern soll. Danach wird die Funktion so klein wie möglich gebaut, bis der Test grün ist. TDD heißt also nicht: erst fertig programmieren und dann prüfen, sondern Verhalten zuerst festzurren.

Modul 4 · Fixtures & Parametrize

Testdaten sauber organisieren

Fixtures sind wiederverwendbare Testvorlagen. Parametrize ist deine Prüfliste für viele ähnliche Fälle.

Noch offen. Ordne Fixture und Parametrize den richtigen Alltagsbildern zu.

Zuordnung

Klicke erst Fixture, dann Parametrize. Beide Begriffe gehören zusammen, meinen aber nicht dasselbe: Fixture liefert wiederverwendbare Ausgangsdaten, Parametrize wiederholt denselben Test mit vielen Fällen.

Notebook-Code

@pytest.fixture
def example_people_data():
    return [{"given_name": "Alfonsa", "family_name": "Ruiz"}]

@pytest.mark.parametrize("palindrome", ["", "Bob", "Never odd or even"])
def test_is_palindrome(palindrome):
    assert is_palindrome(palindrome)

🏋️ Übung: Parametrize ergänzen

Baue aus mehreren Einzeltests eine parametrisierte Version. Ergänze die fehlende Deko-Zeile und den erwarteten Wert.

📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.

import pytest

def is_palindrome(s):
    return s == s[::-1]

# ??? DEINE LÖSUNG ???
def test_is_palindrome(word, expected_result):
    assert is_palindrome(word) == # ??? DEINE LÖSUNG ???

💡 Tipp anzeigen

Die Notebook-Variante nutzt @pytest.mark.parametrize mit zwei Spalten: Eingabe und erwartetes Ergebnis.

✅ Lösung anzeigen

import pytest

def is_palindrome(s):
    return s == s[::-1]

@pytest.mark.parametrize("word, expected_result", [
    ("Bob", True),
    ("abc", False),
])
def test_is_palindrome(word, expected_result):
    assert is_palindrome(word) == expected_result

Erwartete Ausgabe: `2 passed`

Modul 5 · Data Science

Daten testen mit pandas

Im Data-Science-Alltag testest du nicht nur Logik, sondern auch Datenqualität, Imputation und Transformationen.

Noch offen. Ergänze die Imputation sinnvoll und lies die DataFrame-Rückmeldung.

Supermarkt-Analogie

Wenn an Jeans im Regal Preisschilder fehlen, fällt das in der Qualitätskontrolle sofort auf. In pandas ist ein fehlender Preis ein NaN. Auch das musst du testen. assert_series_equal vergleicht dabei nicht nur einen einzelnen Wert, sondern die komplette Serie inklusive Reihenfolge und Datentyp.

Imputation live

Fehlende Werte2

MethodeMittelwert

Nach dem Test2

Starte mit dem Mittelwert. Das ist die Notebook-Variante der Grundfunktion.

🏋️ Übung: impute() testen

Dieser Test ist direkt aus dem Data-Science-Notebook vereinfacht. Ergänze die erwartete Serie für die Mittelwert-Imputation.

📓 Öffne dein Jupyter Notebook oder Google Colab und probiere es selbst aus.

import pandas as pd
from pandas.testing import assert_series_equal

def impute(series):
    return series.fillna(series.mean())

input_series = pd.Series([1.0, None, 3.0])
expected_result = pd.Series(# ??? DEINE LÖSUNG ???)
assert_series_equal(impute(input_series), expected_result)

💡 Tipp anzeigen

Der Mittelwert von 1.0 und 3.0 ist 2.0. Genau dieser Wert ersetzt die Lücke.

✅ Lösung anzeigen

import pandas as pd
from pandas.testing import assert_series_equal

def impute(series):
    return series.fillna(series.mean())

input_series = pd.Series([1.0, None, 3.0])
expected_result = pd.Series([1.0, 2.0, 3.0])
assert_series_equal(impute(input_series), expected_result)

Erwartete Ausgabe: kein Fehler, der Test läuft grün durch

Modul 6 · Abschlussprojekt

Ein testbarer Taschenrechner

Zum Schluss führst du alles zusammen: Tests zuerst, Funktionen danach, dann ein kleines CLI-Projekt.

Noch offen. Löse das Abschlussquiz vollständig, damit das Kapitel wirklich sitzt.

Projekt-Checkliste

Tests zuerst schreiben
Rechenfunktionen implementieren
Division durch Null absichern
CLI mit typer anschließen

TDD-Reihenfolge

Klicke die Reihenfolge einmal bewusst durch.

Abschlussquiz

Was nimmst du mit?

Unit Tests geben dir Sicherheit. Sie helfen dir beim Umbauen, beim Datenprüfen und beim gemeinsamen Arbeiten an Projekten.