第八章 异常

来源：http://www.cnblogs.com/Marlowes/p/5428641.html

作者：Marlowes

在编写程序的时候，程序员通常需要辨别事件的正常过程和异常(非正常)的情况。这类异常事件可能是错误(比如试图除以0)，或者是不希望经常发生的事情。为了能够处理这些异常事件，可以在所有可能发生这类事件的地方都使用条件语句(比如让程序检查除法的分母是否为零)。但是，这么做可能不仅会没效率和不灵活，而且还会让程序难以阅读。你可能会想直接忽略这些异常事件，期望它们永不发生，但Python的异常对象提供了非常强大的替代解决方案。

本章介绍如何创建和引发自定义的异常，以及处理异常的各种方法。

8.1 什么是异常

Python用异常对象(exception object)来表示异常情况。遇到错误后，会引发异常。如果异常对象并未被处理或捕捉，程序就会用所谓的回溯(traceback， 一种错误信息)终止执行：

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> 
  ZeroDivisionError: integer division or modulo by zero

如果这些错误信息就是异常的全部功能，那么它也就不必存在了。事实上，每个异常都是一些类(本例中是ZeroDivisionError)的实例，这些实例可以被引发，并且可以用很多种方法进行捕捉，使得程序可以捉住错误并且对其进行处理，而不是让整个程序失效。

8.2 按自己的方式出错

异常可以在某些东西出错的时候自动引发。在学习如何处理异常之前，先看一下自己如何引发异常，以及创建自己的异常类型。

8.2.1 raise语句

为了引发异常，可以使用一个类(应该是Exception的子类)或者实例参数调用raise语句。使用类时，程序会自动创建类的一个实例。下面是一些简单的例子，使用了内建的Exception的异常类：

>>> raise Exception
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> 
  Exception 
>>> raise Exception("hyperdrive overload")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> \
  Exception: hyperdrive overload

第一个例子raise Exception引发了一个没有任何有关错误信息的普通异常。后一个例子中，则添加了错误信息hyperdrive overload。

内建的异常类有很多。Python库参考手册的Built-in Exceptions一节中有关与它们的描述。用交互式解释器也可以分析它们，这些内建异常都可以在exceptions模块(和内建的命名空间)中找到。可以使用dir函数列出模块内容，这部分会在第十章中讲到：

>>> import exceptions 
>>> dir(exceptions)
['ArithmeticError', 'AssertionError', 'AttributeError', ...]

读者的解释器中，这个名单可能要长得多——出于对易读性的考虑，这里删除了大部分名字，所有这些异常都可以用在raise语句中：

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

表8-1描述了一些最重要的内建异常类：

表8-1 一些内建异常类

Exception　　　　　　　　　　　　所有异常的基类
AttributeError　　　　　　　　　 特性引用或赋值失败时引发
IOError　　　　　　　　　　　　　试图打开不存在文件(包括其他情况)时引发
IndexError                       在使用序列中不存在的索引时引发
KeyError　　　　　　　　　　　　 在使用映射中不存在的键时引发
NameError　　　　　　　　　　　  在找不到名字(变量)时引发
SyntaxError　　　　　　　　　　　在代码为错误形式时引发
TypeError　　　　　　　　　　　　在内建操作或者函数应用于错误类型的对象时引发
ValueError　　　　　　　　　　　 在内建操作或者函数应用于正确类型的对象，但是该对象使用不合适的值时引发
ZeroDivisionError　　　　　　　　在除法或者模除操作的第二个参数为0时引发

8.2.2 自定义异常类

尽管内建的异常类已经包括了大部分的情况，而且对于很多要求都已经足够了，但是有些时候还是需要创建自己的异常类。比如在超光速推进装置过载(hyperdrive overload)的例子中，如果能有个具体的HyperDriveError类来表示超光速推进装置的错误状况是不是更自然一些？错误信息是足够了，但是会在8.3节中看到，可以根据异常所在的类，选择性地处理当前类型的异常。所以如果想要使用特殊的错误处理代码处理超光速推进装置的错误，那么就需要一个独立于exceptions模块的异常类。

