Python全栈之路系列----之-----异常处理

Python全栈之路系列之异常处理

初识异常处理

如下面的例子:

让用户进行输入，提示用户输入一个数字，如果输入的事一个数字那个就把输入的数字转换为int类型，然后输出用户输入的而数字，如果用户输入的不是一个数字，那么类型转换就会出错，如果出错，就提示用户”输入类型错误，你因该输入的是一个数字。”

基础语法:

try:
     被检测的代码块
except 异常类型：
     try中一旦检测到异常，就执行这个位置的逻辑

　　第一个例子:  as

　　# 关于一些异常的提示问题 你明确知道会发什么什么错 就不用as
　　# 在我们不能完全明确的知道这个错误到底是发生了什么的时候
　　# 就用as 变量名，将变量中存储的错误信息打印出来
　　# 但是不知道报什么错误的时候 就用as 把系统报的错打印出来

try:
    n = int(input("请输出一个数字>>> "))
    print("你输入的数字是",n)
# e是Exception的对象，Exception是一个类
except Exception as e:
    print("输入类型错误，你因该输入的是一个数字。")

请输出一个数字>>> 123
你输入的数字是 123

请输出一个数字>>> abc
输入类型错误，你因该输入的是一个数字。

如何查看和找到报错的异常

　　python解释器检测到错误，触发异常（也允许程序员自己触发异常)

　　　找到报错的是最后一行
　　# 排错的时候真正报错的是最下面
　　# 从下往上找最后一行 那个报错的地方
　　# python的自带代码是不会出错的

　　# 一个地方报错 其他地方不能用 程序不往下执行

       #异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。
　　# SyntaxError 语法错误 写代码执行前 就要处理完毕

异常处理的应用

# 异常处理的应用  1,可以用if规避 但是成本太高   各种判断
#               2,有些报错 不能用 if  处理了 StopIteration
# 异常处理的特点: 一旦发生异常,程序就不在执行

#放在try:中的代码如果遇到except中的错误类型,就会自行except中的代码
# 且一旦发生异常,try中的代码就会停在异常处
# 不影响try语句之外的代码执行
# except 监控一种错误类型只能处理对应的一种错误,其他错误还是会报错

第二个例子:

try:#一用就是一组   不能分开用
    num=input('num: ')
    int(num)
    print(num)# 一旦发生异常 就打印这句话

except ValueError: #触发这个异常就提示   如果没问题 就不执行
    print('输入一个数字')
print('aaaa')

多分支异常处理

　　可以写好多except 去监控各种异常的报错

　　第三个例子

# try:
#     num = input('num : ')
#     int(num)  # ValueError
#     print(num)
#     a
#     sum(1, 2, 3)
# except ValueError:
#     print('请输入一个数字')
# except NameError as nameerror:
#     print('产生了一个%s'%nameerror)
# except TypeError:
#     print('又一个错误诞生了')


多分支+Exception万能异常处理


s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
except Exception as e:
    print(e)

万能异常

　　万能异常报错处理 找到第一个能处理异常的 就不会走下面的异常处理
　　所以万能异常 一般都放在所有异常处理的最后面

　　#对于你已经可以预见的但是不能完全规避的必须要处理的异常，
　　# 你应该去指定他的处理方式
　　#对于其他你不能预料的，在使用万能异常处理

# try:
#     num = input('num : ')
#     int(num)  # ValueError
#     # b          #NameError
#     # sum(1,2,3)  #TypeError
#     # dic = {}
#     # dic['key']  #KeyError
#     l = []
#     l[1000]   #IndexError
#     l = [1,23]
#     l_iterator = iter(l)
#     next(l_iterator)
#     next(l_iterator)
#     next(l_iterator)  #StopIteration
# except ValueError:  #遇到能处理的 就不执行下面的万能异常处理
#     print('请输入一个数字')
# except Exception as e:    万能异常处理  并打印异常的信息
#     print(e)

异常的其他机构

　　其他机构包括 1.异常处理中的else语句 2.装饰器中的异常处理

　　3.finally 始终会执行的语句 4.assert(断言) 5.主动触发异常 和 自定义异常

