1 什么是异常（程序运行崩溃）

异常就是程序运行时发生错误的信号（在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止），在python中,错误触发的异常如下

2 异常的种类

AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x

IOError 输入/输出异常；基本上是无法打开文件

ImportError 无法引入模块或包；基本上是路径问题或名称错误

IndentationError 语法错误（的子类）；代码没有正确对齐

IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]

KeyError 试图访问字典里不存在的键

KeyboardInterrupt Ctrl+C被按下

NameError 使用一个还未被赋予对象的变量

SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）

TypeError 传入对象类型与要求的不符合

UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，

导致你以为正在访问它

ValueError 传入一个调用者不期望的值，即使值的类型是正确的

更多报错：

ArithmeticError

AssertionError

AttributeError

BaseException

BufferError

BytesWarning

DeprecationWarning

EnvironmentError

EOFError

Exception

FloatingPointError

FutureWarning

GeneratorExit

ImportError

ImportWarning

IndentationError

IndexError

IOError

KeyboardInterrupt

KeyError

LookupError

MemoryError

NameError

NotImplementedError

OSError

OverflowError

PendingDeprecationWarning

ReferenceError

RuntimeError

RuntimeWarning

StandardError

StopIteration

SyntaxError

SyntaxWarning

SystemError

SystemExit

TabError

TypeError

UnboundLocalError

UnicodeDecodeError

UnicodeEncodeError

UnicodeError

UnicodeTranslateError

UnicodeWarning

UserWarning

ValueError

Warning

ZeroDivisionError

2.1 逻辑错误

IndexError [][1]

KeyError {}['key']

pickle.load() EOFError

FileNotFoundError open('aa')

ModuleNotFoundError import aaaaaaaaaaa

ValueError int('sdjkhf')

2.2 语法错误

语法异常，语法错误应该在写代码的时候就规避掉—SyntaxError、NameError

2.3 什么时候容易出现异常

当你要处理的内容不确定的时候

# 有用户参与

# 有外界数据接入 : 从文件中读，从网络上获取

3 如何排错

3.1 多行报错的原因

如下图，嵌套调用，其中有一个语法错误

3.2 怎么解决多行报错

在嵌套调用的过程中,内部的代码出了问题,外部所有的调用的地方都成为报错追溯信息的一部分

怎么解决

# 从下往上找首先找到你写的代码出错的那一行

# 看看能不能看出问题

# 就把报错的最后一行错误类型和详细提示贴到百度里,结合报错的那一行解决问题

4 异常处理的介绍

4.1 什么是异常处理

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

程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）

如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理

4.2 为什么要进行异常处理

python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。

所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性

5 异常处理的方式

try ... except
try ... except ... else
try ... finally
try ... except ... finally
try ... except ... else ... finally

5.1 单分支（处理指定异常）

5.1.1 基本语法

try:

被检测的代码块

except 异常类型：

try中一旦检测到异常，就执行这个位置的逻辑

5.1.2 案例：

for num, i in enumerate(l,1):
    print(num,i)
try :
    num = int(input('num>>>'))
except ValueError :
    print('请输入一个数字')

5.1.3 缺点：

如果有多种异常，是无法很好的表示多个异常的，所以用多分支

5.2 多分支

案例;

 1 l = ['login','register']
 2 for num,i in enumerate(l,1):
 3     print(num,i)
 4 try:
 5     num = int(input('num >>>'))
 6     print(l[num - 1])
 7 except ValueError :
 8     # 从上向下报错的代码只要找到一个和报错类型相符的分支就执行这个分支中的代码,然后直接退出分支
 9     print('请输入一个数字')
10 except IndexError :
11     # 如果找不到能处理和报错类型相同的分支,会一直往下走,最后还是没有找到就会报错
12     print('只能输入1或2')

5.3 多分支合并

1 l = ['login','register']
2 for num,i in enumerate(l,1):
3     print(num,i)
4 
5 try:
6     num = int(input('num >>>'))
7     print(l[num - 1])
8 except (ValueError,IndexError) :
9     print('您输入的内容不合法')

View Code

5.4 万能异常1 （可处理未知异常）

5.4.1 优缺点：

对用户友好，但是不好找错误

5.4.2 案例：

1 try :
2     func = l[num - 1][1]
3     func()
4 except Exception:
5     print("发生异常了")

5.4.3 如何解决缺点--->as

as可以将具体错误信息打印出来

1 try :
2     func = l[num - 1][1]
3     func()
4 except Exception as e:
5     print(e.args,e.__traceback__.tb_lineno,e.__traceback__.tb_frame)
6 #("name 'l' is not defined",) 42 <frame object at 0x000001E6FD771C98>

View Code

5.5 万能异常2：

案例：相当于except… Exception

1 try :
2     func = l[num - 1][1]
3     func()
4 except:
5     print("错了")

5.6 多分支+万能异常

万能异常应该永远放在异常处理的最下面

1 try :
2     a
3 except (ValueError,IndexError):
4     print('针对性的处理')
5 except Exception as e:
6     print("通用性的处理")
7     print(e)

5.7 else 分支

5.7.1 作用:

当try中的代码不发生异常的时候走else分支

5.7.2 案例：

 1 try :
 2     a=1
 3 except (ValueError,IndexError):
 4     print('针对性的处理')
 5 except Exception as e:
 6     print("通用性的处理")
 7     print(e)
 8 else :
 9     print('else')
10 
11 结果：
12 
13 else

