Grundlagen: Python-Module, Fehlersuche und Tests

Ein Modul enthält Python-Code, den ein anderes Programm wiederverwenden kann. Die meisten Module sind .py-Dateien. Die Standardbibliothek wird mit Python geliefert; Code von Drittanbietern muss separat installiert werden. Ein Paket bündelt zusammengehörige Module, meist in einem Ordner.

Den Aufruf passend zum Import schreiben

Ein Import erzeugt Namen in deinem Programm. Die gewählte Form bestimmt, wie du den importierten Code aufrufst.

Punktnotation bedeutet, einen Namen innerhalb eines Moduls oder Objekts nachzuschlagen. In math.sqrt(16) findet Python sqrt innerhalb von math und ruft es mit 16 auf. Das Ergebnis ist 4.0. Die Konstante math.pi braucht keine Aufrufklammern, weil sie ein Wert und keine Funktion ist.

Nach import math löst sqrt(16) allein einen NameError aus: Das Programm hat einen Namen für das Modul, aber keinen eigenen Namen für sqrt. Nach alleinstehendem from math import sqrt löst der umgekehrte Fehler math.sqrt(16) ebenfalls einen NameError aus, weil math nicht gebunden wurde. Ein Alias ersetzt den üblichen Namen der importierten Bindung: import statistics as stats erzeugt stats, nicht beide Namen.

Dieselbe Berechnung auf zwei Arten durchführen

Ein rechtwinkliges Dreieck hat die Seitenlängen 3 und 4. Quadriere zuerst die Seitenlängen und addiere sie; ziehe dann die Quadratwurzel.

import math

length = math.sqrt(3**2 + 4**2)
print(length)  # 5.0

Der Ausdruck innerhalb des Aufrufs wird zu 9 + 16, dann zu 25; sqrt gibt 5.0 zurück. Mit from math import sqrt schreibst du stattdessen length = sqrt(3**2 + 4**2). Der vorangestellte Modulname macht die Herkunft einer Funktion sichtbar und hält die übrigen Namen des Moduls aus dem Namensraum deines Programms heraus. Die Bindung math selbst kann weiterhin eine frühere Variable namens math ersetzen.

Namen übersichtlich halten

Vermeide from math import *. Dieser Wildcard-Import bringt öffentliche Namen in dein Programm, ohne sie einzeln zu nennen. Zum Beispiel ändert e = 5, gefolgt von diesem Import, den Wert von e zu 2.718281828459045. Ein scheinbar unbeteiligter Import kann daher eine spätere Berechnung verändern. PEP 8 empfiehlt explizite Importe und setzt sie an den Anfang, mit einem Modul pro Zeile: zuerst die Standardbibliothek, danach Pakete von Drittanbietern, zuletzt eigene Module.

Python führt den Code auf Modulebene beim ersten Import eines Moduls während eines Programmlaufs aus. Spätere Importe verwenden das geladene Modul wieder; sie starten es nicht erneut.

Anhand des Fehlers die Lösung wählen

Führe in der interaktiven Shell import math und dann dir(math) aus, um die Namen des Moduls aufzulisten. Führe help(math.sqrt) aus, um die Dokumentation einer Funktion zu lesen. Die offizielle Python-Bibliotheksreferenz erklärt ihre Argumente und ihr Ergebnis.

Die Standardbibliothek stellt getestete Werkzeuge für Berechnungen und Simulationen bereit. Welche Funktion du wählst, hängt vom benötigten Ergebnis ab: einer ganzzahligen Anzahl, einem gerundeten Messwert, einem zufälligen Element oder einer neu angeordneten Liste.

Runden hat mehrere Bedeutungen

Nach import math gibt math.sqrt(16) die Gleitkommazahl 4.0 zurück. math.pi und math.e liefern die Konstanten 3.141592653589793 und 2.718281828459045. math.factorial(5) multipliziert die ganzen Zahlen von 1 bis einschließlich 5 und gibt 120 zurück.

Für 23 Quadratmeter Wand und 10 Quadratmeter pro Farbdose ergibt die Division 2.3 Dosen. Um ganze Dosen zu kaufen, brauchst du math.ceil(23 / 10), das 3 zurückgibt. round(2.3) ergibt 2 und damit zu wenig Farbe.

Die eingebaute Funktion round() braucht keinen Import. Für einen Kreis mit Radius 2 ergibt round(math.pi * 2 ** 2, 2) den Wert 12.57. Runden ändert die Genauigkeit einer Zahl; das ist eine andere Aufgabe, als genügend ganze Behälter zu kaufen.

Definitionsbereiche und Vergleiche von Gleitkommazahlen prüfen

math.sqrt(-1) löst ValueError aus, weil es für diese Eingabe keine reelle Quadratwurzel gibt. Auch bei berechneten Gleitkommazahlen ist Vorsicht nötig: Aufgrund der binären Speicherung ist 0.1 + 0.2 == 0.3 gleich False. math.isclose(0.1 + 0.2, 0.3) ist True; verwende es für einen näherungsweisen Vergleich berechneter Gleitkommazahlen.

Die Zufallsoperation auswählen

Das Modul random erzeugt mit einem Algorithmus Pseudozufallsergebnisse.

