chapter10.1、异常处理
异常处理
异常Exception
错误 Error
逻辑错误:算法写错了,
笔误:变量名错误或者语法错误
函数或类使用错误,也属于逻辑错误
大部分的错误都可以避免
异常Exception
本意就是意外情况,在没有错误的前提下,在某些情况下,会有意外,导致程序无法正常执行下去
例如open文件,已存在或已经创建,就是异常,或者访问网络文件,断网了,也是异常,本身就是意外。
异常不可避免
异常和错误
在高级编程语言中,一般都有错误和异常的概念,异常可以被捕获,错误不能被捕捉
python中错误也放在异常中,但是一般其他语言不会,错误无法捕获。
一个健壮得程序,尽可能避免错误,尽可能捕获处理各种异常
异常的产生
raise语句,抛出异常
python解释器执行时,检测到异常并引发它,例如除零异常
异常会在异常抛出的地方中断执行,如果不捕获,就会提前结束程序(其实是终止当前线程的执行)
raise后什么都没有,表示抛除最近得一个被激活的异常,
raise 后要求放BaseException类的子类或者实例,如果是类,将被无参实例化,无参构造器
异常的捕获
try:
待捕获的异常代码块
except [异常类型]:
异常的处理代码块
try: print('______') c = 1/0 print('!!!!!!') except: print('catch the exception') print('*******')
在异常处中断执行,处理异常,异常后的语句不在执行,只在第一个异常中断处抛出异常,其他语句不在执行,转而执行对应的except的语句,最后执行try...except外的语句。
可以捕获特定异常
try: print('______') c = 1/0 print('!!!!!!') except ArithmeticError: print('catch the exception') print('*******')
健壮性,优先于代码好看
异常类及继承层次
BaseException 所有内建的异常的基类
SystemExit 抛出系统异常,退出当前进程,
sys.exit() 函数引发该异常,异常不捕获处理,就交给解释器,解释器退出
如果except语句捕获了该异常,则继续向后执行,如果没有捕获该异常,解释器直接退出程序
返回的值非零,表示异常,0为正常
KeyboardInterrupt 对应捕获用户中断行为,以下是Ctrl + C
try: import time while True: time.sleep(2) print('!!!!!') except KeyboardInterrupt:##键盘打断方式是ctrl+c print('stop') print('outer')
直接执行以上文件,在控制台测试,
GeneratorExit 捕获迭代器退出异常
Exception 所有内建的,非系统退出的异常的基类,自定义的异常应该继承自它
SyntaxError 语法出错误,无法捕获
LookupError 使用映射的键或者序列的索引无效时引发的异常的基类IndexError,KeyError
ArithmeticError 所有算数计算引发的异常,除零异常是其子类
异常的捕获
except可以捕获多个异常
class MyException(BaseException): pass try: a = 1/0 raise MyException ##自定义的类 open('aaaa.txt') ##无法执行 except MyException: print('catch the MyException') except ZeroDivisionError: print('1/0') except Exception: print('Exception')
捕获规则
捕获是从上到下依次比较,如果匹配,则执行匹配的except语句块
如果被其中一个except捕获,其他的except语句就不会再次捕获了
如果没有任何一个except语句捕获到这个异常,则该异常向外抛出
捕获原则
从小到大,从具体到宽泛
多个异常的接收,会相互干扰,父类放下边(越具体的类型越往上写)
as子句
被抛出的异常,是异常的实例,使用as子句获得该对象
class MyException(BaseException): def __init__(self,code,message): self.code = code self.message = message try: raise MyException ##自定义的类,raise后跟类名,是无参构造实例 except MyException as e: print('MyException = {} {}'.format(e.code,e.message)) except Exception as e: print('Exception = {}'.format(e))
raise 后跟类名是无参构造实例,而自建的类没有设置缺省值,因此需要2个参数,可以改为
class MyException(BaseException): def __init__(self,code,message): self.code = code self.message = message try: raise MyException(100,'wrong gagaga') ##自定义的类,raise后跟 except MyException as e: print('MyException = {}: {}'.format(e.code,e.message)) except Exception as e: print('Exception = {}'.format(e))
finally子句
try...finally子句中,最后一定会执行的,不管语句中是否有异常,都要执行finally部分
f = None ##解决作用域问题 try: f = open('test111.txt') except FileNotFoundError as e: print('{} {} {}'.format(e.__class__,e.errno,e.strerror)) finally: print('qingli') if f: f.close()
在finally中,可以作为最后一道关卡,释放资源,解决异常,当然,解决不了就抛出给外层。
try: f = open('test111.txt') except Exception as e: print('{}'.format(e)) finally: print('qingli') try: f.close() except NameError as e: print(e)
def foo(): try: return 3 finally: print('finally') print('====') print(foo())
以上函数,虽然return已经执行,得到了3,但是还是会执行finally语句,所以打印了finally才退出
def bar(): try: return 3 finally: return 5 print("===") print(bar())
以上函数,先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
异常是向外传递的,如果外层没有处理这个异常,就会继续向外抛出
如果内层捕获了异常,外部就捕获不到了
异常向外传递到线程,都没有处理,会导致异常所在的线程崩溃,如果该线程是工作线程,会导致很大的问题,所以异常要处理,但也不能随意压制
def foo2(): time.sleep(3) print('foo start') foo() print('foo2 stop') t = threading.Thread(target=foo2) t.start() while True: time.sleep(1) print('All ok') if t.is_alive(): print('alive') else: print('dead')
异常产生后,线程结束。
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语句,则异常就不会继续向外抛出:
def foo(): try: ret = 1 / 0 except KeyError as e: print(e) finally: print('inner fin ') return #return 会压制异常,不向外传递 try: foo() except: print('outer catch') finally: print('outer fin')
异常的捕获时机
立即捕获
需要立即返回一个明确的结果
def parse_int(s): try: return int(s) except: return 0 print(parse_int('s'))
边界捕获
封装产生了边界
比如open函数,用户使用时,模块内部捕获了文件存在或不存在,它如果不返回异常,内部处理了,那我们就无法感知。
如果写一个类,里边调用了open,但出现异常,不知道如何处理,就继续向外抛出,一般来说最外层也是边界,必须处理这个异常,否则线程退出。
else子句
没有异常发生,就执行else
总结:
try: <语句> #运行其他代码 except <异常类> : <语句> #捕获某种类型的异常 except<异常类> as <变量名>: <语句> #捕获某种类型的异常,并获得对象 else: <语句> #没有异常就执行 finally: <语句> #退出时一定会执行
try工作原理
1、如果try语句执行时发生异常,搜索except子句,并执行第一个匹配该异常的子句
2、如果发生异常,却没有匹配except子句,那就会交到外层的try,如果外层不处理这个异常,就继续向外层传递,直到到达边界,再不处理就终止异常所在的线程
3、如果没有发生异常,将执行else子句的语句
4、无论是否发生异常,finally都会执行