View Code

5.8 finally分支

5.8.1 作用：

无论try语句是否异常，都执行。主要用在回收资源

5.8.2 案例：

 1 try :
 2     a=1
 3 except (ValueError,IndexError):
 4     print('针对性的处理')
 5 except Exception as e:
 6     print("通用性的处理")
 7     print(e)
 8 else :
 9     print('else')
10 finally:
11     print('finally')
12 
13 结果：
14 
15 else
16 
17 finally
18 
19  
20 
21 案例2：
22 
23 def func():
24     try:
25         a
26         b=2
27         print(b)
28         return 3
29     except:
30         print('异常处理')
31     finally:    #即使return也会先执行fianlly中的代码
32         print("hi")
33 print(func())
34 
35 结果：
36 
37 异常处理
38 
39 hi
40 
41 None

View Code

5.9 主动抛出异常

5.9.1 作用：

主动抛出异常 : 是给其他开发者用的

案例：

1 #主动抛出异常
2 try:
3     raise TypeError('类型错误')
4 except Exception as e:
5     print(e)

5.10断言

语法：

assert bool值

----》不满足条件抛异常

1 assert 1 == 2
2 
3 ---》结果：报错
4 #相当于
5 if 1 == int(input()):
6     pass
7 else:
8     raise AssertionError

5.11自定义异常

5.11.1 引子

对于异常的简单代码（这种代码结构复杂）

 1 import os
 2 def func(path,prev):
 3     """
 4     去path路径的文件中，找到前缀为prev的一行数据，获取数据并返回给调用者。
 5         1000,成功
 6         1001,文件不存在
 7         1002,关键字为空
 8         1003,未知错误
 9         ...
10     :return:
11     """
12     response = {'code':1000,'data':None}
13     try:
14         if not os.path.exists(path):
15             response['code'] = 1001
16             response['data'] = '文件不存在'
17             return response
18         if not prev:
19             response['code'] = 1002
20             response['data'] = '关键字为空'
21             return response
22         pass
23     except Exception as e:
24         response['code'] = 1003
25         response['data'] = '未知错误'
26     return response
27 
28  
29 
30 总结：这种方法较为复杂，捕获到异常还得映射中找到对应关系（1000---对应成功）

View Code

自定义异常类

 1 class ExistsError(Exception):#自定义异常类
 2     pass
 3 
 4 class KeyInvalidError(Exception):
 5     pass
 6 
 7  
 8 
 9  
10 
11 def new_func(path,prev):
12     """
13     去path路径的文件中，找到前缀为prev的一行数据，获取数据并返回给调用者。
14         1000,成功
15         1001,文件不存在
16         1002,关键字为空
17         1003,未知错误
18         ...
19     :return:
20     """
21     response = {'code':1000,'data':None}
22     try:
23         if not os.path.exists(path):
24             raise ExistsError()
25 
26         if not prev:
27             raise KeyInvalidError()
28         pass
29     except ExistsError as e:
30         response['code'] = 1001
31         response['data'] = '文件不存在'
32     except KeyInvalidError as e:
33         response['code'] = 1002
34         response['data'] = '关键字为空'
35     except Exception as e:
36         response['code'] = 1003
37         response['data'] = '未知错误'
38     return response

View Code

5.11.2 自定义异常类模板

 1 # 一：如何自定义异常类
 2 
 3   class MyException(Exception):
 4 
 5     def __init__(self,code,msg):
 6 
 7         self.code = code
 8 
 9         self.msg = msg
10 
11   
12 
13   try :
14 
15     # 二：如何主动抛出异常
16 
17     raise MyException(1000,'操作异常')  #相当于封装，触发异常这些数据就会存在self里用于捕获时提取
18 
19   #三： 捕获异常
20 
21   except MyException as e:    #e相当于e= MyException（）,对象
22 
23     print(e.code,e.msg)
24 
25   except KeyError as e:    #这个捕获不了
26 
27     print(e.code,e.msg)
28 
29   except Exception as e:    #大boss
30 
31     print(e.code,e.msg)
32  
33 #Exception：所有异常类的基类（这里面有捕获异常的功能）

6 异常处理的经验

在最外层的异常处理应该在所有的开发结束之后才放

posted on 2018-08-22 20:43 诚意阅读(187) 评论(0) 收藏举报

刷新页面返回顶部

导航

1 什么是异常（程序运行崩溃）

2 异常的种类

2.1 逻辑错误

2.2 语法错误

2.3 什么时候容易出现异常

3 如何排错

3.1 多行报错的原因

3.2 怎么解决多行报错

4 异常处理的介绍

4.1 什么是异常处理

4.2 为什么要进行异常处理

5 异常处理的方式

5.1 单分支（处理指定异常）

5.1.1 基本语法

5.1.2 案例：

5.1.3 缺点：

5.2 多分支

5.3 多分支合并

5.4 万能异常1 （可处理未知异常）

5.4.1 优缺点：

5.4.2 案例：

5.4.3 如何解决缺点--->as

5.5 万能异常2：

5.6 多分支+万能异常

5.7 else 分支

5.7.1 作用:

5.7.2 案例：

5.8 finally分支

5.8.1 作用：

5.8.2 案例：

5.9 主动抛出异常

5.9.1 作用：

5.10断言

5.11自定义异常

5.11.1 引子

对于异常的简单代码（这种代码结构复杂）

自定义异常类

5.11.2 自定义异常类模板

6 异常处理的经验