Was ist Ausnahmebehandlung?

Ein Programm, das Leute nach ihrem Alter fragt, bekommt früher oder später "twenty" statt 20. Diesen Text umzuwandeln ist ein Laufzeitfehler: int("twenty") wirft ValueError, und ohne Plan dafür hält das Programm an. Ausnahmebehandlung ist dieser Plan. Du markierst den Code, der scheitern könnte, und schreibst den Code, der dann läuft.

answers = ["34", "twenty", "19"]

for text in answers:
    try:
        age = int(text)
        print("Next year you will be", age + 1)
    except ValueError:
        print("Not a number:", text)

print("Done")

Next year you will be 35
Not a number: twenty
Next year you will be 20
Done

Die falsche Antwort wird gemeldet, und die Schleife macht mit der nächsten weiter. Ohne das try hätte das Programm eine Zeile ausgegeben und dann einen Traceback.

Wie Ausnahmebehandlung funktioniert

1. Der Code in try läuft ganz normal.
2. Eine Operation scheitert, und die Laufzeitumgebung wirft eine Ausnahme: ein Objekt mit einem Typ (ValueError) und einer Meldung (invalid literal for int() with base 10: 'twenty').
3. Der try-Block hält an dieser Zeile an. Seine restlichen Zeilen werden übersprungen, deshalb wird "Next year you will be" für "twenty" nicht ausgegeben.
4. Die Laufzeitumgebung vergleicht den Typ der Ausnahme von oben nach unten mit jeder except-Klausel und führt die erste aus, die passt.
5. Wenn der Handler fertig ist, macht das Programm mit der ersten Zeile nach der gesamten try-Anweisung weiter.
6. Passt keine Klausel, verlässt die Ausnahme die aktuelle Funktion, und die Suche geht in der aufrufenden Funktion weiter, dann in deren Aufrufer. Das nennt man das Abwickeln des Aufrufstapels. Erreicht die Suche die oberste Ebene des Programms ohne Treffer, endet das Programm mit einem Traceback.

Schritt 6 bedeutet, dass der Handler nicht in der Funktion stehen muss, in der der Fehler passiert. Hier liegt der Fehler zwei Aufrufe tief, und der Handler ganz unten fängt ihn trotzdem:

def parse_price(text):
    print("parsing", text)
    return float(text)

def total(prices):
    result = 0
    for p in prices:
        result += parse_price(p)
    return result

try:
    print(total(["4.50", "free", "3.20"]))
except ValueError as error:
    print("Could not add the prices:", error)

parsing 4.50
parsing free
Could not add the prices: could not convert string to float: 'free'

float("free") ist in parse_price gescheitert. Weder parse_price noch total hatte einen Handler, also wurden beide abgebrochen, und "3.20" wurde nie geparst. Das ist die zentrale Entwurfsentscheidung, die Ausnahmebehandlung dir gibt: Behandle einen Fehler dort, wo du weißt, was zu tun ist, und das ist oft weit entfernt von der Stelle, an der er passiert ist.

try, except, else und finally

Die try-Anweisung in Python hat zwei weitere optionale Teile. else läuft nur, wenn der try-Block ohne Ausnahme fertig geworden ist. finally läuft in jedem Fall: nach Erfolg, nach einer behandelten Ausnahme und sogar dann, wenn die Funktion aus dem try heraus zurückkehrt.

def divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        print("b was zero")
        return None
    else:
        print("no error")
        return result
    finally:
        print("finally runs either way")

print(divide(6, 3))
print(divide(6, 0))

no error
finally runs either way
2.0
b was zero
finally runs either way
None

In den finally-Block gehört das Aufräumen: eine Datei schließen, eine Sperre freigeben, eine Datenbankverbindung schließen. In Python erledigt die with-Anweisung dieses Aufräumen für Dateien automatisch, und sie ist dafür die übliche Wahl.

Eigene Ausnahmen werfen

Ausnahmen gibt es nicht nur für Fehler, die die Sprache erkennt. Bekommt deine eigene Funktion eine Eingabe, mit der sie nicht arbeiten kann, kann sie eine Ausnahme werfen, um abzulehnen, und der Aufrufer entscheidet, was als Nächstes passiert. Eine kleine eigene Ausnahmeklasse gibt dem Fehler einen Namen, der ihn beschreibt.

class InsufficientFunds(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFunds(f"cannot take {amount}, balance is {balance}")
    return balance - amount

print(withdraw(100, 30))

try:
    withdraw(100, 250)
except InsufficientFunds as error:
    print("Refused:", error)

70
Refused: cannot take 250, balance is 100

Python verwendet raise. Java, C++ und JavaScript verwenden dafür throw.

Ausnahmebehandlung in anderen Sprachen

Dasselbe Parsing-Beispiel sieht in Java so aus:

try {
    int age = Integer.parseInt("twenty");
    System.out.println(age + 1);
} catch (NumberFormatException e) {
    System.out.println("Not a number: " + e.getMessage());
} finally {
    System.out.println("done");
}

Java teilt Ausnahmen in zwei Gruppen. Geprüfte Ausnahmen (Checked Exceptions) wie IOException beschreiben Probleme außerhalb der Kontrolle des Programms, und der Compiler weigert sich, Code zu bauen, der sie weder fängt noch deklariert. Ungeprüfte Ausnahmen, Unterklassen von RuntimeException wie NullPointerException, bedeuten meist einen Bug, und der Compiler zwingt dich nicht, sie zu behandeln.

Häufige Fehler

• Alles fangen. Ein nacktes except: fängt in Python auch KeyboardInterrupt, sodass Strg+C nicht mehr funktioniert, und except Exception: fängt Bugs, mit denen du nie gerechnet hast. Fang den konkreten Typ, von dem du weißt, wie du ihn behandelst.
• Den Fehler verschlucken. except ValueError: pass versteckt das Problem. Gib zumindest aus oder protokolliere, was schiefgelaufen ist.
• Ein zu großer try-Block. Umschließ nur die Zeilen, die die gefangene Ausnahme werfen können, damit nicht versehentlich ein anderer Fehler behandelt wird.
• Bugs fangen statt beheben. Ein IndexError aus einer Schleife, die einen Schritt zu weit läuft, ist ein Fehler im Code. Ihn zu behandeln hält den falschen Code am Leben.
• Erwarten, dass catch einen Absturz in C oder C++ verhindert. Ein Segmentation Fault ist ein Signal des Betriebssystems, keine Ausnahme, und unter Linux und macOS bekommt ein catch (...) in C++ ihn nie zu sehen.

Wie es weitergeht

Die Fehler, auf die Ausnahmebehandlung reagiert, beschreibt die Seite zu Laufzeitfehler, den Absturz, den sie nicht fangen kann, die Seite zu Segmentation Fault. Die vollständige Syntax findest du in den Anleitungen zu Python-Ausnahmen, try und catch in Java, C++-Ausnahmen und try und catch in JavaScript. Der Java-Kurs und der Python-Kurs üben beides mit echten Aufgaben.