Schreibe random.shuffle(cards) in eine eigene Zeile. Weist du das Ergebnis wieder cards zu, geht die Bindung an die Liste verloren, weil sie durch None ersetzt wird. Positionen zu ziehen ist außerdem etwas anderes, als unterschiedliche Werte zu verlangen: random.sample([1, 1], 2) gibt [1, 1] zurück.

Eine reproduzierbare Simulation ausführen

import random

sevens = 0
for _ in range(1000):
    if random.randint(1, 6) + random.randint(1, 6) == 7:
        sevens += 1
print(sevens)

Sechs von 36 gleich wahrscheinlichen Paaren ergeben zusammen 7, deshalb liegt die Anzahl meist nahe bei 167, ändert sich aber zwischen den Läufen. Um eine Folge für die Fehlersuche zu reproduzieren, rufe vor dem Erzeugen der Werte random.seed(42) auf und verwende dieselbe Python-Version und Aufruffolge. Verwende für Passwörter oder Sicherheitstoken secrets.

Weitere alltägliche Werkzeuge finden

statistics.mean([2, 4, 9]) gibt 5 zurück; statistics.median([2, 4, 9]) gibt 4 zurück. datetime.date.today() liefert das heutige Datum. Nach import sys enthält sys.argv den Skriptnamen gefolgt von seinen Argumenten: Der Aufruf python greet.py Ada liefert ['greet.py', 'Ada'].

Eine Funktion lässt sich leichter wiederverwenden, wenn sie in einem Modul mit klarer Aufgabe steht. Ein anderes Programm kann diese Funktion importieren und ein Test kann sie prüfen, ohne dass jemand die gesamte Anwendung ausführen muss.

Die Funktion vom aufrufenden Code trennen

Speichere diesen Code als geometry.py:

"""Calculations for simple shapes."""
import math

def circle_area(radius):
    """Return the area of a circle with the given radius."""
    return math.pi * radius ** 2

Speichere im selben Ordner diesen aufrufenden Code als main.py:

import geometry

print(geometry.circle_area(2))

Führe python main.py aus. Python findet geometry, erstellt dessen Funktion und anschließend führt der aufrufende Code diese Funktion aus. Das ausgegebene Ergebnis ist 12.566370614359172. Importiere ohne die Endung .py. Ein gültiger Modulname verwendet Buchstaben, Ziffern und Unterstriche und beginnt mit einem gültigen Zeichen; my_tools.py funktioniert mit import my_tools, während import my-tools ungültige Syntax ist.

Die Zeichenketten am Anfang des Moduls und der Funktion sind Docstrings. Sie beschreiben den Zweck des Codes und erscheinen in help(geometry) und help(geometry.circle_area).

Verstehen, was ein Import ausführt

Beim ersten Import führt Python die Anweisungen des Moduls auf Modulebene der Reihe nach aus. Eine def-Anweisung erstellt eine Funktion; sie führt deren Körper nicht aus. Ein ungeschütztes print(circle_area(2)) am Ende von geometry.py würde dagegen beim Import eine Ausgabe erzeugen.

Dieser Nebeneffekt ist wichtig, wenn ein Modul Eingabeaufforderungen oder eine Programmschleife enthält. Ein Test, der nur circle_area benötigt, sollte nicht das Programm starten und dessen Eingabeaufforderungen beantworten müssen.

Den Start schützen, die Funktion verfügbar halten

Füge dies unterhalb der wiederverwendbaren Funktion in geometry.py ein:

def main():
    print(circle_area(2))

if __name__ == "__main__":
    main()

Python setzt __name__ für jedes Modul. Bei einer direkten Ausführung mit python geometry.py wird es auf "__main__" gesetzt, sodass die Bedingung wahr ist und main() aufgerufen wird. Beim Import von geometry wird es auf "geometry" gesetzt, sodass Python den Aufruf überspringt. Die Definitionen oberhalb der Schutzbedingung bleiben in beiden Fällen verfügbar.

Setze circle_area selbst nicht innerhalb der Schutzbedingung. Importierender Code braucht diese Definition auch dann, wenn die Startbedingung falsch ist. Die Schutzbedingung steuert, wann die Anwendung startet; sie hindert Python nicht daran, das Modul zu laden.

Wissen, wo Python sucht

Python prüft eingebaute Module wie sys und dann der Reihe nach die Ordner in sys.path. Normalerweise steht der Ordner des laufenden Skripts an erster Stelle dieses Pfads, gefolgt von den Ordnern der Standardbibliothek und der installierten Pakete. Eigene Dateien neben dem ausgeführten Skript aufzubewahren, ist eine einfache Anordnung für ein Anfängerprojekt. Ein Modul außerhalb des Suchpfads kann durch einen gewöhnlichen Import nicht gefunden werden.

Diese Reihenfolge kann auch ein Bibliotheksmodul verdecken. Speicherst du dein Programm als random.py, kann dessen import random deine Datei statt der Bibliothek laden. Ein späteres random.randint(1, 6) löst dann AttributeError aus. Benenne die Datei um, zum Beispiel in dice.py; Python 3.13 und spätere Versionen können der Fehlermeldung einen Hinweis zum Umbenennen hinzufügen.

