python-异常处理

错误和异常的区别

错误 Error

• 逻辑错误:算法写错了，加法写成了减法
• 笔误:变量名写错了，语法错误
• 函数或类使用错误，其实这也属于逻辑错误

错误是可以避免的

异常Exception
程序正确，但是在某些特殊情况下，导致程序无法正常的执行下去。例如open函数操作一个文件，文件不存在，或者创建一个文件时该文件已经存在了，或者访问一个网络文件，突然断网了，这就是异常

异常不能避免

在高级编程语言中，一般都有错误和异常的概念，异常是可以捕获，并被处理的，但是错误是不能被捕获的。

一个健壮的程序尽可能的避免错误，尽可能的捕获、处理各种异常

产生异常

• raise语句显式的抛出异常
• Python解释器自己检测到异常并引发它

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

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

def t():
    print("before")
    def abc():
       print(1/0)
    abc()
    print("after")
t()

def abc():
    print("before")
    raise Exception("my exception")
    print("after")
abc()

捕获异常

try:
    待捕获异常的代码块

except [异常类型]:

    异常的处理代码块

try:
    a = 1/0
except ZeroDivisionError:
    print("除零错误")

except可以捕获多种异常

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

try:
    a = 1/0
except ZeroDivisionError:
    print("除零错误")
except AttributeError:
    pass
except AssertionError:
    pass
except Exception:
    pass

异常捕获时机

• 立即捕获：需要立即返回一个明确的结果
• 边界捕获：封装产生了边界，例如，open函数，出现的异常交给调用者处理，文件存在了，就不用再创建了，看是否修改还是删除

异常类及继承层次

#python异常继承
BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

BaseException及子类

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

Keyboardlnterrupt：对应的捕获用户中断行为Ctrl+C

Exception及子类
Exception是所有内建的、非系统退出的异常的基类，自定义异常应该继承自它
SyntaxError：语法错误，Python将这种错误也归到异常类下面的Exception下的子类，但是这种错误是不可捕获的

ArithmeticError所有算术计算引发的异常，其子类有除零异常等
LookupError
使用映射的键或序列的索引无效时引发的异常的基类:IndexError,KeyError

自定义异常：从Exception继承的类

class myException(Exception):
    print("这是一个异常")

try:
    print("begin")
    raise myException
except myException:
    print("自定义异常")
except Exception:
    pass

as语句

用as语句保存被捕获的异常

try:
    a = 1/0
except ZeroDivisionError as e:
    print("除零错误")
    print(e)

except Exception:
    pass

finally语句

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

 finally中一般放置资源的清理、释放工作的语句

也可以在finally中再次捕捉异常

try:
    a = 1/0
except ZeroDivisionError as e:
    print("除零异常")
    print(e)

except Exception:
    pass
finally:
    try:
        b = 2/0
    except ZeroDivisionError:
        print("finally 除零异常")
    print("finally")

else语句

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

try:
    a = 4/2
except ZeroDivisionError:
    print("除零异常")
else:
    print("无异常")

异常的传递

def f1():
    return 1/0

def f2():
    print("begin")
    f1()
    print("end")

f2()

异常总是向外层抛出，如果外层没有处理这个异常，就会继续向外抛出

如果内层捕获并处理了异常，外部就不能捕获到了

如果到了最外层还是没有被处理，就会中断异常所在的线程的执行

try嵌套

def f():
    try:
        r = 1/0
    except KeyError as e:
        print(e)
    finally:
        print("inner")

try:
    f()
except:
    print("outer catch")
finally:
    print("outer end")

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

总结：

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

try的工作原理

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