那么如何创建自己的异常类呢？就像其他类一样，只是要确保从Exception类继承(不管是间接还是直接，也就是说继承其他的内建异常类也是可以的)。那么编写一个自定义异常类基本上就像下面这样：

class SomeCustomException(Exception): 
    pass

还不能做太多事，对吧？(如果你愿意，也可以向你的异常类中增加方法)

8.3 捕捉异常

前面曾经提到过，关于异常的最有意思的地方就是可以处理它们(通常叫做诱捕或者捕捉异常)。这个功能可以使用try/except语句来实现。假设创建了一个让用户输入两个数，然后进行相除的程序，像下面这样：

x = input("Enter the first number: ")
y = input("Enter the second number: ") 
print x / y

程序工作正常，假如用户输入0作为第二个数

Enter the first number: 10 Enter the second number: 0
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 6, in <module>
    print x / y
ZeroDivisionError: integer division or modulo by zero

为了捕捉异常并且做出一些错误处理(本例中只是输出一些更友好的错误信息)，可以这样重写程序：

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ") 
    print x / y 
except ZeroDivisionError: 
    print "The second number can't be zero!"

看起来用if语句检查y值会更简单一些，本例中这样做的确很好。但是如果需要给程序加入更多除法，那么就得给每个除法加个if语句。而且使用try/except的话只需要一个错误处理器。

注：如果没有捕捉异常，它就会被“传播”到调用的函数中。如果在那里依然没有捕获，这些异常就会“浮”到程序的最顶层，也就是说你可以捕捉到在其他人的函数中所引发的异常。有关这方面的更多信息，请参见8.10节。

看，没参数

如果捕捉到了异常，但是又想重新引发它(也就是说要传递异常，不进行处理)，那么可以调用不带参数的raise(还能在捕捉到异常时显式地提供具体异常，在8.6节会对此进行解释)。

举个例子吧，看看这么做多么有用：考虑一下一个能“屏蔽”ZeroDivisionError(除零错误)的计算器类。如果这个行为被激活，那么计算器就打印错误信息，而不是让异常传播。如果在与用户交互的过程中使用，那么这就有用了，但是如果是在程序内部使用，引发异常会更好些。因此“屏蔽”机制就可以关掉了，下面是这样一个类的代码：

class MuffledCalculator():

    muffled = False 
    def calc(self, expr): 
        try: 
            return eval(expr) 
        except ZeroDivisionError: 
            if self.muffled: 
                print "Division by zero is illegal"
            else: 
                raise

注：如果除零行为发生而屏蔽机制被打开，那么calc方法会(隐式地)返回None。换句话说，如果打开了屏蔽机制，那么就不应该依赖返回值。

下面是这个类的用法示例，分别打开和关闭了屏蔽：

>>> calculator = MuffledCalculator() 
>>> calculator.calc("10 / 2") 
5
>>> calculator.calc("10 / 0")
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 28, in <module> calculator.calc("10 / 0")
  File "/home/marlowes/MyPython/My_Exception.py", line 19, in calc return eval(expr)
  File "<string>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero >>> calculator.muffled = True >>> calculator.calc("10 / 0")
Division by zero is illegal

当计算器没有打开屏蔽机制时，ZeroDivisionError被捕捉但已传递了。

8.4 不止一个except子句

如果运行上一节的程序并且在提示符后面输入非数字类型的值，就会产生另一个异常：

Enter the first number: 10 
Enter the second number: "Hello, world!" 
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 8, in <module>
    print x / y
TypeError: unsupported operand type(s) for /: 'int' and 'str'

因为except子句只寻找ZeroDivisionError异常，这次的错误就溜过了检查并导致程序终止。为了捕捉这个异常，可以直接在同一个try/except语句后面加上另一个except子句：

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ") 
    print x / y 
except ZeroDivisionError: 
    print "The second number can't be zero!"
