异常捕获
异常捕获
在编写程序的时候，如果我们知道某段代码可能会导致某种异常，而又不希望程序以堆栈跟踪的形式终止，这时我们可以根据需要添加 try/except 或者 try/finally 语句（或者它们的组合）进行处理。一般来说，有以下使用形式：
try...except...
try...except...else...
try...except...else...finally...
try...except...except...else...finally...
try...finally...
捕捉异常的基本形式是 try…except。
try:
x = input('Enter x: ')
y = input('Enter y: ')
print x / y
except ZeroDivisionError as e:
print 'Error:',e
print 'hello world'
当 y = 0 时，看看执行结果：
Enter x: 3
Enter y: 0
Error: integer division or modulo by zero
hello world
可以看到，我们的程序正确捕获了除以零的异常，而且程序没有以堆栈跟踪的形式终止，而是继续执行后面的代码，打印出 ‘hello world’。
多个 except 子句
有时，我们的程序可能会出现多个异常，这时可以用多个 except 子句来处理这种情况。让我们继续看第一个例子，如果 y 输入的是一个非数字的值，就会产生另外一个异常：
Enter x: 2
Enter y: 'a' # y 的输入是一个字符
----------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-209-d4666cfaefb4> in <module>()
2 x = input('Enter x: ')
3 y = input('Enter y: ')
----> 4 print x / y
5 except ZeroDivisionError as e:
6 print e
TypeError: unsupported operand type(s) for /: 'int' and 'str'
可以看到，当 y 输入一个字符 ‘a’ 之后，程序产生了一个 TypeError 异常，并且终止，这是因为我们的 except 子句只是捕获了 ZeroDivisionError 异常，为了能捕获TypeError 异常，我们可以再加一个 except 子句，完整代码如下：
try:
x = input('Enter x: ')
y = input('Enter y: ')
print x / y
except ZeroDivisionError as e: # 处理 ZeroDivisionError 异常
print 'ZeroDivisionError:',e
except TypeError as e: # 处理 TypeError 异常
print 'TypeError:',e
print 'hello world'
当 y 输入 ‘a’ 时，看看执行结果：
Enter x: 3
Enter y: 'a'
TypeError: unsupported operand type(s) for /: 'int' and 'str'
hello world
捕捉未知异常
事实上，在编写程序的时候，我们很难预料到程序的所有异常情况。比如，对于第一个例子，我们可以预料到一个 ZeroDivisionError 异常，如果细心一点，也会预料到一个 TypeError 异常，可是，还是有一些其他情况我们没有考虑到，比如在输入 x 的时候，我们直接按回车键，这时又会引发一个异常，程序也会随之挂掉：
Enter x: # 这里输入回车键
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
File "<string>", line 0
^
SyntaxError: unexpected EOF while parsing
那么，我们应该怎么在程序捕获某些难以预料的异常呢？我们在上文说过，Python 中所有的异常类都是从 BaseException 类派生的，也就是说，ZeroDivisionError、SyntaxError 等都是它的子类，因此，对于某些难以预料的异常，我们就可以使用 BaseException 来捕获，在大部分情况下，我们也可以使用 Exception 来捕获，因为 Exception 是大部分异常的父类，可以到这里查看所有异常类的继承关系。
因此，对于第一个例子，我们可以把程序做一些修改，使其更加健壮：
try:
x = input('Enter x: ')
y = input('Enter y: ')
print x / y
except ZeroDivisionError as e: # 捕获 ZeroDivisionError 异常
print 'ZeroDivisionError:',e
except TypeError as e: # 捕获 TypeError 异常
print 'TypeError:',e
except BaseException as e: # 捕获其他异常
print 'BaseException:',e
print 'hello world'
注意到，我们把 BaseException 写在了最后一个 except 子句。如果你把它写在了第一个 except 子句，由于 BaseException 是所有异常的父类，那么程序的所有异常都会被第一个 except 子句捕获。
else 子句
我们可以在 except 子句后面加一个 else 子句。当没有异常发生时，会自动执行 else 子句。
对第一个例子，加入 else 子句：
try:
x = input('Enter x: ')
y = input('Enter y: ')
print x / y
except ZeroDivisionError as e:
print 'ZeroDivisionError:',e
except TypeError as e:
print 'TypeError:',e
except BaseException as e:
print 'BaseException:',e
else:
print 'no error!'
print 'hello world'
看看执行结果：
Enter x: 6
Enter y: 2
3
no error!
hello world
finally 子句
finally 子句不管有没有出现异常都会被执行。
看看例子：
try:
x = 1/0
print x
finally:
print 'DONE'
执行结果：
DONE
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ZeroDivisionError: integer division or modulo by zero
再看一个例子：
try:
x = 1/0
print x
except ZeroDivisionError as e:
print 'ZeroDivisionError:',e
finally:
print 'DONE'
执行结果：
ZeroDivisionError: integer division or modulo by zero
DONE
使用 raise 手动引发异常
有时，我们使用 except 捕获了异常，又想把异常抛出去，这时可以使用 raise 语句。
try:
x = input('Enter x: ')
y = input('Enter y: ')
print x / y
except ZeroDivisionError as e:
print 'ZeroDivisionError:',e
except TypeError as e:
print 'TypeError:',e
except BaseException as e:
print 'BaseException:',e
raise # 使用 raise 抛出异常
else:
print 'no error!'
print 'hello world'
运行上面代码，当 x 输入一个回车键时，错误会被打印出来，并被抛出：
Enter x: # 这里输入回车键
BaseException: unexpected EOF while parsing (<string>, line 0)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
File "<string>", line 0
^
SyntaxError: unexpected EOF while parsing
上面的 raise 语句是不带参数的，它会把当前错误原样抛出。事实上，我们也创建自己的异常类，并抛出自定义的异常。