Wie man prüft, ob eine Ausnahme in Python eine bestimmte Meldung hat

Einführung

In diesem Lab lernen Sie, wie Sie Ausnahmemeldungen (exception messages) in Python untersuchen und zugreifen können, um Fehler effektiv zu debuggen und zu behandeln. Das Lab führt Sie durch die Erstellung eines Python-Skripts mit einer divide-Funktion, die einen try...except-Block verwendet, um potenzielle Ausnahmen während der Division abzufangen. Sie werden beobachten, wie verschiedene Arten von Ausnahmen, wie ZeroDivisionError und TypeError, spezifische Fehlermeldungen generieren.

Das Lab zeigt dann, wie Sie auf das Ausnahmeobjekt (exception object) und seinen Typ zugreifen können, um detailliertere Informationen über den Fehler zu erhalten. Indem Sie das Skript mit verschiedenen Eingaben ausführen, werden Sie sehen, wie die Ausnahmemeldungen wertvolle Einblicke in die Ursache der Fehler geben und Ihnen ermöglichen, Probleme in Ihrem Code zu identifizieren und zu beheben.

Skills Graph

Untersuchen von Ausnahmemeldungen

In diesem Schritt lernen Sie, wie Sie Ausnahmemeldungen (exception messages) in Python untersuchen können. Ausnahmemeldungen liefern wertvolle Informationen darüber, was in Ihrem Code schief gelaufen ist, und helfen Ihnen, Fehler zu debuggen und zu beheben.

Zunächst erstellen wir eine Python-Datei namens exceptions.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", e)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

In diesem Code:

• Wir definieren eine Funktion divide(x, y), die versucht, x durch y zu teilen.
• Wir verwenden einen try...except-Block, um alle Ausnahmen (exceptions) abzufangen, die während der Division auftreten könnten.
• Wenn eine Ausnahme auftritt, geben wir eine Fehlermeldung zusammen mit dem Ausnahmeobjekt e aus.

Jetzt führen wir das exceptions.py-Skript mit dem python-Befehl aus:

python exceptions.py

Sie sollten die folgende Ausgabe sehen:

The result is: 5.0
An error occurred: division by zero
An error occurred: unsupported operand type(s) for /: 'str' and 'int'

Wie Sie sehen können, wird der erste Aufruf von divide(10, 2) erfolgreich ausgeführt und das Ergebnis ausgegeben. Der zweite Aufruf, divide(10, 0), löst eine division by zero-Ausnahme aus, die vom except-Block abgefangen wird, und die entsprechende Fehlermeldung wird ausgegeben. Der dritte Aufruf, divide("hello", 5), löst einen TypeError aus, da Sie einen String nicht durch eine Ganzzahl teilen können.

Jetzt ändern wir die exceptions.py-Datei, um den Typ der Ausnahme auszugeben:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

Führen Sie das Skript erneut aus:

python exceptions.py

Sie sollten die folgende Ausgabe sehen:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> division by zero
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Diese Ausgabe zeigt den Typ jeder aufgetretenen Ausnahme an und liefert somit noch mehr Informationen für das Debugging.

Zugriff auf Ausnahme-Argumente (Exception args)

In diesem Schritt lernen Sie, wie Sie auf die Argumente (args), die einer Ausnahme (exception) in Python zugeordnet sind, zugreifen können. Ausnahme-Argumente können genauere Details über den aufgetretenen Fehler liefern.

Ändern wir die exceptions.py-Datei, die Sie im vorherigen Schritt erstellt haben, um auf die Ausnahme-Argumente zuzugreifen und sie auszugeben. Öffnen Sie exceptions.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e.args)

divide(10, 2)
divide(10, 0)
divide("hello", 5)

In diesem Code haben wir den except-Block so geändert, dass e.args ausgegeben wird. Das args-Attribut ist ein Tupel, das die Argumente enthält, die an den Konstruktor der Ausnahme übergeben wurden.

Jetzt führen wir das exceptions.py-Skript aus:

python exceptions.py

Sie sollten die folgende Ausgabe sehen:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> ('division by zero',)
An error occurred: <class 'TypeError'> ("unsupported operand type(s) for /: 'str' and 'int'",)

Wie Sie sehen können, enthält die Ausgabe jetzt die Argumente, die jeder Ausnahme zugeordnet sind. Bei ZeroDivisionError ist das Argument ein Tupel, das die Zeichenkette 'division by zero' enthält. Bei TypeError ist das Argument ein Tupel, das die Zeichenkette "unsupported operand type(s) for /: 'str' and 'int'" enthält.