except TypeError: 
    print "That wasn't a number, was it?"

这次用if语句实现可就复杂了。怎么检查一个值是否能被用在除法中？方法很多，但是目前最好的方式是直接将值用来除一下看看是否奏效。

还应该注意到，异常处理并不会搞乱原来的代码，而增加一大堆if语句检查可能的错误情况会让代码相当难读。

8.5 用一个块捕捉两个异常

如果需要用一个块捕捉多个类型异常，那么可以将它们作为元组列出，像下面这样：

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ") 
    print x / y 
except (ZeroDivisionError, TypeError, NameError): 
    print "Your numbers were bogus..."

上面的代码中，如果用户输入字符串或者其他类型的值，而不是数字，或者第2个数为0，都会打印同样的错误信息。当然，只打印一个错误信息并没有什么帮助。另外一个方法就是继续要求输入数字直到可以进行除法运算为止。8.8节中会介绍如何实现这一功能。

注意，except子句中异常对象外面的圆括号很重要。忽略它们是一种常见的错误，那样你会得不到想要的结果。关于这方面的解释，请参见8.6节。

8.6 捕捉对象

如果希望在except子句中访问异常对象本身，可以使用两个参数(注意，就算要捕捉到多个异常，也只需向except子句提供一个参数——一个元组)。比如，如果想让程序继续运行，但是又因为某种原因想记录下错误(比如只是打印给用户看)，这个功能就很有用。下面的示例程序会打印异常(如果发生的话)，但是程序会继续运行：

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ") 
    print x / y 
except (ZeroDivisionError, TypeError), e: 
    print e

(在这个小程序中，except子句再次捕捉了两种异常，但是因为你可以显式地捕捉对象本身，所以异常可以打印出来，用户就能看到发生什么(8.8节会介绍一个更有用的方法)。——译者注)

注：在Python3.0中，except子句会被写作except (ZeroDivisionError, TypeError) as e。

8.7 真正的捕捉

就算程序能处理好几种类型的异常，但是有些异常还会从眼皮地下溜走。比如还用那个除法程序来举例，在提示符下面直接按回车，不输入任何东西，会的到一个类似下面这样的错误信息(栈跟踪)：

Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 33, in <module> x = input("Enter the first number: ")
  File "<string>", line 0 
  ^ SyntaxError: unexpected EOF while parsing

这个异常逃过了try/except语句的检查，这很正常。程序员无法预测会发生什么，也不能对其进行准备。在这些情况下，与其用那些并非捕捉这些异常的try/except语句隐藏异常，还不如让程序立刻崩溃。

但是如果真的想用一段代码捕捉所有异常，那么可以在except子句中忽略所有的异常类：

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ") 
    print x / y 
except: 
    print "Something wrong happened..."

现在可以做任何事情了：

Enter the first number: "This" is *completely* illegal 123 Something wrong happened...

警告：像这样捕捉所有异常是危险的，因为它会隐藏所有程序员未想到并且未做好准备处理的错误。它同样会捕捉用户终止执行的Ctrl+C企图，以及用sys.exit函数终止程序的企图，等等。这时使用except Exception, e会更好些，或者对异常对象e进行一些检查。

8.8 万事大吉

有些情况中，没有坏事发生时执行一段代码是很有用的；可以像对条件和循环语句那样，给try/except语句加个else子句：

try: 
    print "A simple task"
except: 
    print "What? Something went wrong?"
else: 
    print "Ah... It went as planned."

运行之后会的到如下输出：

A simple task
Ah... It went as planned.

使用else子句可以实现在8.5节中提到的循环：

while True: 
    try:
        x = input("Enter the first number: ")
        y = input("Enter the second number: ")
        value = x / y 
        print "x / y is", value 
    except: 
        print "Invalid input. Please try again."
    else: 
        break

这里的循环只有在没有异常引发的情况下才会退出(由else子句中的break语句退出)。换句话说，只要有错误发生，程序会不断要求重新输入。下面是一个例子的运行情况：

