Python之异常处理与程序调试(Exception Handling and Program Debugging in Python)

💝💝💝欢迎来到我的博客,很高兴能够在这里和您见面!希望您在这里可以感受到一份轻松愉快的氛围,不仅可以获得有趣的内容和知识,也可以畅所欲言、分享您的想法和见解。

推荐:Linux运维老纪的首页,持续学习,不断总结,共同进步,活到老学到老
导航剑指大厂系列:全面总结 运维核心技术:系统基础、数据库、网路技术、系统安全、自动化运维、容器技术、监控工具、脚本编程、云服务等。
常用运维工具系列:常用的运维开发工具, zabbix、nagios、docker、k8s、puppet、ansible等
数据库系列:详细总结了常用数据库 mysql、Redis、MongoDB、oracle 技术点,以及工作中遇到的 mysql 问题等
懒人运维系列:总结好用的命令,解放双手不香吗?能用一个命令完成绝不用两个操作
数据结构与算法系列:总结数据结构和算法,不同类型针对性训练,提升编程思维,剑指大厂
非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨

Python异常处理与程序调试
技能目标
- 掌握 Python 的异常处理
- 掌握测试和调试程序的方法
异常处理是程序中用于处理意外情况的代码段,而在代码编写的过程中,经常要进行代
码的调试和测试工作,本章将介绍 Python 语言中异常处理和程序调试的具体使用方法。

5.1 异常处理

5.1.1 异常

在人们的工作生活中,做某一件事情的时候,通常并不能很顺序的完成,在做事情的过
程中可能会有一些意外的情况发生。比如在开车上班的途中车胎被扎漏气,就需要先补好车
胎再去上班;再比如在写作业时笔坏了,就需要换一支新笔。所以当有意外情况发生时,就
需要有对应的解决方法,以便使事情能够继续做下去。对于程序来说,当要完成某一功能时,
有可能也会产生一些意外的情况,这种意外发生的情况在程序中称为异常。
示例 1:存在除数为 0 的程序代码
示例代码如下:
print('开始执行除法运算\n\n')
while True:
str1 = '输入 1 个整数作为第 1 个操作数\n'
str2 = '输入 1 个整数作为第 2 个操作数\n'
print ('开始执行除法运算\n')
op1 = int(input(str1))
op2 = int(input(str2))
result = op1 /op2
print ('%d / %d = %d' %(op1,op2,result))
仔细阅读这段代码,并没有发现问题。只是在 while 循环进行除法的计算功能。但是请
注意:当除数是 0 时,代码中的除法运算是没有意义的。所以,在这段程序运行过程中,
如果输入的第 2 个参数是 0,则会出现异常情况,输出结果如下:
开始执行除法运算
输入 1 个整数作为第 1 个操作数
3
输入 1 个整数作为第 2 个操作数
0
Traceback (most recent call last):
File "<stdin>", line 7, in <module>
ZeroDivisionError: integer division or modulo by zero
从程序输出结果中,可以发现:运行这段程序,键盘输入的第 2 个参数是 0 时,程序
会产生一个 ZeroDivisionError 异常。Python 编译器将会输出提示信息"integer division or
modulo by zero",并终止程序的运行。就像是汽车的车胎被扎一样,需要停下车先补好车
胎才能继续开车。程序运行出现异常时,也需要做适当的处理,再继续完成所要实现的功能。
一个健壮的程序,不能因为发生异常就中断结束。
常见的异常现象有但不限于:读写文件时,文件不存在;访问数据库时,数据库管理系
统没有启动;网络连接中断;算术运算时,除数为 0;序列越界等。
异常(Exception)通常可看作是程序的错误(Error),是指程序是有缺陷(Bug)的。
错误分为语法错误和逻辑错误。
语法错误是指 Python 解释器无法解释代码,在程序执行前就可以进行纠正。逻辑错误
是因为不完整或不合法的输入导致程序执行得不到预期的结果。程序在运行时,如果 Python
解释器遇到一个错误,会停止程序的执行,并且提示一些错误信息,这就是异常。
程序开发时,很难将所有的特殊情况都处理的面面俱到,通过异常捕获可以针对突发事
件做集中的处理,从而保证程序的稳定性和健壮性。
示例 2:使用 try-except 语句捕获并处理除数为 0 的异常
示例代码如下:
print('开始执行除法运算\n\n')
while True:
str1 = '输入 1 个整数作为第 1 个操作数\n'
str2 = '输入 1 个整数作为第 2 个操作数\n'
print ('开始执行除法运算\n')
try:
#可能产生异常的代码块
op1 = int(input(str1))
op2 = int(input(str2))
result = op1 /op2
print ('%d / %d = %d' %(op1,op2,result))
except ZeroDivisionError:
#捕获除数为 0 的异常
print ('捕获除数为 0 的异常')
#结果
>>>
开始执行除法运算
输入 1 个整数作为第 1 个操作数
11
输入 1 个整数作为第 2 个操作数
0
捕获除数为 0 的异常
开始执行除法运算
输入 1 个整数作为第 1 个操作数
在示例 2 中,当输入第 2 个参数为 0 时,程序继续到下一次循环执行,也就是异常情
况得到了处理,程序并没有因为异常而终止。
这段代码对异常使用 try-except 的语法结构,对引发的异常进行捕获和处理,保证程序
能继续执行并获得正确的结果。由此得知,对异常进行处理要分为 2 个阶段,第一个阶段
是捕获可能引发的异常,第二个阶段是要对发生的异常进行及时的处理。当异常发生时,不
仅能检测到异常条件,还可以在异常发生时采取更可靠的补救措施,排除异常。
示例 1 和示例 2 中的 ZeroDivisionError 是除数为 0 的异常类,Python 中还有很多内置
的异常类,它们分别表示程序中可能发生的各种异常,如表 5-1 所示。
表 5-1 Python 内置的异常类