Ändern wir die exceptions.py-Datei erneut, um direkt auf das erste Argument zuzugreifen:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

Führen Sie das Skript erneut aus:

python exceptions.py

Sie sollten die folgende Ausgabe sehen:

The result is: 5.0
An error occurred: <class 'ZeroDivisionError'> division by zero
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Durch den Zugriff auf e.args[0] können wir das erste Argument der Ausnahme extrahieren, das oft der beschreibendste Teil der Fehlermeldung ist.

Übereinstimmung der Meldungszeichenkette prüfen

In diesem Schritt lernen Sie, wie Sie die Meldungszeichenkette einer Ausnahme (exception) in Python prüfen können. Dies ist nützlich, wenn Sie bestimmte Arten von Ausnahmen basierend auf ihrer Meldung unterschiedlich behandeln möchten.

Ändern wir die exceptions.py-Datei, an der Sie gearbeitet haben, um speziell den ZeroDivisionError abzufangen und eine benutzerdefinierte Meldung auszugeben. Öffnen Sie exceptions.py in Ihrem ~/project-Verzeichnis mit dem VS Code-Editor.

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except ZeroDivisionError as e:
        print("Cannot divide by zero!")
    except Exception as e:
        print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

In diesem Code:

• Wir haben einen speziellen except-Block für ZeroDivisionError hinzugefügt.
• Wenn ein ZeroDivisionError auftritt, geben wir die Meldung "Cannot divide by zero!" aus.
• Der generische except Exception as e-Block fängt alle anderen Ausnahmen ab.

Jetzt führen wir das exceptions.py-Skript aus:

python exceptions.py

Sie sollten die folgende Ausgabe sehen:

The result is: 5.0
Cannot divide by zero!
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Wie Sie sehen können, wird beim Aufruf von divide(10, 0) der ZeroDivisionError vom speziellen except-Block abgefangen, und die benutzerdefinierte Meldung "Cannot divide by zero!" wird ausgegeben. Der von divide("hello", 5) ausgelöste TypeError wird immer noch vom generischen except-Block abgefangen.

Sie können auch direkt die Meldungszeichenkette prüfen, obwohl dies im Allgemeinen weniger empfohlen wird als das Abfangen spezieller Ausnahmetypen. So können Sie es tun:

## exceptions.py
def divide(x, y):
    try:
        result = x / y
        print("The result is:", result)
    except Exception as e:
        if "division by zero" in str(e):
            print("Cannot divide by zero!")
        else:
            print("An error occurred:", type(e), e.args[0])

divide(10, 2)
divide(10, 0)
divide("hello", 5)

In diesem Code:

• Wir fangen alle Ausnahmen im generischen except-Block ab.
• Wir prüfen, ob die Zeichenkette "division by zero" in der Zeichenkettenrepräsentation des Ausnahmeobjekts e enthalten ist.
• Wenn dies der Fall ist, geben wir "Cannot divide by zero!" aus. Andernfalls geben wir die generische Fehlermeldung aus.

Führen Sie das Skript erneut aus:

python exceptions.py

Sie sollten die gleiche Ausgabe wie zuvor sehen:

The result is: 5.0
Cannot divide by zero!
An error occurred: <class 'TypeError'> unsupported operand type(s) for /: 'str' and 'int'

Obwohl das Prüfen der Meldungszeichenkette in einigen Fällen nützlich sein kann, ist es im Allgemeinen besser, spezielle Ausnahmetypen abzufangen, da sich Ausnahmemeldungen ändern können, was Ihren Code weniger zuverlässig macht.

Zusammenfassung

In diesem Lab haben Sie Ausnahmemeldungen (exception messages) in Python untersucht, um zu verstehen, wie Sie Fehler debuggen und beheben können. Sie haben gelernt, einen try...except-Block zu verwenden, um Ausnahmen während Divisionsoperationen abzufangen und das Ausnahmeobjekt e auszugeben, um die Fehlermeldung anzuzeigen.

Sie haben auch das Skript so geändert, dass der Typ der Ausnahme ausgegeben wird. Dadurch haben Sie weitere Einblicke in die Art der auftretenden Fehler erhalten, wie z. B. ZeroDivisionError und TypeError. Dies ermöglicht eine gezieltere Fehlersuche und -behandlung.