Enter the first number: 1 
Enter the second number: 0
Invalid input. Please try again.
Enter the first number: "foo" 
Enter the second number: "bar" 
Invalid input. Please try again.
Enter the first number: baz
Invalid input. Please try again.
Enter the first number: 10 
Enter the second number: 2 
x / y is 5

之前提到过，可以使用空的except子句来捕捉所有Exception类的异常(也会捕捉其所有子类的异常)。百分之百捕捉到所有的异常是不可能的，因为try/except语句中的代码可能会出现问题，比如使用旧风格的字符串异常或者自定义的异常类不是Exception类的子类。不过如果需要使用except Exception的话，可以使用8.6节中的技巧在除法程序中打印更加有用的错误信息：

while True: 
    try:
        x = input("Enter the first number: ")
        y = input("Enter the second number: ")
        value = x / y 
        print "x / y is", value 
    except Exception, e: 
        print "Invalid input:", e 
        print "Please try again"
    else: 
        break

下面是示例运行：

Enter the first number: 1 Enter the second number: 0
Invalid input: integer division or modulo by zero
Please try again
Enter the first number: "x" 
Enter the second number: "y" 
Invalid input: unsupported operand type(s) for /: 'str' and 'str' Please try again
Enter the first number: quuux
Invalid input: name 'quuux' is not defined
Please try again
Enter the first number: 10 
Enter the second number: 2 
x / y is 5

8.9 最后······

最后，是finally子句。它可以用来在可能的异常后进行清理。它和try子句联合使用：

x = None 
try:
    x = 1 / 0 
finally: 
    print "Cleaning up..."
    del x

上面的代码中，finally子句肯定会被执行，不管try子句中是否发生异常(在try子句之前初始化x的原因是如果不这样做，由于ZeroDivisionError的存在，x就永远不会被赋值。这样就会导致在finally子句中使用del删除它的时候产生异常，而且这个异常是无法捕捉的)。

运行这段代码，在程序崩溃之前，对于变量x的清理就完成了：

Cleaning up...
  File "/home/marlowes/MyPython/My_Exception.py", line 36, in <module> x = 1 / 0
ZeroDivisionError: integer division or modulo by zero

注：在Python2.5之前的版本内，finally子句需要独立使用，而不能作为try语句的except子句使用。如果都要使用的话，那么需要两条语句。但在Python2.5及其之后的版本中，可以尽情地组合这些子句。

8.10 异常和函数

异常和函数能很自然地一起工作。如果异常在函数内引发而不被处理，它就会传播至(浮到)函数调用的地方。如果在那里也没有处理异常，它就会继续传播，一直到达主程序(全局作用域)。如果那里没有异常处理程序，程序会带着栈跟踪中止。看个例子：

>>> def faulty():
...     raise Exception("Something is wrong")
... 
>>> def ignore_exception():
...     faulty()
... 
>>> def handle_exception():
...     try:
...         faulty()
...     except:
...         print "Exception handled" 
... 
>>> ignore_exception()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module> File "<stdin>", line 2, in ignore_exception
  File "<stdin>", line 2, in faulty
Exception: Something is wrong 
>>> handle_exception()
Exception handled

可以看到，faulty中产生的异常通过faulty和ignore_exception传播，最终导致了栈跟踪。同样地，它也传播到了handle_exception，但在这个函数中被try/except语句处理。

8.11 异常之禅

异常处理并不是很复杂。如果知道某段代码可能会导致某种异常，而又不希望程序以堆栈跟踪的形式终止，那么就根据需要添加try/except或者try/finally语句(或者它们的组合)进行处理。

有些时候，条件语句可以实现和异常处理同样的功能，但是条件语句可能在自然性和可读性上差些。而从另一方面来看，某些程序中使用if/else实现会比使用try/except要好。让我们看几个例子。

假设有一个字典，我们希望打印出存储在特定的键下面的值。如果该键不存在，那么什么也不做。代码可能像下面这样写：

