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子句最终都会执行