Zurück zum Lernbereich

Wenn Code bricht

Eine Anleitung für den Moment, in dem das Programm nicht das tut, was du wolltest — also fast immer.

  • Grundlagen
  • 13 min
  • Einsteiger

Einfache Sprache

Diese Vorschau ist in Einfacher Sprache. Das ganze Portal gibt es auch in Einfacher Sprache. Du kannst oben die Sprache wechseln. Oder nutze den Knopf unten. Unsere Texte in Einfacher Sprache entstehen KI-gestützt und werden redaktionell begleitet. Sie orientieren sich an den Grundprinzipien der Leichten Sprache, sind aber keine geprüfte Leichte Sprache: Eine Prüfgruppe von Menschen mit Lernschwierigkeiten prüft sie nicht.

Vorschau: Fehler im Code finden

Drei Arten von Fehlern

Es gibt drei Arten von Fehlern.
Der Code hat einen Schreibfehler. Python startet nicht. Das heißt Syntaxfehler. Python stürzt ab. Das heißt Laufzeitfehler. Das Ergebnis ist falsch. Das heißt Logikfehler.

Fehlermeldungen lesen

Wenn Python abstürzt, gibt es eine Fehlermeldung. Das heißt Traceback. Traceback bedeutet: ein Bericht über den Fehler. Du liest ihn von unten nach oben. Unten steht: was ist passiert? Darüber: wo im Code ist es passiert?

Fehler abfangen

Du kannst Fehler abfangen. Das heißt Fehlerbehandlung. try/except ist eine Technik dafür. try bedeutet: dieser Teil könnte abstürzen. except bedeutet: dann passiert dies stattdessen. Das Programm läuft weiter.

In dem Moment, in dem dein Code zum ersten Mal eine Wand aus rotem Text erzeugt, ist dein erster Instinkt: Panik. Aber dieser rote Text, der Traceback, ist eigentlich das Hilfreichste, was Python dir geben kann. Er sagt dir genau, was schiefgelaufen ist, und genau wo.

Die echte Gefahr lauert nicht, wenn Python dich anschreit, sondern wenn Python schweigt und deine Ergebnisse leise, unauffällig falsch sind. Dieser Artikel bringt dir bei, Python-Fehler in drei Typen einzuteilen, Tracebacks wie ein Detektiv zu lesen und Sicherheitsnetze zu schreiben, die dein Programm am Laufen halten.

Drei Arten von Fehlern

Definition

Fehlerarten in Python

Analogie

Stell dir ein Kochrezept vor. Ein Syntaxfehler ist ein Rezept mit einem Wort, das der Koch nicht lesen kann: "Gib 200g Sltz hinzu." Der Koch hört sofort auf, die Anweisung ist unverständlich. Ein Laufzeitfehler ist eine Anweisung, die klar klingt, aber in der Praxis scheitert: "Teile den Teig in Portionen basierend auf der Anzahl der Eier." Bei null Eiern steckt der Koch fest, Division durch Null. Ein Logikfehler ist ein Rezept, das perfekt lesbar und ausführbar ist, aber falsch: "Gib 200 Kilogramm Salz hinzu." Der Koch folgt der Anweisung, und das Ergebnis ist ungenießbar, aber niemand hat dem Koch gesagt, dass etwas nicht stimmt.

Die Rezept-Analogie bricht an zwei Stellen: Ein echter Koch würde "200 Kilogramm Salz" hinterfragen, er hat gesunden Menschenverstand. Python hat keinen Menschenverstand und führt jede syntaktisch gültige Anweisung aus. Außerdem kann ein Koch das Ergebnis probieren, Code dagegen braucht systematische Tests.

Syntaxfehler Stoppt vor der Ausführung. Fehlende Klammern, Doppelpunkte, falsche Einrückung.
Laufzeitfehler Stürzt während der Ausführung ab. Erzeugt einen Traceback mit Fehlermeldung.
Logikfehler Läuft ohne Warnung durch. Liefert falsche Ergebnisse. Am gefährlichsten.

Merke

Drei Fehler, ein Programm

Der gleiche Temperaturrechner kann auf alle drei Arten scheitern:

