8. 错误和异常

到目前为止，错误消息还没有被提及，但是如果您尝试过这些示例，您可能已经看到了一些。有（至少）两种可区分的错误：语法错误和异常。

8.1. 语法错误

语法错误，也称为解析错误，可能是您在学习 Python 时遇到的最常见的抱怨类型：

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

解析器重复违规行并显示一个小“箭头”，指向检测到错误的行中最早的点。该错误是由（或至少检测到）箭头 之前的标记 引起的：在示例中，错误是在函数 print() 处检测到的，因为冒号 ([ X176X]) 在它之前丢失。打印文件名和行号，以便您知道在输入来自脚本的情况下在哪里查看。

8.2. 例外

即使语句或表达式在语法上是正确的，当试图执行它时也可能导致错误。在执行过程中检测到的错误称为异常并且不是无条件致命的：您很快就会学习如何在 Python 程序中处理它们。然而，大多数异常不会由程序处理，并且会导致如下所示的错误消息：

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

错误消息的最后一行指示发生了什么。异常有不同的类型，类型作为消息的一部分打印：示例中的类型是 ZeroDivisionError、NameError 和 TypeError。作为异常类型打印的字符串是发生的内置异常的名称。这适用于所有内置异常，但不一定适用于用户定义的异常（尽管这是一个有用的约定）。标准异常名称是内置标识符（不是保留关键字）。

该行的其余部分提供了基于异常类型及其原因的详细信息。

错误消息的前面部分以堆栈回溯的形式显示了发生异常的上下文。一般来说，它包含一个列出源代码行的堆栈回溯；但是，它不会显示从标准输入读取的行。

内置异常列出了内置异常及其含义。

8.3. 处理异常

可以编写处理选定异常的程序。看下面的例子，它要求用户输入直到输入一个有效的整数，但允许用户中断程序（使用 Control-C 或任何操作系统支持）；请注意，用户生成的中断是通过引发 KeyboardInterrupt 异常来发出信号的。

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

try 语句的工作方式如下。

首先，执行 try 子句 （try 和 except 关键字之间的语句）。
如果没有异常发生，则跳过except子句并完成try语句的执行。
如果在执行 try 子句期间发生异常，则跳过该子句的其余部分。然后如果它的类型匹配以except关键字命名的异常，则执行except子句，然后在try语句之后继续执行。
如果发生的异常与 except 子句中指定的异常不匹配，则将其传递给外部 try 语句；如果未找到处理程序，则为 未处理异常 并且执行将停止并显示如上所示的消息。

一个 try 语句可能有多个 except 子句，为不同的异常指定处理程序。最多会执行一个处理程序。处理程序只处理在相应的 try 子句中发生的异常，而不是在同一 try 语句的其他处理程序中。一个except子句可以将多个异常命名为一个带括号的元组，例如：

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

except 子句中的类与异常兼容，如果它是同一个类或其基类（但不是相反——列出派生类的 except 子句与基类不兼容）。例如，以下代码将按顺序打印 B、C、D：

class B(Exception):
    pass

class C(B):
    pass

class D(C):
    pass

for cls in [B, C, D]:
    try:
        raise cls()
    except D:
        print("D")
    except C:
        print("C")
    except B:
        print("B")

请注意，如果将 except 子句反转（首先使用 except B），它将打印 B, B, B — 第一个匹配的 except 子句被触发。

最后一个 except 子句可以省略异常名称，用作通配符。使用它时要格外小心，因为用这种方式很容易掩盖真正的编程错误！它还可以用于打印错误消息，然后重新引发异常（也允许调用者处理异常）：

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

try … except 语句有一个可选的 else 子句 ，当出现时，它必须跟在所有的 except 子句之后。如果 try 子句不引发异常，则它对于必须执行的代码很有用。例如：

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 子句添加额外代码要好，因为它避免意外捕获不是由 [ 保护的代码引发的异常X208X] ... 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 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
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. 引发异常

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. 异常链

raise 语句允许一个可选的 from，它启用链接异常。例如：

# exc must be exception instance or None.
raise RuntimeError from exc

这在您转换异常时很有用。例如：

>>> def func():
...     raise IOError
...
>>> try:
...     func()
... except IOError as exc:
...     raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
OSError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

当在 except 或 finally 部分中引发异常时，异常链接会自动发生。可以使用 from None 习语禁用异常链接：

>>> try:
...     open('database.sqlite')
... except OSError:
...     raise RuntimeError from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError

有关链接机制的更多信息，请参阅内置异常。

8.6. 用户定义的异常

程序可以通过创建一个新的异常类来命名它们自己的异常（有关 Python 类的更多信息，请参阅 Classes）。异常通常应该直接或间接地从 Exception 类派生。

异常类可以被定义为做任何其他类可以做的任何事情，但通常保持简单，通常只提供一些属性，允许异常处理程序提取有关错误的信息。当创建一个可以引发多个不同错误的模块时，通常的做法是为该模块定义的异常创建一个基类，以及为不同的错误条件创建特定异常类的子类：

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

大多数异常定义的名称以“Error”结尾，类似于标准异常的命名。

许多标准模块定义了自己的异常来报告它们定义的函数中可能发生的错误。关于类的更多信息在类一章中介绍。

8.7. 定义清理操作

try 语句有另一个可选子句，用于定义必须在所有情况下执行的清理操作。例如：

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

如果存在 finally 子句，则 finally 子句将作为 try 语句完成之前的最后一个任务执行。无论 try 语句是否产生异常，finally 子句都会运行。以下几点讨论了发生异常时更复杂的情况：

如果在try子句的执行过程中发生异常，异常可以由except子句处理。如果异常未由 except 子句处理，则在执行 finally 子句后重新引发异常。
在执行 except 或 else 子句期间可能会发生异常。同样，在执行 finally 子句后，会重新引发异常。
如果 finally 子句执行 break、continue 或 return 语句，则不会重新引发异常。
如果 try 语句到达 break、continue 或 return 语句，则 finally 子句将在break、continue 或 return 语句的执行。
如果 finally 子句包含 return 语句，则返回值将是来自 finally 子句的 return 语句的值，而不是来自 try 子句的 return 语句。

例如：

>>> def bool_return():
...     try:
...         return True
...     finally:
...         return False
...
>>> bool_return()
False

一个更复杂的例子：

>>> 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 <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

如您所见，在任何情况下都会执行 finally 子句。通过划分两个字符串引发的 TypeError 不会由 except 子句处理，因此在执行 finally 子句后重新引发。

在实际应用中，finally 子句对于释放外部资源（例如文件或网络连接）很有用，无论资源的使用是否成功。

8.8. 预定义的清理操作

一些对象定义了不再需要该对象时要执行的标准清理操作，而不管使用该对象的操作是成功还是失败。看下面的例子，它试图打开一个文件并将其内容打印到屏幕上。

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

这段代码的问题在于，在这部分代码完成执行后，它使文件打开的时间不确定。这在简单脚本中不是问题，但对于较大的应用程序可能是问题。 with 语句允许像文件这样的对象以确保它们总是被及时正确地清理的方式使用。

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

语句执行后，文件 f 始终关闭，即使在处理行时遇到问题。像文件一样提供预定义清理操作的对象将在其文档中指明这一点。

8. 错误和异常 — Python 文档

目录