8. 错误和异常
*************

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


8.1. 语法错误
=============

语法错误又称解析错误，可能是你在学习Python 时最容易遇到的错误:

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

解析器会输出出现语法错误的那一行，并显示一个“箭头”，指向这行里面检测到
的第一个错误。 错误是由箭头指示的位置 *上面* 的 token 引起的（或者至少
是在这里被检测出的）：在示例中，在 "print()" 这个函数中检测到了错误，
因为在它前面少了个冒号 ("':'") 。文件名和行号也会被输出，以便输入来自
脚本文件时你能知道去哪检查。


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't convert 'int' object to str implicitly

错误信息的最后一行告诉我们程序遇到了什么类型的错误。异常有不同的类型，
而其类型名称将会作为错误信息的一部分中打印出来：上述示例中的异常类型依
次是："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 子句中的类是兼容的（但反过来则不成立 --- 列出派生类的 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" 子句添加额外的代码要好，因为它避免了意外捕
获非 "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 '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. 用户自定义异常
===================

程序可以通过创建新的异常类来命名它们自己的异常（有关Python 类的更多信
息，请参阅 类）。异常通常应该直接或间接地从 "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.6. 定义清理操作
=================

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

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

如果存在 "finally" 子句，则 "finally" 子句将作为 "try" 语句结束前的最
后一项任务被执行。 "finally" 子句不论 "try" 语句是否产生了异常都会被执
行。 以下几点讨论了当异常发生时一些更复杂的情况：

* 如果在执行 "try" 子句期间发生了异常，该异常可由一个 "except" 子句进
  行处理。 如果异常没有被某个 "except" 子句所处理，则该异常会在
  "finally" 子句执行之后被重新引发。

* 异常也可能在 "except" 或 "else" 子句执行期间发生。 同样地，该异常会
  在 "finally" 子句执行之后被重新引发。

* 如果在执行 "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.7. 预定义的清理操作
=====================

某些对象定义了在不再需要该对象时要执行的标准清理操作，无论使用该对象的
操作是成功还是失败，清理操作都会被执行。 请查看下面的示例，它尝试打开
一个文件并把其内容打印到屏幕上。:

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

这个代码的问题在于，它在这部分代码执行完后，会使文件在一段不确定的时间
内处于打开状态。这在简单脚本中不是问题，但对于较大的应用程序来说可能是
个问题。 "with" 语句允许像文件这样的对象能够以一种确保它们得到及时和正
确的清理的方式使用。:

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

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