def describePerson(person): 
    print "Description of", person["name"] 
    print "Age:", person["age"] 
    if "occupation" in person: 
        print "Occupation:", person["occupation"]

如果给程序提供包含名字Throatwobbler Mangrove和年龄42(没有职业)的字典的函数，会得到如下输出：

Description of Throatwobbler Mangrove
Age: 42

如果添加了职业camper，会的到如下输出：

Description of Throatwobbler Mangrove
Age: 42 
Occupation: camper

代码非常直观，但是效率不高(尽管这里主要关心的是代码的简洁性)。程序会两次查找"occupation"键，其中一次用来检查键是否存在(在条件语句中)，另外一次获得值(打印)。另外一个解决方案如下：

def describePerson(person): 
    print "Description of", person["name"] 
    print "Age:", person["age"] 
    try: 
        print "Occupation: " + person["occupation"] 
    except KeyError: 
        pass

注：这里在打印职业时使用加号而不是逗号。否则字符串"Occupation:"在异常引发之前就会被输出。

这个程序直接假定"occupation"键存在。如果它的确存在，那么就会省事一些。直接取出它的值再打印输出即可——不用额外检查它是否真的存在。如果该键不存在，则会引发KeyError异常，而被except子句捕捉到。

在查看对象是否存在特定特性时，try/except也很有用。假设想要查看某对象是否有write特性，那么可以使用如下代码：

try:
    obj.write 
except AttributeError: 
    print "The object is not writeable"
else: 
    print "The object is writeable"

这里的try子句仅仅访问特性而不用对它做别的有用的事情。如果AttributeError异常引发，就证明对象没有这个特性，反之存在该特性。这是实现第七章中介绍的getattr(7.2.8节)方法的替代方法，至于更喜欢哪种方法，完全是个人喜好。其实在内部实现getattr时也是使用这种方法：它试着访问特性并且捕捉可能引发的AttributeError异常。

注意，这里所获得的效率提高并不多(微乎其微)，一般来说(除非程序有性能问题)程序开发人员不用过多担心这类优化问题。在很多情况下，使用try/except语句比使用if/else会更自然一些(更“Python化”)，应该养成尽可能使用try/except语句的习惯。

8.12 小结

本章的主题如下。

☑ 异常对象：异常情况(比如发生错误)可以用异常对象表示。它们可以用几种方法处理，但是如果忽略的话，程序就会中止。

☑ 警告：警告类似于异常，但是(一般来说)仅仅打印错误信息。

☑ 引发异常：可以使用raise语句引发异常。它接受异常类或者异常实例作为参数。还能提供两个参数(异常和错误信息)。如果在except子句中不使用参数调用raise，它就会“重新引发”该子句捕捉到的异常。

☑ 自定义异常类：用继承Exception类的方法可以创建自己的异常类。

☑ 捕捉异常：使用try语句的except子句捕捉异常。如果在except子句中不特别指定异常类，那么所有的异常都会被捕捉。异常可以放在元组中以实现多个异常的指定。如果给except提供两个参数，第二个参数就会绑定到异常对象上。同样，在一个try/except语句中能包含多个except子句，用来分别处理不同的异常。

☑ else子句：除了except子句，可以使用else子句。如果主try块中没有引发异常，else子句就会被执行。

☑ finally：如果需要确保某些代码不管是否有异常引发都要执行(比如清理代码)，那么这些代码可以放置在finally(注意，在Python2.5以前，在一个try语句中不能同时使用except和finally子句——但是一个子句可以放置在另一个子句中)子句中。

☑ 异常和函数：在函数内引发异常时，它就会被传播到函数调用的地方(对于方法也是一样)。

8.12.1 本章的新函数

本章涉及的新函数如表8-2所示。

表8-2 本章的新函数

warnings,filterwarnings(action, ...)  用于过滤警告

8.12.2 接下来学什么

本章讲异常，内容可能有些意外(双关语)，而下一章的内容真的很不可思议，恩，近乎不可思议。