Ein geladenes Modul wird innerhalb desselben Laufs wiederverwendet. Änderst du in einer interaktiven Shell die Datei und importierst sie erneut, bleibt die geladene Version erhalten. Starte die Shell neu, bevor du deine Änderungen testest.

Pakete von Drittanbietern ergänzen Code, der nicht mit Python geliefert wird. PyPI, der Python Package Index unter https://pypi.org, beherbergt diese Projekte. pip lädt sie herunter und installiert sie für eine bestimmte Python-Installation.

Erst das Terminal, dann Python verwenden

Ein Terminalbefehl und eine Python-Anweisung gehören an unterschiedliche Stellen. Die Eingabeaufforderung >>> bedeutet, dass du dich in Pythons interaktiver Shell befindest. Gibst du dort pip install requests ein, erhältst du SyntaxError; Python kann es nicht als Anweisung lesen.

Führe in deinem Terminal aus:

python -m pip install cowsay

Schreibe danach Folgendes in ein Python-Programm:

import cowsay

cowsay.cow("Hello, Ada")

Das Programm gibt eine Kuh aus Textzeichen neben einer Sprechblase mit der Nachricht aus. Die Installation macht das Paket verfügbar; der Import erzeugt die Bindung des Programms an das Paket.

pip auf deinen Interpreter abstimmen

Die Form -m pip weist das angegebene Python an, sein eigenes pip auszuführen. Verwende den Befehl, mit dem du deine Programme startest: unter macOS oder Linux häufig python3, unter Windows py.

python3 -m pip install cowsay
python3 game.py

Beide Zeilen wählen denselben Python-Befehl. Meldet eine Installation Erfolg, aber ein Skript löst weiterhin ModuleNotFoundError aus, vergleiche das zur Installation verwendete Python mit dem, das das Skript ausführt. Ein Editor kann einen anderen Interpreter ausgewählt haben als dein Terminal. Verwende das pip des ausgewählten Interpreters, bevor du den Import änderst.

Eine Installation untersuchen und pflegen

Eine genaue Versionsangabe ist nützlich, wenn du das Verhalten genau dieser Version brauchst. Mit show kannst du prüfen, an welchem Ort pip tatsächlich etwas geändert hat.

Den Namen in der Dokumentation prüfen

Der für pip eingegebene Distributionsname kann sich vom Importnamen unterscheiden. Installiere beautifulsoup4 und verwende dann import bs4; installiere Pillow und verwende dann import PIL. Wiederholt einen Importnamen zu installieren, ist keine sinnvolle Lösung, wenn die Dokumentation eine anders benannte Distribution angibt.

Pythons Standardbibliothek, einschließlich math, random und unittest, wird bereits mit Python geliefert. Diese Module müssen nicht mit pip installiert werden.

Eine verwaltete Installation beachten

Einige Betriebssysteme und Paketverwaltungen schützen ihr Python mit einem externally-managed-environment-Fehler. Das bedeutet, dass eine direkte Installation gesperrt ist, damit die verwaltete Installation konsistent bleibt. Verwende eine virtuelle Umgebung, also einen eigenen Python- und Paketordner für das Projekt. Erzwinge die Installation nicht mit sudo pip install.

Jeder kann auf PyPI veröffentlichen. Prüfe vor der Installation die genaue Schreibweise und lies die Projektseite und die Dokumentation. Ähnlich aussehende Namen können Versuche von Typosquatting sein. Bevorzuge etablierte, gepflegte Pakete und installiere die, die dein Programm tatsächlich braucht.

Ein Traceback zeigt dir, welche Aufrufe aktiv waren, als eine unbehandelte Ausnahme das Programm stoppte. Er gibt dir sowohl einen Ausgangspunkt für das Lesen als auch einen Weg zurück zu dem Wert, der den Fehler verursacht hat.

Mit der letzten Zeile beginnen

Betrachte dieses vollständige Programm in scores.py:

def average(values):
    return sum(values) / len(values)

def report(scores):
    avg = average(scores)
    print(f"Average: {avg:.1f}")

report([])

Die letzte Zeile seines Fehlerberichts lautet ZeroDivisionError: division by zero. Sie nennt den Ausnahmetyp und beschreibt die fehlgeschlagene Operation. Beginne dort und lies dann nach oben bis zur Codestelle direkt darüber.

Ein vereinfachter Traceback ohne Markierungen der Ausdrücke lautet:

Traceback (most recent call last):
  File "scores.py", line 8, in <module>
    report([])
  File "scores.py", line 5, in report
    avg = average(scores)
  File "scores.py", line 2, in average
    return sum(values) / len(values)
ZeroDivisionError: division by zero

Jeden Aufrufrahmen als aktiven Aufruf lesen

Ein Aufrufrahmen nennt Datei, Zeilennummer und Funktion, gefolgt vom relevanten Code. in <module> bezeichnet Code auf Modulebene. Der älteste Aufruf steht oben, der neueste unten. Liest du von unten, kehrst du diese Reihenfolge um: So kannst du zuerst fragen, was fehlgeschlagen ist, und danach, wie die Ausführung dorthin gelangt ist.

