Python 异常处理

一、异常
1.1 异常介绍
异常就是程序运行时发生错误的信号，在python中,错误触发的异常如下：

1.2 异常种类
在python中不同的异常可以用不同的类型（python中统一了类与类型，类型即类）去标识，不同的类对象标识不同的异常，一个异常标识一种错误

1 # 触发IndexError
2 l=[‘egon’,‘aa’]
3 l[3]
4
5 # 触发KeyError
6 dic={‘name’:‘egon’}
7 dic[‘age’]
8
9 # 触发ValueError
10 s=‘hello’
11 int(s)
常用异常
更多异常
二、 异常处理
2.1 什么是异常处理
python解释器检测到错误，触发异常（也允许程序员自己触发异常）
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理.
2.2 为什么要进行异常处理
python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。
所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性
2.3 基本语法：
try:
被检测的代码块
except 异常类型：
try中一旦检测到异常，就执行这个位置的逻辑
1 try:
2 print(’-----test–1—’)
3 open(‘123.txt’,‘r’)
4 print(’-----test–2—’)
5 except IOError:
6 pass
异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

1 # 未捕获到异常，程序直接报错
2 s1 = ‘hello’
3 try:
4 int(s1)
5 except IndexError as e:
6 print e
2.3.1 多分支异常

1 s1 = ‘hello’
2 try:
3 int(s1)
4 except IndexError as e:
5 print(e)
6 except KeyError as e:
7 print(e)
8 except ValueError as e:
9 print(e)

2.3.2 万能异常
在python的异常中，有一个万能异常：Exception，他可以捕获任意异常

1 s1 = ‘hello’
2 try:
3 int(s1)
4 except Exception as e:
5 print(e)
多分支+Exception：

1 s1 = ‘hello’
2 try:
3 int(s1)
4 except IndexError as e:
5 print(e)
6 except KeyError as e:
7 print(e)
8 except ValueError as e:
9 print(e)
10 except Exception as e:
11 print(e)

主动触发异常

1 try:
2 raise TypeError(‘类型错误’)
3 except Exception as e:
4 print(e)
2.3.3 else
咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try…except…中也是如此，即如果没有捕获到异常，那么就执行else中的事情

1 try:
2 num = 100
3 print num
4 except NameError as errorMsg:
5 print(‘产生错误了:%s’%errorMsg)
6 else:
7 print(‘没有捕获到异常，真高兴’)

运行结果如下：

2.3.4 try…finally…
try…finally…语句用来表达这样的情况：在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
1 import time
2 try:
3 f = open(‘test.txt’)
4 try:
5 while True:
6 content = f.readline()
7 if len(content) == 0:
8 break
9 time.sleep(2)
10 print(content)
11 except:
12 #如果在读取文件的过程中，产生了异常，那么就会捕获到
13 #比如 按下了 ctrl+c
14 pass
15 finally:
16 f.close()
17 print(‘关闭文件’)
18 except:
19 print(“没有这个文件”)
2.3.5 异常的传递
try嵌套：

1 import time
2
3 try:
4 f = open(‘demo1.py’)
5 try:
6 while True:
7 content = f.readline()
8 if len(content) == 0:
9 break
10 time.sleep(2)
11 print(content)
12 finally:
13 f.close()
14 print(‘关闭文件’)
15 except:
16 print(“没有这个文件”)
17
18 # 结果
19 # 关闭文件
20 # 没有这个文件
函数嵌套调用：

1 def test1():
2 print("----test1-1----")
3 print(num)
4 print("----test1-2----")
5
6
7 def test2():
8 print("----test2-1----")
9 test1()
10 print("----test2-2----")
11
12
13 def test3():
14 try:
15 print("----test3-1----")
16 test1()
17 print("----test3-2----")
18 except Exception as result:
19 print(“捕获到了异常，信息是:%s”%result)
20
21 print("----test3-2----")
22
23
24
25 test3()
26 print("------华丽的分割线-----")
27 test2()

运行结果：

总结：

如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。。。
如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样
注意观察上图中，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行
2.3.6 自定义异常
1 class ShortInputException(Exception):
2 ‘’‘自定义的异常类’’’
3 def init(self, length, atleast):
4 #super().init()　　# 可调用也可不调用，建议先调用
5 self.length = length
6 self.atleast = atleast
7
8 def main():
9 try:
10 s = input('请输入 --> ')
11 if len(s) < 3:
12 # raise引发一个你定义的异常
13 raise ShortInputException(len(s), 3)
14 except ShortInputException as result:#x这个变量被绑定到了错误的实例
15 print(‘ShortInputException: 输入的长度是 %d,长度至少应是 %d’% (result.length, result.atleast))
16 else:
17 print(‘没有异常发生.’)
18
19 main()