Einführung in zwei Fehlertypen in Python

Bisher haben wir nicht viel über Fehlermeldungen berichtet, aber sie wurden in einigen Beispielen verwendet. Python hat mindestens zwei Arten von Fehlern: Syntaxfehler und Ausnahme

8.1 Syntaxfehler

Syntaxfehler, auch Parsingfehler genannt, sind Python Eine häufige Beschwerde unter Anfängern.

>>> while True print('Hello world')
  File "<stdin>", line 1while True print(&#39;Hello world&#39;)                   ^SyntaxError: invalid syntax

Der Python-Parser druckt die Fehlerzeile wiederholt aus und zeigt einen kleinen Pfeil an, der auf die Position in der Fehlerzeile zeigt, an der der Fehler erstmals erkannt wurde. Der Fehler wird durch die Anweisung vor dem Pfeil verursacht (zumindest wird das erkannt): Im obigen Beispiel wird der Fehler in der Funktion print() erkannt, weil der Doppelpunkt : davor fehlt. Der Dateiname und die Zeilennummer werden ebenfalls gedruckt, was das Auffinden von Problemen erleichtert, wenn das Programm aus einem Skript stammt.

8.2 Ausnahmen

Auch wenn die Aussage oder der Ausdruck grammatikalisch korrekt ist, können bei der Ausführung Fehler auftreten. Während der Ausführung erkannte Probleme werden als Ausnahmen bezeichnet. Ausnahmen sind keine absolut schwerwiegenden Fehler: Als Nächstes stellen wir vor, wie Ausnahmen in Python behandelt werden. Die meisten Ausnahmen werden jedoch vom Programm nicht behandelt und werden schließlich zu Fehlermeldungen, wie unten gezeigt:

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

Die letzte Zeile der Fehlermeldung gibt an, was passiert ist. Es gibt verschiedene Arten von Ausnahmen, und die Typen werden auch als Teil der Fehlermeldung gedruckt: Die Typen im obigen Beispiel sind die Division-durch-Null-Ausnahme ZeroDivisionError, die Namensausnahme NameError und die Typausnahme TypeError. Die als Ausnahmetyp ausgegebene Zeichenfolge ist der Name der integrierten Ausnahme. Dies gilt für alle integrierten Ausnahmen, und obwohl diese Konvention nützlich ist, halten sich nicht alle benutzerdefinierten Ausnahmen daran. Standardausnahmenamen sind integrierte Bezeichner (keine reservierten Wörter).

Die verbleibenden Zeilen zeigen detaillierte Informationen basierend auf dem Ausnahmetyp und dem Grund, warum die Ausnahme aufgetreten ist.

Im vorherigen Teil der Fehlermeldung werden die Kontextinformationen der Ausnahme in Form eines Stack-Tracebacks angezeigt. Normalerweise werden die Quellcodezeilen im Stack-Traceback aufgelistet. Wenn das Programm jedoch von der Standardeingabe liest, werden die Zeilen nicht angezeigt.

Integrierte Ausnahmen listet alle integrierten Ausnahmen und ihre Bedeutung auf.

8.3 Ausnahmen behandeln

Python-Programme ermöglichen die Behandlung bestimmter Ausnahmen. Das folgende Programm erfordert, dass der Benutzer die Eingabe wiederholt, bis die Eingabe eine gültige Ganzzahl ist. Das Programm kann jedoch auch unterbrochen werden (mit Control-C oder anderen vom Betriebssystem unterstützten Mitteln). Beachten Sie, dass vom Benutzer verursachte Unterbrechungen eine KeyboardInterrupt-Ausnahme auslösen . Die Ausführungsreihenfolge der

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

try-Anweisungen lautet:

• Führen Sie zunächst die Anweisungen zwischen try und except aus try-Klausel

• Wenn keine Ausnahme auftritt, überspringen Sie die Exception-Klausel und die try-Anweisung wird ausgeführt

• Wenn während der Ausführung der try-Klausel eine Ausnahme auftritt, werden die restlichen Anweisungen in der Klausel übersprungen. Wenn der ausgelöste Ausnahmetyp mit der Ausnahme nach dem Schlüsselwort except übereinstimmen kann, wird als Nächstes die Ausnahmeklausel ausgeführt und anschließend die Anweisung nach der try-Anweisung weiter ausgeführt.

• Wenn eine Ausnahme auftritt, aber keine Ausnahme nach „except“ gefunden wird, wird die Ausnahme an die äußere try-Anweisung geworfen; wenn die Ausnahme nicht behandelt werden kann, wird die Ausnahme nicht behandelt Ausnahme , die dazu führt, dass das Programm beendet wird und eine Meldung wie im obigen Beispiel ausgibt.

Eine

-Anweisung kann mehrere Except-Klauseln haben, um Behandlungsmethoden für verschiedene Ausnahmen anzugeben. Es wird höchstens eine Ausnahmeklausel ausgeführt. Der Handler behandelt nur Ausnahmen, die in der entsprechenden try-Klausel auftreten, nicht Ausnahmen, die in anderen Handlern in derselben try-Anweisung auftreten. Eine Ausnahmeklausel kann mithilfe eines in Klammern gesetzten Tupels mehrere Ausnahmen auflisten, wie folgt: try

... except (RuntimeError, TypeError, NameError):
...     pass

Eine Klasse in der Klausel kann mit Typen übereinstimmen, deren untergeordnete Klasse oder mit ihrem eigenen Ausnahmetyp (Aber nicht umgekehrt, Unterklassen in der Ausnahmeklausel stimmen nicht mit Ausnahmen der übergeordneten Klasse überein.) Der folgende Code gibt beispielsweise B, C, D der Reihe nach aus: except

class B(Exception):passclass C(B):passclass D(C):passfor cls in [B, C, D]:try:raise cls()except D:print("D")except C:print("C")except B:print("B")

Beachten Sie Folgendes: Wenn die obige Ausnahmeklausel umgekehrt geschrieben wird (

zuerst), dann B wird gedruckt, B, B – Die Übereinstimmung der ersten Except-Klausel wird ausgelöst. except B

In der letzten Ausnahmeklausel kann der Ausnahmename als Platzhalterzeichen weggelassen werden. Da dadurch andere echte Programmfehler verdeckt werden können, ist Vorsicht geboten. Kann auch zum Drucken von Fehlermeldungen und zum erneuten Auslösen verwendet werden (damit der Aufrufer die Ausnahme behandeln kann):

import systry:
    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

... Die try-Anweisung verfügt über ein optionales exceptelse-Klausel , diese Klausel kann nur nach allen Ausnahmeklauseln erscheinen. Wenn ein Codeabschnitt ausgeführt werden muss, obwohl die try-Klausel keine Ausnahme auslöst, ist es sinnvoll, die else-Klausel zu verwenden (Anmerkung: Die -Klausel wird von else übersprungen). Zum Beispiel: return, break, continue

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

使用 else 子句比在 try 子句中附加代码要好，因为这样可以避免 try ... except 意外的捕获的本不属于它们保护的那些代码抛出的异常。

异常发生时，可以携带与之关联的值，也称作异常参数。异常参数是否可以存在以及其类型取决于异常类型。

except子句可以在异常名字后指定变量。该变量绑定到异常实例，异常参数存储在instance.args属性中。方便起见，异常实例定义了__str__()以便异常参数可以直接打印，而不是使用.args引用。也可以首先实例化异常，并在抛出它之前加入任何想要的参数：

>>> try:
...     raise Exception('spam', 'eggs')
... except Exception as inst:
...     print(type(inst))    # the exception instance...     print(inst.args)     # arguments stored in .args...     print(inst)          # __str__ allows args to be printed directly,...                          # but may be overridden in exception subclasses...     x, y = inst.args     # unpack args...     print('x =', x)
...     print('y =', y)
...<class &#39;Exception&#39;>(&#39;spam&#39;, &#39;eggs&#39;)
(&#39;spam&#39;, &#39;eggs&#39;)
x = spam
y = eggs

对于未处理异常来说，如果它有参数，那么参数将在错误信息的后面部分（详细信息部分）打印。

异常处理程序不仅仅会处理即时发生在try子句中的异常，还会处理try子句中直接或者间接调用的函数中发生的异常。例如：

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

8.4 Raising Exceptions

raise语句允许程序员强制发生异常。例如：

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

raise的唯一参数指定要抛出的异常。参数必须是异常实例或者异常类（继承自Exception类的子类）。如果参数是异常类型，会隐式使用无参方式调用异常的构造器初始化一个异常实例：

raise ValueError  # shorthand for 'raise ValueError()'

如果需要捕获异常但是不处理，一种更简单形式的raise语句允许重新抛出这个异常：

>>> 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 <module>NameError: HiThere

8.5 User-defined Exception

程序中可以通过创建新异常类的方式提出自己的异常（参见Classes获取Python类的更多信息）。异常必须直接或者间接继承自Exception类。

自定义异常类拥有其他类的功能，但通常需要保持其简洁性，只提供几个供异常处理程序提取错误信息的属性。需要创建一个抛出若干不同错误的模块时，比较好的实践是，为定义在这个模块中的异常创建父类，由子类创建对应不同错误的具体异常：

class Error(Exception):"""Base class for exceptions in this module."""passclass 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 = expressionself.message = messageclass 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 = previousself.next = nextself.message = message

与标准异常类类似，大多数异常的名字都以"Error"结尾。

许多标准模块都定义了自己的异常，这些异常对应模块中定义的函数中可能发生的错误。更多信息参考Classes。

8.6 Defining Clean-up Actions

try语句有可选的在任何情况下都会执行的子句，可用于定义清理动作。例如：

>>> try:
...     raise KeyboardInterrupt... finally:
...     print('Goodbye, world!')
...
Goodbye, world!KeyboardInterruptTraceback (most recent call last):
  File "<stdin>", line 2, in <module>

无论是否有异常发生，finally子句在离开try语句之前总是会执行。当try子句中有异常发生并且没有被except子句处理（或者异常发生在except子句或else子句），finally子句执行之后，这些异常会重新抛出。当try语句的其他子句通过break, continue或者return语句离开时，finally子句也会执行。以下是较为复杂的示例：

>>> 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.0executing 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 <module>
  File "<stdin>", line 3, in divideTypeError: unsupported operand type(s) for /: &#39;str&#39; and &#39;str&#39;

正如所见的那样，finally子句在任何情况下都会执行。两个字符串相除产生的TypeError异常没有被except子句处理，因此在finally子句执行完毕之后被重新抛出。

在实践应用中，finally子句用来释放外部资源（比如文件和网络连接），不论资源的使用是否成功。

8.7 Predefined Clean-up Actions

一些对象定义了标准的清理动作，当不再需要这些对象时，会执行清理动作，而不论使用对象的操作是否成功。以下示例读取文件并打印内容到显示器：

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

这段代码的问题是：当代码执行完毕后，文件会保留打开状态一段不确定的时间。这在简单的脚本中不是什么大问题，但是在大型的应用程序中会出问题。with语句使得像文件一样的对象可以被立即准确回收。

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

语句执行后，即使在执行代码时遇到问题，文件f总是会被关闭。像文件一样提供预定义清理动作的对象会在其说明文档中指示这点。

Das obige ist der detaillierte Inhalt vonEinführung in zwei Fehlertypen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!