1.异常处理中的else语句

# try:
#     a =1
# except NameError as e:
#     print(e)
# else:
#     print('当try语句中不会发生异常的时候执行else中的代码啦')

 2.装饰器中的异常处理

# def wrapper(func):
#     def inner(*args,**kwargs):
#         try:
#             return func(*args,**kwargs)
#         finally:
#             "被装饰的函数执行之后要执行的内容"
#     return inner

 3.finally 这个关键字下的内容是 始终会执行的语句 不管是否有return

#finally
# def func():
#     try:
#         f = open('file')
#         int(f.read())
#     except ValueError as e:
#         a = 123
#         return a
#     finally:       #清理的工作 把之前的打开的链接 文件 都关掉
#                    #避免因为程序异常造成的浪费资源和逻辑问题
#         f.close()
#
# print(func())

4.assert  断言

如果条件成立则成立，如果条件不成立则报错。

assert 1 == 1  不报错 并且执行下面的代码
assert 1 == 2  直接报错 并且绕不过这个错误,不执行下面的任何代码

5.主动触发异常 和 自定义异常

　　如果需要捕获和处理一个异常，又不希望异常在程序中死掉，一般都会利用raise传递异常

　　用户自定义的异常通过类编写，且通常需要继承Exception内置的异常类，基于类的异常允许脚本建立异常类型、继承行为以及附加状态信息。

主动触发异常
try:
　　 # raise表示主动出发异常，然后创建一个Exception对象，Exception括号内的值就是Exception对象的值
    raise TypeError('类型错误'"主动出发的异常")
except Exception as e:
　　　　# 输出Exception对象的值
    print(e)



自定义异常
class EvaException(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

try:
    raise EvaException('类型错误')
except EvaException as e:
    print(e)

自定义异常

>>> class Bar(Exception):
...     pass
... 
>>> 
>>> def doomed():
...     raise Bar()
... 
>>> 
>>> try:
...     doomed()
... except Bar as e:
...     print('error')
... 
error


自定义异常

>>> class MyError(Exception):
...     def __str__(self):
...         return '出错啦.'
... 
>>> try:
...     raise MyError()
... except MyError as e:
...     print(e)
... 
出错啦.

错误异常的基本结构

try:
    # 主代码块
    pass
except KeyError as e:
    # 异常时，执行该块
    pass
else:
    # 主代码块执行完，执行该块
    pass
finally:
    # 无论异常与否，最终执行该块
    pass

执行流程：

1. 如果出现错误，那么就执行except代码块，然后在执行finally
2. 如果没有出现错误，那么就执行else代码块，然后再执行finally
3. 不管有没有出现异常都会执行finally

异常分类

常用异常

异常名	说明
AttributeError	试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError	输入/输出异常；基本上是无法打开文件
ImportError	无法引入模块或包；基本上是路径问题或名称错误
IndentationError	语法错误（的子类） ；代码没有正确对齐
IndexError	下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError	试图访问字典里不存在的键
KeyboardInterrupt	Ctrl+C被按下
NameError	使用一个还未被赋予对象的变量
SyntaxError	Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError	传入对象类型与要求的不符合
UnboundLocalError	试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
ValueError	传入一个调用者不期望的值，即使值的类型是正确的

总结

try.. ........   except

这种异常处理机制就是取代if那种方式，让你的程序在不牺牲可读性的前提下增强健壮性和容错性

异常处理中为每一个异常定制了异常类型（python中统一了类与类型，类型即类），对于同一种异常，一个except就可以捕捉到，可以同时处理多段代码的异常（无需‘写多个if判断式’）减少了代码，增强了可读性 

使用try..except的方式

1：把错误处理和真正的工作分开来
2：代码更易组织，更清晰，复杂的工作任务更容易实现；
3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；

4:try...except应该尽量少用，因为它本身就是你附加给你的程序的一种异常处理的逻辑

5:这种东西加的多了，会导致你的代码可读性变差，只有在有些异常无法预知的情况下，才应该加上try...except，其他的逻辑错误应该尽量修正