本文内容全部出自《Python基础教程》第二版，在此分享自己的学习之路。
______欢迎转载：http://www.cnblogs.com/Marlowes/p/5428641.html______
Created on 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 接下来学什么
本章讲异常，内容可能有些意外(双关语)，而下一章的内容真的很不可思议，恩，近乎不可思议。