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，其余的逻辑错误应该尽可能修正