Python中异常处理

异常Exception

错误 Error 逻辑错误：算法写错 笔误：变量名写错，笔误 函数或者类使用错误 错误可以避免异常 Exception 本意就是意外情况 这有个前提，没有出现上面说的错误，也就是说程序写的没有问题，但是在某些情况下，会出现一些意外，导致程序无法正常的执行下去 异常无法避免 错误和异常：在高级编程语言中，一般都有错误和异常的概念，异常是可以捕获的，并被处理的，但是错误是不能被捕获的 一个健壮的程序 尽可能的避免错误 尽可能的捕获、处理各种异常

产生异常

产生：

raise语句显示的抛出异常Python解释器自己检测到异常并引发它 def foo(): print(1/0) def f(): raise Exception('error')

程序会在异常抛出的地方中断执行，如果不捕获，会提前结束程序

异常的捕获

try: 待捕获异常的代码块 except[异常类型]: 异常的处理代码块 def foo(): try: c=1/0 except: print('error') print('+++++++++') foo() print('+======')

上例执行到c=1/0时产生异常并抛出，由于使用了try……except语句块则捕捉到了这个异常，异常生成位置之后语句将不再执行，转而执行对应的except部分的语句，最后执行try……except语句块之外的语句。

捕获指定类型的异常

异常类及继承层次

BaseException及子类

BaseException: 所有内建异常类的基类是BaseException SystemExit systemExit sys.exit()函数引发的异常，异常不捕获处理，就直接交给Python解释器，解释器退出

import sys print('before') sys.exit(1) print(3)

import sys try: sys.exit(1) except SystemExit: print('sysExit') print('123')

如果except语句捕获了该异常，则继续向后面执行，如果没有捕获该异常SystemExit,解释器直接退出程序。 没有捕获到程序直接停止，捕获到相当于能够正常执行后面的程序。

Exception及子类

Exception是所有内建的、非系统退出的异常的基类，自定义异常类应该继承自它

syntaxError语法错误 Python将这种错误也归到异常类下面的Exception下的子类，但是这种错误是不可捕获的 def a(): try: 0a=5 except: pass

ArithmeticError 所有算术计算引发的异常，其子类有除零异常等LookupError 使用映射的键或序列的索引无效时引发的异常的基类：indexError,KeyError自定义异常类 从Exception继承的类 class My(Exception): pass try: raise My() except My: print('Error')

多种捕获

except可以指定捕获的类型，捕获多种异常

import sys class My(Exception): pass try: a=1/0 raise My() open('t') sys.exit(1) except ZeroDivisionError: print('zero') except ArithmeticError: print('arith') except My: print('My') except Exception: print('all') except: print('sys')

捕获规则：

捕获是从上到下依次捕获，如果匹配，则执行匹配的except语句块如果被一个except语句捕获，其他except语句就不会再次捕获了如果没有任何一个except语句捕获到这个异常，则该异常向外抛出从小到大，从具体到宽泛

as子句

class My(Exception): def __init__(self,code,message): self.code=code self.message=message try: raise My(200,'ok') except My as e: print('My') except Exception as e: print('{}'.format(e))

raise 语句 raise后要求应该是BaseException类的子类或实例，如果是类，将被无参实例化 raise后什么都没有，表示抛出最近一个被激活的异常，如果没有被激活的异常，则抛类性异常。

finally子句

finally，最终，即最后一定要执行的，try……finally语句块中，不管是否发生了异常，都要执行finally的部分

try: f=open('2.txt') except FileNotFoundError as e: print(e.__class__,e.errno,e,strerror) finally: print('finally') f.close()

在finally中再次捕捉异常

try: f=open('2.txt') except Exception as e: print(e) finally: try: f.close() except Exception as e: print(e)

finally执行时机

def foo(): try: return 3 finally: return 5 print('finally') print('==') print(foo())

进入rty,执行return 3，虽然函数要返回，但是finally一定还要执行，所以执行return 5，函数返回，5被压在栈顶，所以返回5，简单说，函数的返回值取决于最后一个执行的return语句，而finally则是try……finally中最后执行的语句块

异常的传递

def foo1(): return 1/0 def foo2(): print('foo2 start') foo1() print('foo2 stop') foo2()

foo2调用了foo1，foo1产生的异常，传递到了foo2中。 异常总是向外层抛出，如果外层没有处理这个异常，就继续向外抛出 如果内层捕获并处理了该异常，外部就不能捕获到了 如果到了最外层还是没有被处理，就会中断异常所在线程的执行，注意整个程序结束的状态返回值

import threading import time def foo1(): return 1/0 def foo2(): time.sleep(2) print('foo2 start') foo1() print('foo2 stop') t=threading.Thread(target=foo2) t.start() while True: time.sleep(1) print('ok') print('threading.enumerate()')

try嵌套

try: try: ret=1/0 except KeyError as e: print(e) finally: print('inner fin') except: print('outer catch') finally: print('outer fin')

内部捕获不到异常，会向外层传递异常 但是如果内层有finally且其中有return、break语句，则异常就不会继续向外抛出

异常捕获的时机

1、立即捕获 需要立即返回一个明确的结果

def parse_init(s): try: return int(s) except: return 0 print(parse_init('s'))

2、边界捕获 封装产生了边界

else子句

try: ret=1*0 except ArithmeticError as e: print(e) else: print('ok') finally: print('fin')

else子句 没有任何异常发生，则执行

总结

try: <语句> 运行别的代码 except <异常类>: <语句> #捕获某种类型的异常 except <异常类> as <变量名>: <语句> #捕获某种类型的异常并获得对象 else: <语句> #如果没有异常产生 finally： <语句> #退出try时总会执行

try的工作原理 1、如果try中语句执行时发生异常，搜索except子句，并执行第一个匹配该异常的except子句 2、如果try中语句执行时发生异常，却没有匹配的except子句，异常将被递交到外层的try，如果外层不处理这个异常，异常将继续想外层传递，如果都不处理该异常，则会传递到最外层，如果还没有处理，就终止异常所在的线程 3、如果在try执行时没有发生异常，如有else子句，可执行else子句中的语句 4、无论try中是否发生异常，finally子句最终都会执行