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都会执行