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. Exception Chaining
=======================

The "raise" statement allows an optional "from" which enables chaining
exceptions by setting the "__cause__" attribute of the raised
exception. For example:

   raise RuntimeError from OSError

This can be useful when you are transforming exceptions. For example:

   >>> 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

The expression following the "from" must be either an exception or
"None". Exception chaining happens automatically when an exception is
raised inside an exception handler or "finally" section. Exception
chaining can be disabled by using "from None" idiom:

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


8.6. 用户自定义异常
===================

程序可以通过创建新的异常类来命名它们自己的异常（有关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.7. 定义清理操作
=================

"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.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* 也始终会被关闭。和文件
一样，提供预定义清理操作的对象将在其文档中指出这一点。