|-----------------------|-------------------|------------------------------------------------------------|
| 异常类 | 说明 | 举例 |
| NameError | 尝试访问一个未声明的变量 | >>>foo |
| ZeroDivisionError | 除数为零 | >>>1/0 |
| SyntaxError | 解释器语法错误 | >>>for |
| IndexError | 请求的索引超出序列范围 | >>>iList=[] >>>iList[0] |
| KeyError | 请求一个不存在的字典关键字 | >>>idict={1:'A',2:'b'} >>>print idict['3'] |
| IOError | 输入/输出错误 | >>>fp = open("myfile") |

|--------------------|-----------------|---------------------------------------------------|
| AttributeError | 尝试访问未知的对象属性 | >>>class myClass(): |
| | | pass >>>my = myClass() >>>my.id |

下面是异常发生的三种情况,示例代码如下:
>>> foo
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
NameError: name 'foo' is not defined
#尝试访问一个未声明的变量
>>> for
File "<stdin>", line 1
for
^
SyntaxError: invalid syntax
#解释器语法错误
>>> iList=[]
>>> iList[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
#请求的索引超出序列范围
第 1 个异常类是 NameError,后面的"name 'foo' is not defined"的表示变量"foo"未定义。
第 2 个异常类是 SyntaxError,后面的"invalid syntax"是指存在语法错误。第 3 个异常类是
IndexError,后面的"list index out of range"是索引超出序列范围。可以看出,异常产生时,
都有一个对应的异常类,且后面有英文的提示信息。熟悉常见的异常类可以准确、快速的解
决问题,减少程序中的缺陷(Bug)。

5.1.2 异常处理

在 Python 中可以使用 try 语句检测异常,任何在 try 语句块里的代码都会被检测,检查
是否有异常发生。try 语句有两种主要形式 try-except 和 try-finally。

1. try-except

使用 try-except 定义异常监控,并且提供处理异常机制的语法结构如下。
语法:
try:
语句
# 被监控异常的代码块
except 异常类 [,对象]:
语句
# 异常处理的代码
当执行 try 中的语句块时,如果出现异常,会立即中断 try 语句块的执行,转到 except
语句块,将产生的异常类型与 except 语句块中的异常进行匹配。如果匹配成功,执行相应
的异常处理。如果匹配不成功,将异常传递给更高一级的 try 语句。如果异常一直没有找到
处理程序,则停止执行,抛出异常信息。
通过示例 2 的代码分析异常的处理过程
示例代码如下:
print('开始执行除法运算\n\n')
while True:
str1 = '输入 1 个整数作为第 1 个操作数\n'
str2 = '输入 1 个整数作为第 2 个操作数\n'
print ('开始执行除法运算\n')
try:
#可能产生异常的语句块
op1 = int(input(str1))
op2 = int(input(str2))
result = op1 /op2
print ('%d / %d = %d' %(op1,op2,result))
except ZeroDivisionError as e:
#捕获除数为 0 异常
print ('捕获除数为 0 的异常')
print (e)
#结果
开始执行除法运算
输入 1 个整数作为第 1 个操作数
1
输入 1 个整数作为第 2 个操作数
0
捕获除数为 0 的异常
division by zero
开始执行除法运算
输入 1 个整数作为第 1 个操作数
示例 2 的 try 语句块中的代码有可能产生异常。当执行到"result = op1 /op2"时,如果除
数为 0 会触发异常,try 语句块就中断执行,直接转到 except 语句块进行异常类型的匹配。
在 except 语句块中,如果捕获的异常对象与"ZeroDivisionError"匹配成功,则执行与之相应
的代码块。"ZeroDivisionError as e"的作用是把异常类赋值给变量 e,用于输出异常信息。
try-except 结构还可以加入 else 语句,当没有异常产生时,执行完 try 语句块后,就要
执行 else 语句块中的内容。

示例 3:使用 try-except-else 语句捕获并处理除数为 0 的异常

示例代码如下:
print('开始执行除法运算\n\n')
while True:
str1 = '输入 1 个整数作为第 1 个操作数\n'
str2 = '输入 1 个整数作为第 2 个操作数\n'
print ('开始执行除法运算\n')
try:
op1 = int(input(str1))
op2 = int(input(str2))
result = op1 /op2
except ZeroDivisionError as e:
print ('捕获除数为 0 的异常')
print (e)
else:
#try 中没有异常产生时,执行 else
print ('%d / %d = %d' %(op1,op2,result))
#结果
开始执行除法运算
输入 1 个整数作为第 1 个操作数
3
输入 1 个整数作为第 2 个操作数
2
3 / 2 = 1
开始执行除法运算
输入 1 个整数作为第 1 个操作数
示例 3 中,输入的除数不为 0 不会产生异常,执行完 try 语句块后,程序转到 else 语
句块继续执行,输出结果的语句写到了 else 语句块中。输出结果的语句放在 try 语句块中或
者在 else 语句块中,对程序的执行结果并没有什么影响。
在同一个 try 语句块中有可能产生多种类型的异常,可以使用多个 except 语句进行处
理,语法结构如下。
语法:
try:
语句
# 被监控异常的代码块
except 异常类 1 [,对象]:
语句
# 异常处理的代码
......
except 异常类 n [,对象]:
语句
# 异常处理的代码
当 try 语句块发生异常时,将产生的异常类型与 except 后面的异常类逐一进行匹配,
按先后顺序确定相匹配的异常类型后,执行对应的语句块。
示例 4:使用多个 except 捕获多个异常类型
示例代码如下:
def safe_float(obj):
try:
retval = float(obj)
except ValueError as e1:
#字符串转浮点数异常
print (e1)
retval = "非数值类型数据不能转换为 float 数据"
except TypeError as e2:
#类型转换错误错误
print (e2)
retval = "数据类型不能转换为 float"
return retval
print (safe_float('xyz'))
print (safe_float(()))
print (safe_float(200))
print (safe_float(99.9))
#结果
could not convert string to float: 'xyz'
非数值类型数据不能转换为 float 数据
float() argument must be a string or a number, not 'tuple'
数据类型不能转换为 float
200.0
99.9
从示例 4 的运行结果可以看到,当函数 safe_float()的参数是"xyz"时,会产生 ValueError
异常对象,在被"except ValueError as e1: "捕获后,执行对应的语句块。当参数是元组"()"
时,会产生 TypeError 异常,被"except TypeError as e2:"捕获,执行对应的语句块。如果
是正确数据将不会产生异常,则执行最后的返回语句。

2. BaseException 类

Python 中,BaseException 类是所有异常的基类,也就是所有的其他异常类型都是直
接或间接继承自 BaseException 类。直接继承 BaseException 的异常类有 SystemExit、
KeyboardExit 和 Exception 等。SystemExit 是 Python 解释器请求退出,KeyboardExit 是
用户中断执行,Exception 是常规错误。前面示例中的异常类都是 Python 内置的异常类型,
它们与用户自定义异常类一样,它们的基类都是 Exception。
如果多个 except 语句块同时出现在一个 try 语句中,异常的子类应该出现在其父类之
前。因为发生异常时 except 是按顺序逐个匹配,而只执行第一个与异常类匹配的 except
语句,因此必须先子类后父类。如果父类放在了前面,当产生子类的异常时,父类对应的
except 语句会匹配成功,子类对应的 except 语句将不会有执行的机会。示例 5:捕获子类异常和父类异常
示例代码如下:
def safe_float(obj):
try:
retval = float(obj)
except Exception as e3:
retval = "有异常产生,类型不详"
except ValueError as e1:
print (e1)
retval = "非数值类型数据不能转换为 float 数据"
except TypeError as e2:
print (e2)
retval = "数据类型不能转换为 float"
return retval
print (safe_float('xyz'))
print (safe_float(()))
print (safe_float('595.99'))
print (safe_float(200))
print (safe_float(99.9))
#结果
>>>
有异常产生,类型不详
有异常产生,类型不详
595.99
200.0
99.9

示例 5 的代码首先将捕获的异常对象与 Exception 类相匹配,然后再与 ValueError 类

和 TypeError 类做匹配。由于 Exception 是所有异常类的基类,所以当发生异常时,捕获的
异常对象会首先与 Exception 类进行匹配,并执行 Exception 对应的语句块。如果对于类型
转换产生的异常,不需要针对不同的情况进行处理,那么只需要把后两个异常处理语句删除
即可。如果想针对不同的情况处理,那么就需要调整 Exception 语句的位置,把它放到所有
异常类型的后面,也就是在其前面的异常子类都不匹配时,才会与 Exception 进行匹配。
对于相同类型的异常,可以只使用一个 except 语句,把同类型的异常对象放到一个元
组中进行处理,语法结构如下。
语法:
try:
语句
# 被监控异常的代码块
except (异常类 1 [,异常类 2][,......异常类 n])[,对象]:
语句
# 异常处理的代码
示例 6:使用元组保存并处理相同类型的异常对象
示例代码如下:
def safe_float(obj):
try:
retval = float(obj)
except (ValueError ,TypeError):
retval = "参数必须是一个数值或数值字符串"
return retval
print (safe_float('xyz'))
print (safe_float(()))
print (safe_float('595.99'))
print (safe_float(200))
print (safe_float(99.9))
#结果
>>>
参数必须是一个数值或数值字符串
参数必须是一个数值或数值字符串
595.99
200.0
99.9
示例 6 的代码将 ValueError 和 TypeError 被放到了一个元组中,它们中的任何一个异第
常发生,都会被捕获。使用这种方式的前提是,异常是同类型的;否则程序的处理是有问题
的。

3. try-except-finally

try 还有一个非常重要的处理语句 finally。一个 try 语句块只能有一个 finally 语句块,它
表示无论是否发生异常,都会执行的一段代码。加入finally后,
t
ry语句会有try-except-finally、
try-except-else-finally 和 try-finally 三种形式。finally 语句块通常用来释放占用的资源,例如
关闭文件、关闭数据库连接等。语法结构如下。
语法:
try:
语句
# 被监控异常的代码块
except 异常类 1 [,对象]:
语句
# 异常处理的代码
[else:
语句] # try 语句块的代码全部成功时的操作
finally:
语句
# 无论如何都执行
当对文件进行操作后,关闭文件是必须要做的工作。不论程序运行是否正确都应该在结
束时关闭文件,因此,可以把关闭文件的代码写到 finally 中。

示例 7:使用 try-except-else-finally 进行文件的读写操作

示例代码如下:
fp = None
try:
fp = open('/usr/local/readme.txt','r+')
fp.write('12345')
except IOError:
print ('文件读写出错')
except Exception:
print ('文件操作异常')
else:fp.seek(1)
f = fp.readlines()
print (f)
finally:
fp.close()
print ('关闭文件')
#结果
['234556789']
关闭文件
顺利执行示例 7 代码,没有产生异常,最后执行到了 finally 语句块中,执行关闭文件
的语句。如果有异常产生,同样是要执行 finally 语句块,执行关闭文件的语句。因此,finally
语句块的作用是非常明显的,把释放资源的代码放在里面,可以保证这些代码一定会被执行。

5.1.3 抛出异常

在现实生活中,当完成一项工作时,碰到问题不知道怎样解决或没有权限做决断,就需
要向上一级领导反映问题。如果上一级领导也不知道怎样解决,依然要向上反映,直到某一
级别的领导可以解决。但如果最高领导还是无法解决,就需要暂停工作,思考解决办法。异
常也有类似的情况,前面的示例中产生的异常都是可以在当前程序块中解决的。但是一旦解
决不了,就需要向调用它的程序块抛出异常,寻找解决办法。比如 float()是 Python 自带的
转换为浮点数的函数,调用时只需要传递数据给它。当它无法把参数转换为浮点数时,就抛
出了异常,告诉调用者是什么原因无法转换。此时调用者就可以根据异常对象确定问题的所
在,并找到解决办法。通过抛出异常、接收并处理异常,可以实现程序的多分支处理。
程序中抛出异常使用 raise 语句,常用的语法格式如下。
语法:
raise 异常类
raise 异常类(参数或元组)
参数是指用户可以自定义的提示信息,使调用者能依此信息快速的判断并确认存在的问
题。

示例 8:要求输入的文件名不能是"hello"

示例代码如下:
filename = input("please input file name:")
if filename == "hello":
raise NameError("input file name error")
#结果
please input file name:hello
Traceback (most recent call last):
File "wyjx.py", line 3, in <module>
raise NameError("input file name error")
NameError: input file name error
当输入文件名是"hello"时,条件判断成立,执行抛出异常语句,和前面示例中的异常
形式相同,显示输出"NameError: input file name error"。此时的异常将交给上一级处理,也
就是 Python 解释器接收异常,因为程序代码没有对异常进行处理,所以最后的结果是程序
终止运行。

示例 9:捕获并处理抛出的异常

示例代码如下:
def filename():
filename = input("please input file name:")
if filename == "hello":
raise NameError("input file name error")
return filename
while True:
try:
#对异常进行捕获处理
filename = filename()
print ("filename is %s" %filename)
break
except NameError:
print ("please input file name again!")#结果
please input file name:hello
please input file name again!
please input file name:
示例 9 的函数 filename()中,如果输入的文件名是"hello",将会抛出 NameError 异
常。在调用 filename()时需要用 try 对它捕获进行处理,此时程序就不会终止运行,增加了
程序的健壮性。

5.2 调试和测试程序

Python 提供了内置的 pdb 模块进行程序调试,也提供了单元测试的模块 doctest。本节
将讲解这两个模块如何使用。

5.2.1 调试程序

Pdb 模块采用命令交互的方式,可以设置断点、单步执行、查看变量等,pdb 模块中的
调试函数分为两种:语句块调试函数和调试函数。

1.语句块调试函数

run()函数可以对语句块进行调试,只要把语句块作为参数执行即可进行调试,示例代
码如下:
import pdb
pdb.run('''
for i in range(1,3):
print (i)
''')
这是对 for 循环进行调试的一段代码,运行后会出现调试的命令提示,代码如下所示:
> <string>(2)<module>()
(Pdb)
然后,就可以输入命令进行调试,常用的命令如表 5-2 所示。
表 5-2 pdb 常用命令

|--------------|--------------------|
| 命令/完整命令 | 描述 |
| h/help | 查看命令列表 |
| j/jump | 跳转到指定行 |
| n/next | 执行下一条语句,不进入函数 |
| r/return | 运行到函数返回 |
| s/step | 执行下一条语句,遇到函数进入 |
| q/quit | 退出 pdb |
| b/break | 设置断点 |

2.调试函数
如果需要对函数进行调试,可以使用 runcall(),示例代码如下:
import pdb
def sum (a,b):
total = a+b
return total
pdb.runcall(sum,10,5)
pdb.runcall(sum,10,5)的含义是调试 sum()函数,后面是调用 sum()的 2 个实参。执行
后也是 pdb 的命令行模式,输入命令可以进行调试。

5.2.2 测试程序

doctest 模块提供了测试的函数,testmod()可以对 docstring 中测试用例进行测试,测
试用例使用">>>"表示,示例 10 代码如下:
def sum(a,b):
"""
>>> sum(1,4)
5
>>> sum(100,11)
133
"""
return a+b
if name == 'main':
import doctest
doctest.testmod()
在每个">>>"后面是调用函数的测试用例,紧跟在下面的内容是函数的返回结果。注意:
在">>>"后面要有一个空格。这段测试用例的执行结果如下:
>>>
**********************************************************************
File "wyjx.py", line 6, in main.sum
Failed example:
sum(100,11)
Expected:
133
Got:
111
**********************************************************************
1 items had failures:
1 of
2 in main.sum
***Test Failed*** 1 failures.
TestResults(failed=1, attempted=2)
因为对 sum(100,11)指定的结果是 133,但它的函数处理结果是 111,所以显示出相应
的错误信息。如果测试用例都能通过,将没有任何的错误信息。
可以像上面示例的代码一样,把测试代码和函数写在了一个 Python 文件中,也可以把
测试代码写到单独的文本文件中,再使用 testfile()函数进行测试,示例代码如下:
sum.py
#函数文件
def sum1(a,b):
return a+b
testsum.txt
#测试代码文件
>>> from sum import sum1
>>> sum1(1,4)
5
>>> sum1(100,11)
133
test.py
#测试文件
import doctest
doctest.testfile('testsum.txt')
执行 test.py 后,测试结果与使用 testmod()函数相同。

相关推荐
DanielYQ11 分钟前
LCR 001 两数相除
开发语言·python·算法
yngsqq16 分钟前
037集——JoinEntities连接多段线polyline和圆弧arc(CAD—C#二次开发入门)
开发语言·c#·swift
Zԅ(¯ㅂ¯ԅ)18 分钟前
C#桌面应用制作计算器进阶版01
开发语言·c#
过期的H2O219 分钟前
【H2O2|全栈】JS进阶知识(七)ES6(3)
开发语言·javascript·es6
一路冰雨30 分钟前
Qt打开文件对话框选择文件之后弹出两次
开发语言·qt
松树戈39 分钟前
JS推荐实践
开发语言·javascript·ecmascript
瑞雨溪41 分钟前
java中的this关键字
java·开发语言
vener_1 小时前
LuckySheet协同编辑后端示例(Django+Channel,Websocket通信)
javascript·后端·python·websocket·django·luckysheet
封步宇AIGC1 小时前
量化交易系统开发-实时行情自动化交易-4.2.3.指数移动平均线实现
人工智能·python·机器学习·数据挖掘
互联网杂货铺1 小时前
自动化测试基础知识总结
自动化测试·软件测试·python·selenium·测试工具·职场和发展·测试用例