Python3 Fehler und Ausnahmen

Als Python Anfänger, nur zu lernen, die Python-Programmierung oft eine Fehlermeldung angezeigt wird, erwähnen wir vor diesem Kapitel nicht werden wir gewidmet.

Python hat zwei leicht erkennbare Fehler: Syntaxfehler und Ausnahmen.

Syntaxfehler

Python-Syntaxfehler oder falsche Ruf analytisch, Anfänger oft begegnen, wie Beispiele

>>> while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

In diesem Beispiel wird die Funktion print () auf Fehler überprüft, bevor es einen Doppelpunkt fehlt (:).

Parser wies auf die Fehler seiner Partei aus, und an der falschen Stelle der erste Marker ein kleiner Pfeil zu finden.

abnormal

Auch Grammatik Python-Programm korrekt ist, ist es Zeit zu laufen, kann es zu Fehlern. Laufzeitfehler erkannt werden Ausnahmen genannt.

Die meisten werden keine Ausnahme-Handler in Form von Fehlermeldungen angezeigt werden hier sein:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly

Erscheinen abnorme in verschiedenen Typen sind diese Arten als Teil der Informationen ausgedruckt: Beispiele für Arten Zerodivisionerror, Nameerror und Typeerror.

Der vordere Teil der Fehlermeldung zeigt den Kontext einer Ausnahme auftritt, den Call-Stack und in Form von spezifischen Informationen angezeigt.

Ausnahmebehandlung

Das folgende Beispiel, ermöglicht es Benutzern, eine gültige ganze Zahl eingeben, sondern ermöglicht es dem Benutzer, das Programm (mit Strg-C oder die Betriebssystem-Methoden zur Verfügung gestellt) zu unterbrechen. Benutzerunterbrechungen eine KeyboardInterrupt Ausnahme verursachen.

>>> while True:
        try:
            x = int(input("Please enter a number: "))
            break
        except ValueError:
            print("Oops!  That was no valid number.  Try again   ")
   

versuchen Anweisung funktioniert wie folgt;

• Zunächst wird die try-Klausel (zwischen den Keywords und Keyword außer try-Anweisungen)
• Wenn keine Ausnahme auftritt, wird die Ausnahme-Klausel ignoriert wird, versuchen Klausel ausgeführt Enden ist.
• Wenn eine Ausnahme in der Prozedur try-Klausel auftritt, dann Klausel versuchen, der Rest wird ignoriert. Wenn der Name und Typ der Ausnahme der Ausnahme nach dem Spiel, dann außer Klausel die entsprechende ausgeführt. Code versuchen Anweisung nach der letzten Ausführung.
• Wenn eine Ausnahme mit jeder nicht außer überein, wird diese Ausnahme von der oberen Versuch übergeben werden.

Eine try-Anweisung kann mehr als eine Ausnahme-Klausel, mit unterschiedlichen spezifischen Ausnahmen zu behandeln. Höchstens ein Zweig ausgeführt.

Handler nur für die entsprechenden try-Klausel eine Ausnahmeverarbeitung, anstatt die anderen Versuch Exception-Handler.

Eine Ausnahme-Klausel kann mehrere Ausnahmen zu behandeln, die in einer Klammer als Tupel platziert werden, zum Beispiel:

    except (RuntimeError, TypeError, NameError):
        pass

Die letzte except-Klausel darf den Namen der Ausnahme ignorieren, wird es als Platzhalter behandelt werden. Sie können diese Methode verwenden, um eine Fehlermeldung zu drucken, und dann wieder geworfen.

import sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

versuchen außer Aussage eine optionale else-Klausel hat, wenn Sie diese Klausel zu verwenden, müssen nach alle außer Klauseln platziert werden. Diese Klausel wird keine Probleme haben, tritt in der try-Klausel ausführt. Zum Beispiel:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

Verwenden Sie die else-Klausel als alle Aussagen in der try-Klausel, die besser ist, etwas unerwartet zu vermeiden, aber außer sie nicht fangen die Ausnahme.

Ausnahmebehandlung nicht nur mit diesen Ausnahmen behandeln auftreten direkt Klausel versuchen, aber auch Handler-Klausel zu nennen (auch indirekte Funktionsaufrufe), wo geworfen. Zum Beispiel:

>>> def this_fails():
        x = 1/0
   
>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
   
Handling run-time error: int division or modulo by zero

Werfen Sie eine Ausnahme

Python verwendet throw-Anweisung eine bestimmte Ausnahme zu erhöhen. Zum Beispiel:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

heben nur ein Parameter die Ausnahme geworfen werden angibt. Es muss eine ungewöhnliche Instanz einer Klasse oder abnormal (dh Ausnahmeunterklasse) sein.

Wenn Sie wissen wollen, ob es eine Ausnahme auslöst, will nicht damit umgehen, dann eine einfache Anweisung kann heben sie wieder geworfen.

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

Benutzerdefinierte Ausnahmen

Sie können Ihre eigenen Ausnahmen müssen durch eine neue Ausnahmeklasse zu schaffen. Ausnahmen sollten von der Exception-Klasse erben, entweder direkt Vererbung, nacheinander oder indirekt, zum Beispiel:

>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)
   
>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)
   
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

In diesem Beispiel ist die Klasse Exception Standard __init __ () überschrieben.

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

>>> try:
        raise KeyboardInterrupt
	finally:
        print('Goodbye, world!')
   
Goodbye, world!
KeyboardInterrupt

>>> def divide(x, y):
        try:
            result = x / y
        except ZeroDivisionError:
            print("division by zero!")
        else:
            print("result is", result)
        finally:
            print("executing finally clause")
   
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

for line in open("myfile.txt"):
    print(line, end="")

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")