正文
13.python错误和异常
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
一.错误和异常
1.错误(Error)：程序中的错误分为俩种
第一种语法错误：不按照语言的规则，必须在程序执行前就改正
第二种逻辑错误：算法写错了，加法写成了减法，函数或类使用错误，其实这也属于逻辑错误
2.异常(Exception)：就是程序运行时发生错误的信号，本身就是意外情况，这有个前提，没有出现上面说的错误，也就是说程序写的没有问题，但是在某些情况下，会出现一些意外，导致程序无法正常的执行下去。
(1)例如open函数操作一个文件，文件不存在，或者创建一个文件时已经存在了，或者访问一个网络文件，突然断网了，这就是异常，是个意外的情况，异常不可能避免。
(2)分为三部分
①Traceback：异常追踪的信息
②NameError：
③NameError异常类后面的是：异常值
3.错误和异常：在高级编程语言中，一般都有错误和异常的概念，异常是可以捕获，并被处理的，但是错误是不能被捕获的
(1)异常
with open('testabc') as f:
pass##异常
Traceback (most recent call last):
File "test2.py", line 1, in <module>
with open('testabc') as f:
FileNotFoundError: [Errno 2] No such file or directory: 'testabc'
(2)错误
def 0A():
pass##错误：
def 0A():
^
SyntaxError: invalid syntax
总结：一个健壮的程序，尽可能的避免错误，尽可能的捕获，处理各种异常
4.python中的常用的异常种类
在python中不同的异常可以用不同的类型(python中统一了类与类型，类型即类)去标识，不同的类对象标识不同的异常，一个异常标识一种错误
AttributeError：视图访问一个对象没有属性，比如foo.x，但是foo没有属性x
IOError：输入/输出操作失败(基本上是无法打开文件)
TypeError：传入对象类型与要求的不符合
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
5.异常类及继承层次
python异常的继承
BaseException[所有内建异常类的基类]
+--SystemExit[sys.exit()函数引发的异常，异常不捕获处理，就直接交给python解释器，解释器退出]
+--KeyboardInterrupt[对应的捕获用户中断行为Ctrl+c]
+--GeneratorExit
+--Exception[是所有内建的，非系统退出的异常的基类，自定义异常应该继承自它]
+--自定义异常[从Exception继承的类]
+--RuntimeError
+RecursionError
+--MemoryError
+--NameError[异常类(错误的类型)]
+--StopIteration
+--StopAsyncIteration
+--ArithmeticError[所有算术计算引发的异常，其子类的除零异常等]
+--FloatingPointError
+--OverflowError
+--ZeroDivisionError
+--LookupError[使用映射的键或序列的索引无效时引发的异常的基类：IndexError,KeyError]
+--IndexError
+--KeyError
+--SyntaxError[语法错误:Python将这种错误也归到异常类下面的Exception下的子类，但是这种错误是不可捕获的]
+--OSError
+--BlockingIOError
+--ChildProcessError
+--ConnectionError
+--BrokenPipeError
+--ConnectionAbortedError
+--ConnectionRefusedError
+--ConnectionResetError
+--FileExistsError
+--FileNotFoundError
+--InterruptedError
+--InterruptedError
+--IsADirectoryError
+--NotADirectoryError
+--PermissionError
+--PermissionError
+--ProcessLookupError
+--TimeoutError
6.异常处理
(1)异常处理：把产生的异常捕捉到，进入另外一个处理分支，执行你为其制定的逻辑，使程序不会崩溃，这就是异常处理
(2)为何要进行异常处理：当触发异常后且没有被处理的情况下，程序就在当前异常终止，后面的代码不会运行，所以必须提供一种异常处理机制来增强你的程序健壮性与容错性
(3)异常是由程序的错误引起的，语法上的错误跟异常处理无关，必须在程序运行前就修正
二.异常处理
方式一：if处理异常
#第一段代码
age=input('>>: ')
if age.isdigit():
int(age) #主逻辑：如果用户输入是数字才会运行主逻辑elif age.isspace(): #如果用户输入空格
print('用户输入的空格')
elif len(age) == 0: #如果用户输入空
print('用户输入的为空')
else: #如果用户输入除数字其它
print('其他的非法输入')#第二段代码
num2=input('>>: ')
if num2.isdigit():
int(num2) #主逻辑
elif num2.isspace():
print('---->用户输入的空格')
elif len(num2) == 0:
print('----》用户输入的为空')
else:
print('其他的非法输入')
总结：
(1)if做异常处理只能针对一段代码，对于不同的代码段的相同类型的错误你需要重复的if来进行处理。
(2)在你的程序中频繁的写与程序本身无关，与异常处理有关的if
方式二：try...except：python为每一种异常定制了一个类型，然后提供一种特定的语法结构用来进行异常处理
1.基本语法：
try:
被检测的代码块
except [异常类型]:
异常的处理代码块 #try中一旦检测到异常，就执行这个位置的逻辑
举例：
try:
#产生异常
1/0
#产生异常后下面不执行
print('after')
#交给except处理
except:
print('exception') #打印结果：exception
总结：
上例子执行到1/0时产生异常并抛出，由于使用了try...except语句块则捕捉到了这个异常，异常生成位置之后语句将不再执行，转而执行对应的except部分的语句，最后执行try...except语句块之外的语句。
使用try..except的方式的好处：
①把错误处理和真正的工作分开
②代码更易组织，更清晰，复杂的工作任务更容易实现
③更安全，不至于由一些小的疏忽而使程序意外崩溃了
2.as子句：
try:
#主逻辑1输出整型
age=input('1>>: ')
int(age) #主逻辑2输出整型
num2=input('2>>: ')
int(num2)#except捕捉ValueError俩段代码同一种异常把取名字为e
except ValueError as e:
#在哪个位置引发异常异常会被except捕捉到，如果能捕捉到就会执行except以下的代码，直接打印捕捉的异常错误，如果捕捉不到程序蹦掉
print(e)
主逻辑1当输入123时候是整型没报错继续往下执行
1>>: 123
主逻辑2输入abc不是整型抛出异常被except捕捉到
2>>: abc
打印捕捉到的错误：invalid literal for int() with base 10: 'abc'
3.异常的捕获：except可以捕获多个异常
(1)如果你想要的效果是，无论出现什么异常，我们统一丢弃，或者使用同一段代码逻辑去处理他们，只有一个Exception万能异常就足够了
(2)如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支
s1 = 'xixi'
#s1=1
try:
int(s1)
#多分支异常1
except IndexError as e:
print(e)#多分支异常2
except KeyError as e:
print(e)#多分支异常3：捕获到异常
except ValueError as e:
print(e) #捕获到异常打印：invalid literal for int() with base 10: 'xixi'#多分支万能异常其他没有考虑到的
except Exception as e:
print(e)
捕获规则总结：
①捕获是从上到下依次比较，如果匹配，则执行匹配的except语句块
②如果被一个except语句捕获，其他except语句就不会再次捕获了
③如果没有任何一个except语句捕获到这个异常，则该异常向外抛出
捕获的原则：
①从小到大，从具体到宽泛
4.主动触发异常(raise)
(1)raise后什么都没有，表示抛出最近一个被激活的异常，入股没有被激活的异常，则抛类型异常。
(2)raise后要求应该是BaseException类的子类或实例，如果是类，将被无参实例化。
try:
#python提供一堆类型就是类,类加上括号进行实例化，raise可以TypeError加一个括号传值进去
raise TypeError('类型错误')
except Exception as xi:
print(xi) #打印结果：类型错误
5.自定义异常类：
#自定义异常就是在写一个类,这个类就是XiXiException这个异常，自定义异常必须继承Exception这个类
class XiXiException(Exception):
pass#主动触发异常用raise触发
try:
#raise主动触发自定制的异常类XiXiException实例化产生的异常对象
raise XiXiException('自定制异常')#except捕捉到这个异常
except XiXiException as xixi:
print(xixi) #打印结果：自定制异常
6.异常的捕获时机
(1)立即捕获：需要立即返回一个明确的结果
def parse_int(s):
try:
return int(s)
#立即捕获异常
except:
#返回异常结果
return 0#正常传整数调用函数：
print(parse_int(123)) #返回结果：123
#不正常传字符串调用函数捕捉异常
print(parse_int('a')) #返回结果：0
(2)边界捕获：封装产生了边界
例如，写一个模块，用户调用这个模块的时候捕获异常，模块内部不需要捕获，处理异常，一旦内部处理了，外部调用者就无法感知了，
例如，open函数，出现的异常交给调用者处理，文件存在了，就不用再创建了，看是否修改还是删除
例如，自己写一个类，使用open函数，但是出现了异常不知道如何处理，就继续向外层抛出，一般来说最外层也就是边界，必须处理这个异常了，否则线程退出
7.其他的异常结构(else和finally)
语法：
try:
<语句> #运行别的代码
except <异常类>：
<语句> #捕获某种类型的异常
except <异常类> as <变量名>：
<语句> #捕获某种类型的异常并获得对象
else:
<语句> #如果没有异常发生
finally:
<语句> #退出try时总会执行
举例：
s1 = 'xixi'
#s1=1
try:
int(s1)
except IndexError as e: #多分支异常1
print(e)
except KeyError as e: #多分支异常2
print(e)
except ValueError as e: #多分支异常3
print(e)
except Exception as e: #多分支万能异常其他没有考虑到的
print(e)
else: #try内代码里没有异常的情况下会执行else里的东西
print('try内代码块没有异常执行')
finally: #无论异常与否都会执行finally里的东西，通常是清理工作
print('try内代码块有没有异常,都会执行')print(11111111111)
print(22222222222)
print(33333333333)####打印结果：
invalid literal for int() with base 10: 'xixi'
try内代码块有没有异常,都会执行
11111111111
22222222222
33333333333
8.try的工作原理：
(1)如果try中语句执行时发生异常，搜索except子句，并执行第一个匹配该异常的except子句
(2)如果try中语句执行时发生异常，却没有匹配的except子句，异常将被递交到外层的try,如果外层不处理这个异常，异常将继续向外层传递。如果都不处理该异常，则会传递到最外层，如果还没有处理，就终止异常所在的线程
(3)如果在try执行时没有发生异常，将执行else子句中的语句
(4)无论try中是否发生异常，finally子句最终都会执行
9.断言assert：在程序的某个位置判断一下结果是否是你想要的值，如果不是想要的值抛出异常
def test(): #定义test函数
'一堆逻辑'
res=1 #由一堆逻辑处理完得到一个结果是1
return 1 #处理完逻辑返回一个值1
res1=test() #一堆逻辑运行得到一个结果赋值给res1assert res1 == 1 #断言判断res1是否等于1#下面的代码，要跟res1的结果进行下一步处理
三.未实现和未实现异常
#未实现
print(NotImplemented) #打印结果：NotImplemented#未实现异常
print(NotImplementedError) #打印结果：<class 'NotImplementedError'>
总结：
NotImplemented是个值，单值，是NotImplementedType类的实例
NotImplementedError是类型，是异常，返回type