1. Zeile 2 dividiert durch len(values). Damit dieser Divisor null ist, muss values leer sein.
2. Zeile 5 ruft average(scores) auf, untersuche also die von report übergebenen Werte scores.
3. Zeile 8 übergibt [], die leere Liste. Das erklärt, wie der Divisor null in die Berechnung gelangt ist.

Die fehlerauslösende Zeile und die Ursache hängen zusammen, können aber an unterschiedlichen Stellen liegen. Die Division zu ersetzen, ohne zu entscheiden, was eine leere Liste bedeuten soll, würde die Frage nach dem gewünschten Verhalten verdecken. Entweder muss der aufrufende Code eine leere Liste vermeiden oder das Verhalten der Funktion bei leerer Eingabe muss festgelegt werden.

Hervorhebungen nutzen, ohne von ihrer genauen Form abzuhängen

Python 3.11 und spätere Versionen können die Markierungen ^ und ~ ergänzen, um den fehlerauslösenden Teil eines Ausdrucks zu zeigen. Sie helfen, wenn eine Zeile mehrere Operationen enthält. Die genaue Hervorhebung variiert zwischen Versionen, doch die Aufrufstellen und die Ausnahmemeldung geben weiterhin die Lesereihenfolge vor.

Ein Traceback kann Aufrufrahmen aus der Standardbibliothek oder einem installierten Paket enthalten. Finde den untersten Aufrufrahmen in deinem eigenen Code und untersuche die dort übergebenen Argumente. Ein Aufrufrahmen einer Bibliothek gibt einen Hinweis auf die Stelle; er belegt nicht, dass die Bibliothek den Programmfehler enthält.

Eine Syntaxfehlermeldung erkennen