# Syntaxfehler: fehlende Klammer
celsius = ((fahrenheit - 32) * 5 / 9
# SyntaxError: Python weigert sich zu starten

Python kann den Code gar nicht ausführen, die Klammer fehlt.

# Laufzeitfehler: Nutzer gibt Text statt Zahl ein
eingabe = input("Temperatur: ")
celsius = (int(eingabe) - 32) * 5 / 9
# ValueError wenn Nutzer "warm" statt einer Zahl tippt

Der Code ist syntaktisch korrekt, stürzt aber ab, wenn die Eingabe keine Zahl ist.

# Logikfehler: + statt - (läuft, aber falsche Ergebnisse)
celsius = (fahrenheit + 32) * 5 / 9
# Kein Fehler, kein Absturz, aber das Ergebnis ist falsch!

Python beschwert sich nicht, weil der Code syntaktisch korrekt und ausführbar ist. Aber die Formel ist falsch (+ statt -), und die Ergebnisse stimmen nicht.

Achtung

Kein Fehler heißt nicht kein Problem

Der gefährlichste Irrglaube: "Mein Code läuft ohne Fehlermeldung, also ist er korrekt." Logikfehler erzeugen keine Meldung. Dein Code läuft durch und liefert Ergebnisse, nur sind die Ergebnisse falsch. Der einzige Schutz: Teste mit bekannten Eingaben und prüfe, ob die erwarteten Ergebnisse herauskommen.

Den Traceback lesen: Deine Fehlerkarte

Definition

Traceback

Analogie

Ein Traceback ist wie ein Unfallbericht. Ganz unten steht der Unfall selbst: "Fahrzeug ist an Kreuzung X gegen eine Mauer gefahren" (Fehlertyp und Meldung). Der Abschnitt darüber beschreibt die unmittelbaren Umstände: "Fahrzeug fuhr mit 80 km/h auf der Hauptstraße, Zeile 47" (die fehlerhafte Codezeile). Die Abschnitte weiter oben zeichnen die Route nach: "Fahrzeug verließ das Parkhaus um 8:00 Uhr, bog auf die Autobahn ab" (die Kette der Funktionsaufrufe).

Die Analogie bricht an einer wichtigen Stelle: Einen echten Unfallbericht liest man von oben nach unten, das Wichtigste steht vorn. Pythons Traceback zeigt das Wichtigste, den neuesten Aufruf, ganz unten ("most recent call last"). Deshalb muss man lernen, von unten nach oben zu lesen.

Merke

Traceback lesen: 4 Schritte

  1. 1. Lies die letzte Zeile: Fehlertyp und Fehlermeldungz.B. ValueError: invalid literal
  2. 2. Lies die Zeile darüber: Welche Codezeile hat den Fehler ausgelöst?
  3. 3. Gehe die Aufrufkette nach oben: Welche Funktion hat welche aufgerufen?
  4. 4. Finde die Ursache: Welche Funktion hat den problematischen Wert übergeben?

Merke

Ein Traceback in der Praxis

def get_age():
    return int(input("Dein Alter: "))    # Nutzer tippt "zwanzig"

def greet_user():
    alter = get_age()
    print(f"Du bist {alter} Jahre alt.")

greet_user()
Traceback (most recent call last):
  File "app.py", line 8, in <module>       # 3. Programm startete hier
    greet_user()
  File "app.py", line 5, in greet_user     # 2. greet_user rief get_age auf
    alter = get_age()
  File "app.py", line 2, in get_age        # 1. get_age stürzte HIER ab
    return int(input("Dein Alter: "))
ValueError: invalid literal for int() with base 10: 'zwanzig'

Lies von unten: ValueError sagt dir den Fehlertyp. Die Zeile darüber zeigt, dass int(input(...)) in get_age() abgestürzt ist. Die Zeilen darüber zeigen den Weg: greet_user() hat get_age() aufgerufen, und das Hauptprogramm hat greet_user() aufgerufen. Neuere Python-Versionen (ab 3.11) setzen unter manche Codezeilen zusätzlich Zeichen wie ^^^^ oder ~~~^^, die genau auf den fehlerhaften Ausdruck zeigen; die betroffene Codezeile steht dann eine Zeile höher.

Achtung

Nicht einfach drauflos ändern

Ein häufiger Fehler: Den Traceback ignorieren und den Code auf gut Glück ändern. Der Traceback sagt dir genau, wo und was schiefgelaufen ist. Lies ihn von unten nach oben, und du sparst dir stundenlanges Raten.

Fehlerbehandlung: Sicherheitsnetze schreiben

Definition

Exception Handling (try/except)

Analogie

Stell dir einen Fallschirmspringer vor. Der Sprung selbst ist der try-Block, der normale Programmablauf. Wenn der Hauptfallschirm nicht öffnet (ein Fehler auftritt), zieht der Springer den Reservefallschirm, der except-Block fängt das spezifische Problem ab. Der finally-Block ist die Landung: Sie passiert unabhängig davon, welcher Fallschirm benutzt wurde, und umfasst Aufräumarbeiten.

Die Analogie bricht, weil ein Springer nur einen Reservefallschirm hat, Python aber mehrere except-Blöcke für verschiedene Fehlertypen erlaubt, wie separate Reserveschirme für verschiedene Ausfallarten.

Merke

Der try/except-Ablauf

  1. 1. try-Block wird ausgeführt: der "riskante" Code läuft normal
  2. 2. Exception tritt auf: Python sucht einen passenden except-Block
  3. 3. except-Block reagiert: Fehlermeldung anzeigen, erneut versuchen oder Standardwert verwenden

Merke

Praxis: Robuste Eingabe

def get_number(prompt):
    while True:
        try:
            return float(input(prompt))
        except ValueError:
            print("Das ist keine gültige Zahl. Versuch es nochmal.")

temperatur = get_number("Temperatur in Fahrenheit: ")
celsius = (temperatur - 32) * 5 / 9
print(f"{temperatur}°F = {celsius:.1f}°C")

Die Funktion fragt so lange nach einer Zahl, bis der Nutzer eine gültige eingibt. Der try-Block versucht die Konvertierung, der except-Block fängt den ValueError ab und gibt eine freundliche Meldung aus.

Achtung

except: pass ist gefährlich

Das gefährlichste Muster in Python: except: pass. Es verschluckt alle Fehler, auch echte Bugs wie Tippfehler in Variablennamen, und macht sie unsichtbar.

# GEFÄHRLICH: verschluckt ALLE Fehler
try:
    ergebnis = berechne_preis(artikel)
except:
    pass    # Stille. Kein Fehler sichtbar.

# RICHTIG: nur den erwarteten Fehler fangen
try:
    ergebnis = berechne_preis(artikel)
except ValueError:
    print("Ungültiger Preis, bitte prüfen.")

Ein bare except: pass fängt alles, auch NameError (Tippfehler), TypeError (falsche Argumente) und sogar KeyboardInterrupt (Ctrl+C). Du wirst nie erfahren, dass dein Code einen Bug hat.

ValueError int("hallo") — falscher Wert für den Typ
TypeError "5" + 3 — falscher Typ für die Operation
FileNotFoundError open("missing.csv") — Datei existiert nicht
KeyError data["key"] — Schlüssel im Dictionary nicht vorhanden
IndexError liste[10] bei einer 3-Element-Liste — Index außerhalb des Bereichs
ZeroDivisionError 100 / 0 — Division durch Null

print()-Debugging: Füge print()-Anweisungen ein, um Variablenwerte an verschiedenen Stellen im Code zu überprüfen. So siehst du Schritt für Schritt, wo die Werte von dem abweichen, was du erwartest.

assert-Anweisungen: Schreibe assert ergebnis > 0, "Ergebnis sollte positiv sein" in deinen Code. Wenn die Bedingung nicht erfüllt ist, stürzt Python absichtlich ab und zeigt dir die Stelle. So machst du stille Logikfehler laut.

Rubber-Duck-Debugging: Erkläre deinen Code Zeile für Zeile einem unbelebten Gegenstand (einer Gummiente, einer Tasse, einem Kuscheltier). Der Zwang, jeden Schritt in Worte zu fassen, zwingt dich, über jeden Schritt nachzudenken, und oft entdeckst du dabei den Fehler.

Interaktiv: Was ist mein Fehler?

Beantworte die Fragen im Diagnosebaum, um herauszufinden, welcher Fehlertyp vorliegt und welche Debugging-Strategie am besten hilft. Achte darauf, wie die drei Fehlerarten zu unterschiedlichen Lösungswegen führen.

Merke

Das Wichtigste auf einen Blick

  1. Python-Fehler kommen in drei Arten: Syntaxfehler (Code nicht lesbar, vor der Ausführung abgefangen), Laufzeitfehler (Code stürzt ab, erzeugt einen Traceback) und Logikfehler (Code läuft, aber liefert falsche Ergebnisse, am gefährlichsten weil stumm).
  2. Ein Traceback wird von unten nach oben gelesen: Die letzte Zeile nennt den Fehlertyp, die Zeile darüber zeigt den fehlerhaften Code, die Zeilen darüber zeichnen die Aufrufkette nach.
  3. try/except-Blöcke fangen vorhersehbare Fehler ab und reagieren, statt abzustürzen. Fange immer spezifische Exceptions wie ValueError, niemals bare except:.
  4. except: pass ist das gefährlichste Muster in Python. Es verschluckt alle Fehler, auch echte Bugs, und macht sie unsichtbar und unmöglich zu debuggen.
  5. "Keine Fehlermeldung" heißt nicht "kein Fehler". Logikfehler erzeugen korrekt aussehende Ausgaben, die subtil falsch sind. Teste immer mit bekannten Eingaben und erwarteten Ergebnissen.

Prüfen

Quiz: Debugging

Noch offen

Welcher Fehlertyp läuft ohne Fehlermeldung durch, liefert aber falsche Ergebnisse?

Wähle eine Antwort

Auflösung: 1) C · 2) B · 3) B · 4) B

Prüfen

Checkpoint: Hast du alles verstanden?

Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.

0 von 3 sitzen