Verschachtelte try...except-Anweisungen in Python

Die Anweisung try...except wird in Python verwendet, um Ausnahmen abzufangen oder fehleranfälligen Code auszuführen. Heutzutage hat jede Programmiersprache diese Funktion, aber in Python wird es durch diese Wörter bzw. durch die Schlüsselwörter try...außer repräsentiert. Neben try...except könnte auch ein weiteres Schlüsselwort, nämlich finally, zusammen mit ihnen verwendet werden.

Wie for-Schleifen können auch diese try-, catch- und finally-Anweisungen verschachtelt werden, und in diesem Artikel werden wir darüber sprechen.

Verschachtelte try...except-Anweisungen in Python

Wie oben erwähnt, können wir diese Anweisungen auf die gleiche Weise verschachteln, wie wir for-Schleifen verschachteln. Ein Beispiel finden Sie im folgenden Code.

a = {"a": 5, "b": 25, "c": 125}

try:
    print(a["d"])
except KeyError:
    try:
        print("a:", a["a"])
    except:
        print("No value exists for keys 'a' and 'd'")
    finally:
        print("Nested finally")
finally:
    print("Finally")

Ausgabe:

a: 5
Nested finally
Finally

Wie wir sehen, initialisiert das obige Programm zunächst ein Dictionary mit einigen Schlüssel-Wert-Paaren und versucht dann, auf den Wert für den Schlüssel d zuzugreifen. Da kein Schlüssel-Wert-Paar existiert, wird eine KeyError-Ausnahme ausgelöst und von der Exception-Anweisung abgefangen. Dann führen die Interpreter den Code unter dem verschachtelten try-Block aus. Da für den Schlüssel a ein Wert existiert, wird dieser an die Konsole ausgegeben und der Code unter der verschachtelten finally-Anweisung ausgeführt. Zuletzt wird der Code unter der äußeren finally-Anweisung ausgeführt.

Das bedeutet, dass wir die Anweisungen try, catch und finally unter jede try-, catch- und finally-Anweisung setzen können. Lassen Sie dies an einem Beispiel verstehen. Wir werden Code schreiben, der die Anweisungen try, catch und finally enthält, und alle diese Anweisungen enthalten auch die Anweisungen try, catch und finally.

a = {
    "a": 5,
    "b": 25,
    "c": 125,
    "e": 625,
    "f": 3125,
}

try:
    try:
        print("d:", a["d"])
    except:
        print("a:", a["a"])
    finally:
        print("First nested finally")
except KeyError:
    try:
        print("b:", a["b"])
    except:
        print("No value exists for keys 'b' and 'd'")
    finally:
        print("Second nested finally")
finally:
    try:
        print("c:", a["c"])
    except:
        print("No value exists for key 'c'")
    finally:
        print("Third nested finally")

Ausgabe:

a: 5
First nested finally
c: 125
Third nested finally

Wie wir sehen, wird zuerst der äußere try-Block ausgeführt. Da für den Schlüssel d kein Wert gefunden wird, wird der Code unter der verschachtelten except-Anweisung ausgeführt und die verschachtelte finally. Da der äußere try-Block während der Ausführung keine Ausnahmen erhalten hat, wird sein except-Block übersprungen und der Code unter dem äußeren finally-Block ausgeführt.

Wir können dies sogar beliebig weiterführen und n Ebenen von verschachtelten try-, catch- und finally-Anweisungen erstellen. Aber wenn die Anzahl der verschachtelten Ebenen zunimmt, wird der Kontroll- oder Ausführungsfluss etwas kompliziert und unüberschaubar. Es wird schwierig, sich durch die Aussagen try, catch und finally zu navigieren.