Ein Syntaxfehler im gestarteten Skript verhindert dessen Ausführung. Python meldet eine Datei, eine Zeile, eine Markierung und eine Meldung ohne die übliche Traceback-Kopfzeile. Zum Beispiel fehlt bei if True der Doppelpunkt; bei total = sum([1, 2, 3] bleibt eine Klammer offen.

Die markierte Stelle zeigt, wo Python bemerkt hat, dass es den Code nicht analysieren kann. Sieht diese Zeile gültig aus, prüfe die vorhergehende Zeile auf ein nicht geschlossenes Anführungszeichen oder eine offene Klammer. Wenn das gestartete Skript nicht ausgeführt wurde, gibt es keine Kette von Laufzeitaufrufen, die du verfolgen könntest.

Ein gewöhnlicher Programmlauf stoppt bei seiner ersten unbehandelten Ausnahme. Behebe dieses Problem und führe das Programm erneut aus, um später auftretende Probleme sichtbar zu machen.

Der Name eines Fehlers grenzt die Suche ein, und seine Meldung liefert Details zu den beteiligten Werten. Ein Programm kann auch falsch sein, ohne eine Ausnahme auszulösen. Deshalb gehört es weiterhin zur Fehlersuche, die erwartete Ausgabe zu überprüfen.

Drei Arten von Problemen unterscheiden

IndentationError ist eine Art von SyntaxError. Ein Funktionskörper muss eingerückt sein; ein fehlender eingerückter Block stoppt den Code vor der Ausführung. Prüfe auch auf nicht geschlossene Anführungszeichen oder Klammern und falsch geschriebene Schlüsselwörter.

Namen und Datentypen genau lesen

Ein NameError bedeutet, dass das Programm einen Namen an dieser Stelle nicht kennt. In prnt("hi") ist die eingebaute Funktion print gemeint. Ein Name kann auch vor der Zuweisung verwendet worden sein oder ein Import kann fehlen.

Ein TypeError bedeutet, dass eine Operation einen ungeeigneten Datentyp oder ein Aufruf die falsche Anzahl von Argumenten erhalten hat. "Age: " + 30 mischt eine Zeichenkette und eine ganze Zahl. Schreibe "Age: " + str(30) oder f"Age: {30}". Benötigt area die Argumente w und h, ist auch area(3) ein TypeError, diesmal wegen eines fehlenden Arguments.

Die Meldung unterscheidet diese Ursachen. In can only concatenate str (not "int") to str nennt Python die Datentypen, die aufeinandergetroffen sind. Nach age = input("Age: ") ist age Text. age + 1 schlägt fehl; bei einer ganzzahligen Eingabe führt int(age) + 1 eine Rechnung aus.

Ein ValueError bedeutet, dass der Datentyp der Eingabe akzeptiert wird, ihr Wert aber ungeeignet ist. int("12.5") erhält eine Zeichenkette, also einen akzeptierten Eingabetyp, aber der Text stellt keine ganze Zahl in der erforderlichen Form dar. math.sqrt(-1) enthält einen weiteren ungeeigneten Wert für eine Berechnung mit reellen Zahlen.

Positionen, Schlüssel und Attribute prüfen

Divisoren mit dem Wert null führen auch bei // und % zu Fehlern. Eine fehlende Listenposition und ein fehlender Wörterbuchschlüssel betreffen unterschiedliche Zugriffe, auch wenn in beiden Fällen etwas Fehlendes angefordert wird.

Ein plausibel aussehendes Ergebnis prüfen

def total_price(prices):
    total = 0
    for i in range(1, len(prices)):
        total += prices[i]
    return total

Für [4, 6, 10] gibt dies 16 statt 20 zurück. Es gibt keine Ausnahme: Die Indizes 1 und 2 existieren, also ist jede Operation zulässig. Die Schleife beginnt zu spät und überspringt Index 0. Der Fehler wird sichtbar, wenn du die Ausgabe mit der beabsichtigten Summe vergleichst.

Schlage bei einer unbekannten Ausnahme ihren Typ und die allgemeine Meldung in der offiziellen Python-Dokumentation nach. Entferne deine eigenen Pfade und Eingabewerte aus einer Suchanfrage; sie erklären selten die allgemeine Regel.

Ein Programmfehler ist ein Unterschied zwischen beabsichtigtem und tatsächlichem Verhalten. Bei der Fehlersuche und Fehlerbehebung findest und behebst du die Ursache. Eine hilfreiche Fehlersuche macht aus einer Beobachtung eine überprüfbare Erklärung und ändert den Code anschließend aufgrund von Belegen.

Den Fehler wiederholt auslösen

Halte eine konkrete Eingabe und das Ergebnis fest, das sie erzeugt. Verwende für die Preisfunktion, die ihre Schleife bei Index 1 beginnt, [4, 6, 10]. Die erwartete Summe ist 20; die tatsächliche Summe ist 16. Anhand dieser konkreten Werte kannst du prüfen, ob sich jede Untersuchung noch auf denselben Fehler bezieht.

Die Differenz beträgt 4 und das tatsächliche Ergebnis ist gleich 6 + 10. Eine konkrete Hypothese lautet, dass der erste Preis übersprungen wird. Diese Hypothese sagt etwas voraus, das du überprüfen kannst: Die Schleife wird Index 0 nie besuchen.

Sechs Schritte befolgen

1. Reproduzieren: Finde eine Eingabe, die den Fehler zuverlässig zeigt.
2. Erwartetes und tatsächliches Ergebnis nennen: Berechne das erwartete Ergebnis unabhängig.
3. Eine Hypothese aufstellen: Nenne eine mögliche Ursache und das daraus erwartete Verhalten.
4. Sie prüfen: Untersuche Werte mit Ausgaben, einer Ablauftabelle oder einem Debugger.
5. Die Ursache beheben: Nimm eine gezielte Änderung vor.
6. Erneut testen: Führe die fehlschlagende Eingabe und zuvor funktionierende Fälle aus.

Gib den Index innerhalb der Schleife aus. Für diese Eingabe sind die einzigen Indizes 1 und 2, was die Vorhersage bestätigt. Wenn range bei 0 beginnt, wird das übersprungene Element berücksichtigt. Durchläufst du die Preise direkt, musst du keinen Index verwalten:

def total_price(prices):
    total = 0
    for price in prices:
        total += price
    return total

Die korrigierte Funktion gibt 20 für [4, 6, 10], 5 für [5] und 0 für [] zurück. Der Fall mit einem Element ist nützlich, weil die fehlerhafte Schleife dafür zuvor 0 zurückgab.

Zu jedem Ergebnis 4 zu addieren würde die beobachtete Summe korrigieren, aber die Ursache bestehen lassen. Für [5] würde diese Behelfslösung 4 zurückgeben; der fehlende Betrag hängt von der Eingabe ab. Prüfe, ob eine vorgeschlagene Korrektur alle Belege erklärt, bevor du sie beibehältst.

Eine größere Suche eingrenzen

Bei Teile und herrsche prüfst du an einer Stelle während der Ausführung die Werte, von denen das falsche Ergebnis abhängt. Ist ein benötigter Wert bereits falsch, untersuche den früheren Code, der ihn erzeugt hat. Sind die benötigten Werte noch richtig, verfolge ihre spätere Verarbeitung. Wiederhole das innerhalb des verbleibenden Abschnitts.

Du kannst auch eine Funktion einzeln aufrufen oder vorübergehend nicht zugehörigen Code entfernen. Ein minimales reproduzierbares Beispiel enthält den kürzesten Code und die kleinste Eingabe, die noch fehlschlagen. Trat ein Problem zuerst bei Hunderten von Datensätzen auf, erleichtert es jede Untersuchung, einen oder zwei auslösende Datensätze zu finden.

Prüfen, was die Daten tatsächlich sind

Eine angezeigte 5 kann die Zeichenkette "5" sein. "5" + "3" ergibt "53", während die Addition von Zahlen 8 ergibt. Untersuche type(value), um den Datentyp zu prüfen. Verwende repr(value), um Leerzeichen und Zeilenumbruchzeichen sichtbar zu machen, die eine gewöhnliche Ausgabe verbergen kann, wie in ' Ada'.

Erkläre den Code laut, Zeile für Zeile, einschließlich der Frage, was jede Schleife tatsächlich durchläuft und was jede Funktion zurückgibt. Das ist Fehlersuche mit einer Gummiente: Einen Schritt zu erklären, deckt oft die Lücke zwischen der beabsichtigten und der geschriebenen Operation auf.

Ändere jeweils nur eine Ursache, damit du das Ergebnis mit der Änderung in Verbindung bringen kannst. Teste sowohl die zuvor funktionierenden Fälle als auch den fehlgeschlagenen Fall erneut.

Die endgültige Antwort eines Programms verbirgt den Weg, auf dem sie entstanden ist. Vorübergehende Ausgaben, eine Ablauftabelle und ein Debugger lassen dich diesen Weg sehen und eine konkrete Hypothese dazu prüfen, wo etwas schiefgeht.

Einen Wert zu einem bekannten Zeitpunkt ausgeben

Beschrifte diagnostische Ausgaben, damit die Bedeutung einer Zahl klar ist. Python 3.8 und spätere Versionen unterstützen diese f-String-Form:

print(f"{i=} {total=}")

Setze sie bei der fehlerhaften Preisschleife unmittelbar vor total += prices[i]. Mit den Preisen [4, 6, 10] gibt sie aus:

i=1 total=0
i=2 total=6

Dies sind die Summen vor jeder Addition. Nach der ersten Ausgabe addiert die Schleife 6; nach der zweiten addiert sie 10. Eine Ausgabe nach der Addition würde andere Summen zeigen. Entscheide vor der Deutung der Ausgabe, welcher Zeitpunkt deine Frage beantwortet.

Denselben Code von Hand nachvollziehen

Eine Ablauftabelle hält Variablen Schritt für Schritt fest. Für diese Schleife:

Es gibt keinen Schleifendurchlauf für Index 0. Folge den tatsächlich im Code angegebenen Start- und Endwerten, auch wenn du bereits weißt, was die Schleife tun sollte. Eine Tabelle hilft, deine Erwartung vom tatsächlichen Geschehen zu unterscheiden.

An einem Haltepunkt pausieren

Ein Debugger hält ein laufendes Programm an, damit du seinen aktuellen Zustand untersuchen kannst. Ein Haltepunkt markiert eine Stelle, an der pausiert werden soll. Klicke in Editoren wie Thonny und VS Code neben eine Zeilennummer und starte den Debug-Modus; klicke in IDLE mit der rechten Maustaste auf die Zeile und wähle Set Breakpoint.

Wähle nach dem Anhalten einen Schritt passend zu der Frage, die du untersuchst:

Übergibt der aufrufende Code korrekte Argumente, erhält aber eine falsche Antwort, steige in die Funktion ein. Musst du nur das zurückgegebene Ergebnis sehen, führe den Aufruf als Prozedurschritt aus. Untersuche die Werte vor und nach der Zeile, die den Fehler erzeugen könnte.

Pythons textbasierten Debugger verwenden

Füge breakpoint() unmittelbar vor dem Code ein, den du untersuchen möchtest. Bei der Standardkonfiguration des Debuggers startet die Ausführung des Programms an dieser Stelle pdb. Gib diese Befehle an seiner Eingabeaufforderung (Pdb) ein:

• p total zeigt total an.
• n führt die nächste Zeile als Prozedurschritt aus.
• s steigt in einen Funktionsaufruf ein.
• c setzt die Ausführung fort.
• q beendet die Fehlersuche.

Das sind Debugger-Befehle, keine Zeilen zum Kopieren in dein Programm.

Ausgegebene Werte von Rückgabewerten unterscheiden

Eine Funktion kann die richtige Zahl ausgeben und dennoch None zurückgeben, weil ihr return total fehlt. Untersuche den Wert, den der aufrufende Code erhält, wenn der Fehler nach dem Funktionsaufruf auftritt. Eine korrekte Ausgabe innerhalb der Funktion belegt nicht, dass der aufrufende Code diese Zahl erhalten hat.

Verwende Ausgaben für schnelle Hinweise über mehrere Schleifendurchläufe hinweg und den Debugger, um einen bestimmten Zeitpunkt zu untersuchen. Entferne nach der Fehlerbehebung vorübergehende Ausgaben und breakpoint()-Aufrufe, damit das fertige Programm normal läuft.

Eine Zusicherung hält etwas fest, das wahr sein muss, wenn dein Code korrekt funktioniert. Sie kann einen Programmfehler nahe an seiner Entstehungsstelle stoppen oder das Ergebnis einer Funktion mit dem erwarteten Wert vergleichen.

Eine Bedingung und eine optionale Meldung schreiben

assert letter_grade(90) == "A", "90 should be an A"

Python wertet die Bedingung aus. Gibt letter_grade(90) den Wert "A" zurück, ist die Bedingung wahr und die Ausführung läuft ohne Ausgabe weiter. Gibt die Funktion "B" zurück, löst Python AssertionError mit der Meldung 90 should be an A aus. Der Traceback zeigt auf die fehlgeschlagene Prüfung.

Auch ohne die Meldung prüft assert letter_grade(90) == "A" das Ergebnis. Die letzte Ausnahmezeile enthält AssertionError, während der Traceback den Ausdruck zeigt. Eine hilfreiche Meldung nennt die Erwartung, die nicht erfüllt wurde; sie sollte dir helfen, die geprüfte Regel zu finden.

Einen internen Fehler früh stoppen

Angenommen, eine interne Berechnung benötigt eine nicht leere Liste:

def average(values):
    assert len(values) > 0, "values must not be empty"
    return sum(values) / len(values)

Eine leere Liste löst nun vor der Division die Zusicherung aus. Die Prüfung dokumentiert die interne Annahme der Funktion und zeigt direkt auf deren Verletzung. Sie gibt einer leeren Liste weder ein arithmetisches Mittel noch entscheidet sie, wie eine Anwendung auf fehlende Benutzerdaten reagieren soll.

Die Eingabevalidierung aktiv halten

Pythons Option -O entfernt assert-Anweisungen. Ein Programm, das sich beim Zurückweisen externer Eingaben auf eine Zusicherung verlässt, kann sich daher bei optimierter Ausführung anders verhalten. Prüfe Benutzereingaben und andere externe Daten mit gewöhnlicher Ablaufsteuerung:

def require_score(score):
    if score < 0 or score > 100:
        raise ValueError("score must be 0 to 100")
    return score

Hier meldet raise ValueError(...) einen ungeeigneten Wert. Die if-Anweisung wird auch mit -O ausgeführt. Wähle eine Zusicherung für eine interne Annahme über das Programm und eine aktive Eingabeprüfung für Daten, die von außen fehlerhaft eingegeben werden können.

Eine Prüfung vermeiden, die nie fehlschlagen kann

assert ist eine Anweisung, keine Funktion. Schreibe die Bedingung und die Meldung durch ein Komma getrennt:

assert x > 10, "x too small"

assert (x > 10, "x too small") erzeugt ein Tupel mit zwei Elementen. Ein nicht leeres Tupel ist auch dann wahr, wenn sein erstes Element False ist, sodass die Zusicherung besteht. Python kann davor warnen, dass diese Zusicherung immer wahr ist. Klammern um die Bedingung allein, wie in assert (x > 10), erzeugen dieses Tupel nicht; das Komma innerhalb der Klammern ist das Problem.

Verwende == für den Vergleich. assert total = 20 ist ungültige Syntax, weil = einen Wert zuweist.

Zahlen mit der beabsichtigten Genauigkeit vergleichen

Verwende für eine berechnete Gleitkommazahl eine Prüfung auf annähernde Gleichheit:

import math

assert math.isclose(0.1 + 0.2, 0.3)

Ein exakter Vergleich schlägt hier fehl, weil sich die gespeicherte Gleitkommasumme geringfügig von 0.3 unterscheidet. Ein einfacher automatisierter Test wendet dieselbe Idee einer Zusicherung auf eine Funktion an: assert total_price([4, 6, 10]) == 20. Der erwartete Wert ergibt sich aus der Regel der Funktion, sodass die Prüfung eine falsche Implementierung aufdecken kann.

Ein Unit-Test prüft eine kleine Codeeinheit, meist eine Funktion, mit einer gewählten Eingabe und einem erwarteten Ergebnis. Automatisierte Tests machen es leicht, dieselben Prüfungen nach Änderungen zu wiederholen. So helfen sie, erneut auftretende Fehler in zuvor funktionierendem Verhalten zu erkennen.

Mit der Spezifikation beginnen

Angenommen, eine Bewertungsfunktion muss für Punktzahlen ab 90 "A", für Punktzahlen ab 80 bis unter 90 "B" und unter 80 "C" zurückgeben. Die fehlerhafte erste Bedingung lautet score > 90.

Tests sollten mehrere Aufgaben erfüllen:

• Typische Fälle prüfen gewöhnliche Eingaben innerhalb jedes Bereichs, etwa 95 und 85.
• Grenzwertfälle prüfen die Werte, an denen eine Regel wechselt, etwa 90 und 89 oder 80 und 79.
• Randfälle prüfen Eingaben wie null oder eine leere Sammlung, wenn die Regeln der Funktion diese zulassen.

Ermittle die erwartete Antwort anhand dieser Regeln. Übernimmst du die aktuelle Antwort des Programms in einen Test, kann dessen Fehler erhalten bleiben.

Die Tests neben das Modul legen

Speichere die Tests in test_grade.py und die Funktion in grade.py. Der Anwendungsstart in grade.py gehört unter den __main__-Schutz, damit der Import der Funktion das Programm nicht startet.

from grade import letter_grade

def test_letter_grade():
    assert letter_grade(95) == "A"
    assert letter_grade(90) == "A"
    assert letter_grade(85) == "B"

Bei der fehlerhaften Regel besteht die erste Zusicherung. Die zweite schlägt fehl, weil 90 nicht größer als 90 ist; die Ausführung stoppt dort, vor der dritten Zusicherung in dieser Funktion. Die Änderung der ersten Bedingung zu score >= 90 korrigiert diesen Grenzfall. Führe alle Tests erneut aus, um den betroffenen Fall und das frühere Verhalten zu prüfen.

Sicherstellen, dass die Tests tatsächlich laufen

Eine Testfunktion zu definieren, ruft sie nicht auf. Wenn du kein Testwerkzeug zum Ausführen verwendest, ergänze test_letter_grade() am Ende der Testdatei und führe dann python test_grade.py aus. Um pytest zu verwenden, installiere es mit python -m pip install pytest und führe dann pytest test_grade.py im Terminal aus. Es findet die Testfunktionen und meldet ihre Ergebnisse. Verzichte auf manuelle Aufrufe, wenn ein Testwerkzeug die Ausführung übernimmt.

Ein Test, der lediglich letter_grade(90) aufruft, enthält keinen Vergleich. Er kann erfolgreich enden, obwohl die zurückgegebene Antwort falsch ist; er schlägt nur fehl, wenn der Aufruf eine unerwartete Ausnahme auslöst. Eine Zusicherung verbindet den Aufruf mit dem geforderten Verhalten.

Rückgabewerte und Eigenschaften zufälliger Ergebnisse testen

Eine Funktion, die eine Summe nur ausgibt, gibt None zurück. Ein Vergleich wie assert print_total([4, 6]) == 10 schlägt daher auch dann fehl, wenn auf dem Bildschirm 10 erscheint. Lass die Berechnung ihr Ergebnis zurückgeben und überlasse main die Ausgabe.

Zufällige Ergebnisse brauchen eine andere Erwartung. Von einer Würfelfunktion ohne festgelegten Startwert kann nicht verlangt werden, bei jedem Aufruf genau dieselbe Augenzahl zurückzugeben. Prüfe, ob jeder von 100 Aufrufen einen zulässigen Wert von 1 bis einschließlich 6 zurückgibt, oder lege vor einer reproduzierbaren Folge einen Startwert fest. Besteht der Test der Schranken, sind die Schranken für diese Aufrufe geprüft; er belegt nicht, dass jede Augenzahl gleich wahrscheinlich ist.

Wenn ein neuer Programmfehler auftritt, ergänze vor der Korrektur der Funktion einen Test, der wegen dieses Fehlers fehlschlägt. Behalte diesen Regressionstest, damit spätere Änderungen dasselbe Verhalten erneut prüfen. Bestandene Tests zeigen, was bei den getesteten Fällen geschah; weitere Eingaben können dennoch einen anderen Fehler aufdecken.

Python enthält unittest, ein Testframework, das Tests findet, ausführt und einzelne Ergebnisse meldet. Es muss nicht mit pip installiert werden. Seine Klassenstruktur kannst du als Vorlage verwenden, während du das Testen von Funktionen lernst.

Unabhängige Testmethoden schreiben

Schreibe für eine Funktion in grade.py Folgendes in test_grade.py:

import unittest
from grade import letter_grade

class TestLetterGrade(unittest.TestCase):
    def test_top(self):
        self.assertEqual(letter_grade(95), "A")

    def test_boundary(self):
        self.assertEqual(letter_grade(90), "A")

    def test_low(self):
        self.assertEqual(letter_grade(50), "C")

if __name__ == "__main__":
    unittest.main()

TestLetterGrade erbt die Testwerkzeuge von unittest.TestCase. Jeder Test ist eine Methode, deren Name mit test beginnt. self bezeichnet das aktuelle Testobjekt; belasse es in der Parameterliste jeder Methode und vor Aufrufen von Zusicherungsmethoden. Du kannst diese Struktur kopieren, ohne eigene Klassen zu entwerfen.

Tests laufen standardmäßig in alphabetischer Reihenfolge ihrer Methodennamen, also kommt test_boundary vor test_low und test_top. Sorge dafür, dass jeder Test seine benötigte Eingabe selbst bereitstellt und unabhängig von vorherigen Tests funktioniert.

Eine Zusicherungsmethode auswählen

Bevorzuge beim Vergleich von Werten assertEqual(a, b) gegenüber assertTrue(a == b): Der Bericht über einen Fehlschlag zeigt die beiden Werte. Die unittest-Methoden behalten ihre Prüfungen auch bei, wenn Python mit -O läuft.

Um eine erwartete Ausnahme zu prüfen, setze den Aufruf in assertRaises:

def test_score_too_high(self):
    with self.assertRaises(ValueError):
        letter_grade(120)

Dieser Test setzt voraus, dass die Regel der Funktion diese Punktzahl mit ValueError zurückweist. Eine Rückgabe ohne Ausnahme lässt die Prüfung fehlschlagen; eine andere Ausnahme als ein Zusicherungsfehler ist ein Testfehler.

Den Bericht ausführen und lesen

Führe python test_grade.py aus, um das geschützte unittest.main() der Datei auszuführen. Oder führe python -m unittest aus, um test*.py-Dateien im aktuellen Ordner zu finden. python -m unittest -v gibt einzelne Testnamen und ihre Ergebnisse aus.

Im Kurzbericht bedeutet . bestanden, F bedeutet, dass eine Zusicherung fehlgeschlagen ist, und E bedeutet, dass eine andere Ausnahme aufgetreten ist. Bei einer Bewertungsfunktion mit score > 90 erzeugen die drei obigen Tests F... Der Bericht zum fehlgeschlagenen Test test_boundary zeigt 'B' != 'A': Das tatsächliche Ergebnis ist "B", während das erwartete Ergebnis "A" ist. Die Zusammenfassung meldet drei Tests und einen fehlgeschlagenen Test.

Prüfe vor einer Änderung der Funktion die Erwartung des Tests anhand der Bewertungsregeln. Eine falsche Erwartung erfordert eine Korrektur des Tests. Laufen keine Tests, prüfe die Methodennamen, den Schutz für die direkte Ausführung und den Startbefehl. Vermeide außerdem, deine Datei unittest.py zu nennen, da sie das Standardmodul verdeckt.