python中的异常处理

异常 Exception

错误 Error 是可以避免的，异常Exception 是不可避免的

错误和异常
在高级编程语言中，一般都有错误和异常的概念，异常是可以捕获，并被处理的，但是错误是不能被捕获的,所以一个健壮的程序要尽可能的捕获，处理各种异常

产生异常:

• raise语句显式的抛出异常
• python解释器自己检测到异常并引发它
• 语法错误不会捕获

try:
待捕获异常的代码块
except [异常类型]: # 做的是类型匹配，什么都不写的话代表什么都可捕获
异常的处理代码块
except # 相当于异常的分支捕获。异常一旦被捕获，就不会再被其他异常捕获

try:
    print('begin')
    c = 1 / 0  # 遇到异常之后跳到异常处理，异常之后的句子不在执行
    print('end')
except:
    print('cant') # 异常处理结束完之后，最后执行外部try,except外的函数
print('outer')

---

捕获指定类型的异常

例子：

try:
    print('begin')
    c = 1 / 0  # 遇到异常之后跳到异常处理
    print('end')

except ArithmeticError:  # 算术错误捕获
    print('cant')
print('outer')

#2
class A:pass
try: #1/0
    raise 1
    # raise 'abc'
    # raise {}
    # raise A
    # raise A()
except:
    print('catch the exception')
#例子可以看到raise好像什么类型都能抛出，但是我们用上as字句可能会很不一样

as 字句

被抛出的异常，应该是异常的实例。用as字句可以获得这个对象，相当于将名字重新命名 except Exception as e:
#Exceptio = 异常，自定义异常类要从Exception为父类开始

class MyException(Exception): # 从Exception继承的类，自定义异常
    def __init__(self, code, message):
        self.code = code
        self.message = message
try:
    raise MyException
except MyException as e:
    # print(e.code, e.message)
    print('MyException = {} {}'.format(e.code, e.message))
except Exception as e:
    print('11',e)

raise 后跟的类名是无参构造实例，所以需要两个参数，且这个语句不会报错 由此得到raise的错误类型都是不一样的

---

BaseException及子类
BaseException所有内建异常类的基类是BaseException
进程检测的话要注意状态码，如果不是0 都是表示异常。
import sys 函数里的sys.exit（）引发的异常，只能由SystemExit接到，用 Exception捕捉不到，捕捉不到解释器直接退出程序，不执行程序后的outer

import sys

print('before')
try:
    sys.exit(1)
# except SystemExit:
except Exception:
# except Exception as e:
    print('sysexit')
print('outer')

# KeyboardInterrupt 对应捕获用户中断行为Ctrl + c
try:
    import time

    while True:
        time.sleep(0.5)
        print('1')
        pass
except KeyboardInterrupt: # 相当于捕获到中断程序的异常
    print('ctl + c')
print('outer')

---

异常捕获：

捕获规则：

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

class Myex(Exception):
    pass


try:
   # raise Myex()
   #  a = 1 / 0
    open('a1.txt')
except Myex:
    print('catch the MyException')
except ZeroDivisionError:
    print('1/0')
except Exception:
    print('Exception')

---

finally字句

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

try:
    f = open('text.txt')
except FileNotFoundError as e:
    print(e)
finally:
    print('end')
    f.close() # 会报错，Nameerror
    
# 可以在finally 再次捕捉异常
try:
    f = open('text.txt')
except FileNotFoundError as e:
    print(e)
finally:
    print('end')
    try:
        f.close()
    except NameError as e:
        print(e)
 
## 又或者用if 的方法
f = None
try:
    f = open('text.txt')
except FileNotFoundError as e:
    print(e)
finally:
    print('end')
    if f:
        f.close()
        
# 例子：finally 的执行时机
def foo():
    try:
        return 3
    finally:
        print('finally') # 遇到finally 会先输出，然后再输出 3
    print('==') # 不执行
print(foo())

def foo(): # 只输出finally 的return 
    #
    try:
        return 3
    finally:
        return 5 
    print('==')
print(foo())

---

异常的传递：

先看例子：

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

# 线程中测试异常
import threading  # 引入线程
import time
def foo1():
    return 1 / 0
def foo2():
    time.sleep(3) # 3秒后抛出异常
    print('begin')
    foo1()
    print('end')
t = threading.Thread(target=foo2)
t.start()
while True:
    time.sleep(1)
    print('OK')
    if t.is_alive():  # 判断是不是活着的线程
        print('alive')
    else:
        print(dead)

线程不是主线程的话，有异常的。主线程不会挂

---

try嵌套

try:
    try:
        ret = 1 / 0
    except KeyError as e:
        print(e)
    finally: # 遇到finally会先执行,如果有retrun 或者break语句，则异常不会继续向外抛出
        print('funny')
except:  # 内部捕获不到异常，会向外层传递异常
    print('outer catch')
finally:
    print('outer fin')
 
# 遇到finally会先执行,如果有retrun 或者break语句，则异常不会继续向外抛出
def foo():
    try:
        return 1 / 0
    except KeyError as e:
        print(e)
    finally:
        print('inner')
        return  # 异常被抛弃
try:
    foo()
except KeyError as e:
    print('outer')
finally:
    print('outer fin')

---

else字句，不出异常的时候可以执行

try:
    ret = 1 * 0 # 可以换成 1/0 看看
except ArithmeticError as e:
    print(e)
else:
    print('OK')
finally:
    print('fin')

---

总结：

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