python处理异常的机制_第十章 Python异常处理机制

10.1 什么是异常处理，Python常见异常类型

开发人员在编写程序时，难免会遇到错误，有的是编写人员疏忽造成的语法错误，有的是程序内部隐含逻辑问题造成的数据错误，还有的是程序运行时与系统的规则冲突造成的系统错误，等等。

总的来说，编写程序时遇到的错误可大致分为 2 类，分别为语法错误和运行时错误。

语法错误，也就是解析代码时出现的错误。当代码不符合 Python 语法规则时，Python解释器在解析时就会报出 SyntaxError 语法错误，与此同时还会明确指出最早探测到错误的语句。例如：

print "Hello,World!"

我们知道，Python 3 已不再支持上面这种写法，所以在运行时，解释器会报如下错误：

SyntaxError: Missing parentheses in call to 'print'

语法错误多是开发者疏忽导致的，属于真正意义上的错误，是解释器无法容忍的，因此，只有将程序中的所有语法错误全部纠正，程序才能执行。

Python运行时错误

运行时错误，即程序在语法上都是正确的，但在运行时发生了错误。例如：

a = 1/0

上面这句代码的意思是“用 1 除以 0，并赋值给 a 。因为 0 作除数是没有意义的，所以运行后会产生如下错误：

>>> a = 1/0Traceback (most recent call last):File "", line 1, in a = 1/0ZeroDivisionError: division by zero

以上运行输出结果中，前两段指明了错误的位置，最后一句表示出错的类型。在 Python 中，把这种运行时产生错误的情况叫做异常(Exceptions)。这种异常情况还有很多，常见的几种异常情况如表 1 所示。

异常类型含义实例

AssertionError

当 assert 关键字后的条件为假时，程序运行会停止并抛出 AssertionError 异常

>>> demo_list = ['C语言中文网'] >>> assert len(demo_list) > 0 >>> demo_list.pop() 'C语言中文网' >>> assert len(demo_list) > 0 Traceback (most recent call last): File "", line 1, in assert len(demo_list) > 0 AssertionError

AttributeError

当试图访问的对象属性不存在时抛出的异常

>>> demo_list = ['C语言中文网'] >>> demo_list.len Traceback (most recent call last): File "", line 1, in demo_list.len AttributeError: 'list' object has no attribute 'len'

IndexError

索引超出序列范围会引发此异常

>>> demo_list = ['C语言中文网'] >>> demo_list[3] Traceback (most recent call last): File "", line 1, in demo_list[3] IndexError: list index out of range

KeyError

字典中查找一个不存在的关键字时引发此异常

>>> demo_dict={'C语言中文网':"c.biancheng.net"} >>> demo_dict["C语言"] Traceback (most recent call last): File "", line 1, in demo_dict["C语言"] KeyError: 'C语言'

NameError

尝试访问一个未声明的变量时，引发此异常

>>> C语言中文网 Traceback (most recent call last): File "", line 1, in C语言中文网 NameError: name 'C语言中文网' is not defined

TypeError

不同类型数据之间的无效操作

>>> 1+'C语言中文网' Traceback (most recent call last): File "", line 1, in 1+'C语言中文网' TypeError: unsupported operand type(s) for +: 'int' and 'str'

ZeroDivisionError

除法运算中除数为 0 引发此异常

>>> a = 1/0 Traceback (most recent call last): File "", line 1, in a = 1/0 ZeroDivisionError: division by zero

提示：表中的异常类型不需要记住，只需简单了解即可。

当一个程序发生异常时，代表该程序在执行时出现了非正常的情况，无法再执行下去。默认情况下，程序是要终止的。如果要避免程序退出，可以使用捕获异常的方式获取这个异常的名称，再通过其他的逻辑代码让程序继续运行，这种根据异常做出的逻辑处理叫作异常处理。

开发者可以使用异常处理全面地控制自己的程序。异常处理不仅仅能够管理正常的流程运行，还能够在程序出错时对程序进行必的处理。大大提高了程序的健壮性和人机交互的友好性。

那么，应该如何捕获和处理异常呢？可以使用 try 语句来实现。有关 try 语句的语法和用法，会在后续章节继续详解。

10.2 Python异常处理机制到底有什么用？

异常处理是现代编程语言不可或缺的能力，它已经成为衡量一门编程语言是否成熟和健壮的标准之一，C++、Java、C#、Python 等高级语言都提供了异常处理机制。

无论你是多么优秀的程序员，你都不能保证自己的程序永远不会出错。就算你的程序没有错，用户也不一定按照你设定的规则来使用你的程序，总有一些小白或者极客会“玩弄”你的程序。

除此以外，你也不能保证程序的运行环境永远稳定，比如操作系统可能崩溃，网络可能无法连接，内存可能突然坏掉……

总之，你基本什么都保证不了。但是，作为一个负责任的程序员，我们要让自己的程序尽可能的健壮，尽可能保证在恶劣环境下还能正常运行，或者给用户提示错误，让用户决定是否退出。

例如有一个五子棋程序，当用户输入落子的坐标时，程序既要判断输入格式是否正确(横坐标和纵坐标之间由逗号分隔)，还要判断坐标是否在合法的范围内。一般我们都会这样来处理：

if 坐标包含了除逗号之外的其它非数字字符：alert 坐标只能是数值goto retryelif 坐标不包含逗号：alert 必须使用逗号分隔横坐标和纵坐标goto retryelif 坐标落在了棋盘外：alert 坐标必须位于棋盘之内goto retryelif 作为位置已有其它棋子：alert 只能在没有棋子的位置落子goto retryelse:#正常的业务代码......

上面的代码并没有涉及所有出错情形，只是考虑了四种可能出错的情形，代码量就已经急剧增加了。

在实际开发中，不可预料的情况呈数量级增长，甚至不能穷举，按照上面的逻辑来处理各种错误简直让人抓狂。

如果每次在实现真正的业务逻辑之前，都需要不厌其烦地考虑各种可能出错的情况，针对各种错误情况给出补救措施，这是多么乏味的事情啊。程序员喜欢解决问题，喜欢开发带来的“创造”快感，但不喜欢像一个“堵漏”工人，去堵那些由外在条件造成的“漏洞”。

对于构造大型、健壮、可维护的应用而言，错误处理是整个应用需要考虑的重要方面，程序员不能仅仅只做“对”的事情，程序员开发程序的过程，是一个创造的过程，这个过程需要有全面的考虑，仅做“对”的事情是远远不够的。

对于上面的错误处理机制，主要有如下两个缺点：

无法穷举所有的异常情况。因为人类知识的限制，异常情况总比可以考虑到的情况多，总有“漏网之鱼”的异常情况，所以程序总是不够健壮。

错误处理代码和业务实现代码混杂。这种错误处理和业务实现混杂的代码严重影响程序的可读性，会增加程序维护的难度。

程序员希望有一种强大的机制来解决上面的问题，能够将上面程序改成如下的形式：

if 用户输入不合法:alert 输入不合法goto retryelse :#正常的业务代码......

上面伪码提供了一个非常强大的“if 块”，即程序不管输入错误的原因是什么，只要用户输入不满足要求，程序就一次处理所有的错误。这种处理方法的好处是，使得错误处理代码变得更有条理，只需在一个地方处理错误。

现在的问题是，“用户输入不合法”这个条件怎么定义？当然，对于这个简单的要求，可以使用正则表达式对用户输入进行匹配，当用户输入与正则表达式不匹配时即可判断“用户输入不合法”。但对于更复杂的情形，就没有这么简单了。使用 Python 的异常处理机制就可以解决这个问题，例如：

try：if(用户输入不合理)：raise 异常except Exception：alert 输入不合法goto retry#正常的业务代码

此程序中，通过在 try 块中判断用户的输入数据是否合理，如果不合理，程序受 raise 的影响会进行到 except 代码块，对用户的错误输出进行处理，然后会继续执行正常的业务代码；反之，如果用户输入合理，那么程序将直接执行正常的业务代码。

try except 是 Python 实现异常处理机制的核心结构，其具体用法会在后续章节做详细介绍。

显然，使用 Python 异常处理机制，可以让程序中的异常处理代码和正常业务代码分离，使得程序代码更加优雅，并可以提高程序的健壮性。

10.3 Python try except异常处理详解

Python中，用try except语句块捕获并处理异常，其基本语法结构如下所示：

try:可能产生异常的代码块except [ (Error1, Error2, ... ) [as e] ]:处理异常的代码块1except [ (Error3, Error4, ... ) [as e] ]:处理异常的代码块2except [Exception]:处理其它异常

该格式中，[] 括起来的部分可以使用，也可以省略。其中各部分的含义如下：

(Error1, Error2,...) 、(Error3, Error4,...)：其中，Error1、Error2、Error3 和 Error4 都是具体的异常类型。显然，一个 except 块可以同时处理多种异常。

[as e]：作为可选参数，表示给异常类型起一个别名 e，这样做的好处是方便在 except 块中调用异常类型(后续会用到)。

[Exception]：作为可选参数，可以代指程序可能发生的所有异常情况，其通常用在最后一个 except 块。

从try except的基本语法格式可以看出，try 块有且仅有一个，但 except 代码块可以有多个，且每个 except 块都可以同时处理多种异常。

当程序发生不同的意外情况时，会对应特定的异常类型，Python 解释器会根据该异常类型选择对应的 except 块来处理该异常。

try except 语句的执行流程如下：

首先执行 try 中的代码块，如果执行过程中出现异常，系统会自动生成一个异常类型，并将该异常提交给 Python 解释器，此过程称为捕获异常。

当 Python 解释器收到异常对象时，会寻找能处理该异常对象的 except 块，如果找到合适的 except 块，则把该异常对象交给该 except 块处理，这个过程被称为处理异常。如果 Python 解释器找不到处理异常的 except 块，则程序运行终止，Python 解释器也将退出。

事实上，不管程序代码块是否处于 try 块中，甚至包括 except 块中的代码，只要执行该代码块时出现了异常，系统都会自动生成对应类型的异常。但是，如果此段程序没有用 try 包裹，又或者没有为该异常配置处理它的 except 块，则 Python 解释器将无法处理，程序就会停止运行；反之，如果程序发生的异常经 try 捕获并由 except 处理完成，则程序可以继续执行。

举个例子：

try:   a = int(input("输入被除数："))   b = int(input("输入除数："))   c = a / b   print("您输入的两个数相除的结果是：", c )except (ValueError, ArithmeticError):   print("程序发生了数字格式异常、算术异常之一")except :   print("未知异常")print("程序继续运行")

try:   1/0except Exception as e:   # 访问异常的错误编号和详细信息   print(e.args)   print(str(e))   print(repr(e))

try:   #...except Exception:   #...

try:   a = int(input("输入 a："))   b = int(input("输入 b："))   print( a/b )except ValueError:   print("数值错误：程序只能接收整数参数")except ArithmeticError:   print("算术错误")except Exception:   print("未知异常")

try:   result = 20 / int(input('请输入除数:'))   print(result)except ValueError:   print('必须输入整数')except ArithmeticError:   print('算术错误，除数不能为 0')else:   print('没有出现异常')print("继续执行")

try:   result = 20 / int(input('请输入除数:'))   print(result)except ValueError:   print('必须输入整数')except ArithmeticError:   print('算术错误，除数不能为 0')print('没有出现异常')print("继续执行")

try:   a = int(input("请输入 a 的值:"))   print(20/a)except:   print("发生异常！")else:   print("执行 else 块中的代码")   finally :   print("执行 finally 块中的代码")

try:   #发生异常   print(20/0)finally :   print("执行 finally 块中的代码")

import ostry:   os._exit(1)finally:   print("执行finally语句")

def test():   try:       # 因为finally块中包含了return语句       # 所以下面的return语句失去作用       return True   finally:       return Falseprint(test())

try:   a = input("输入一个数：")   #判断用户输入的是否为数字   if(not a.isdigit()):       raise ValueError("a 必须是数字")except ValueError as e:   print("引发异常：",repr(e))

try:   a = input("输入一个数：")   if(not a.isdigit()):       raise ValueError("a 必须是数字")except ValueError as e:   print("引发异常：",repr(e))   raise

try:   a = input("输入一个数：")   if(not a.isdigit()):       raiseexcept RuntimeError as e:   print("引发异常：",repr(e))

#使用 sys 模块之前，需使用 import 引入import systry:   x = int(input("请输入一个被除数："))   print("30除以",x,"等于",30/x)except:   print(sys.exc_info())   print("其他异常...")

#使用 sys 模块之前，需使用 import 引入import sys#引入traceback模块import tracebacktry:   x = int(input("请输入一个被除数："))   print("30除以",x,"等于",30/x)except:   #print(sys.exc_info())   traceback.print_tb(sys.exc_info()[2])   print("其他异常...")

class SelfException(Exception):   passdef main():   firstMethod()def firstMethod():   secondMethod()def secondMethod():   thirdMethod()def thirdMethod():   raise SelfException("自定义异常信息")main()

# 导入trackback模块import tracebackclass SelfException(Exception): passdef main():   firstMethod()def firstMethod():   secondMethod()def secondMethod():   thirdMethod()def thirdMethod():   raise SelfException("自定义异常信息")try:   main()except:   # 捕捉异常，并将异常传播信息输出控制台   traceback.print_exc()   # 捕捉异常，并将异常传播信息输出指定文件中   traceback.print_exc(file=open('log.txt', 'a'))

class SelfExceptionError(Exception):   passtry:   raise SelfExceptionError()except SelfExceptionError as err:   print("捕捉到自定义异常")

class InputError(Exception):   '''当输出有误时，抛出此异常'''   #自定义异常类型的初始化   def __init__(self, value):       self.value = value   # 返回异常类对象的说明信息   def __str__(self):       return ("{} is invalid input".format(repr(self.value)))   try:   raise InputError(1) # 抛出 MyInputError 这个异常except InputError as err:   print('error: {}'.format(err))

#如果要下棋的点不为空if board[int(y_str) - 1) [int(x_str) - 1] !="╋" :   inputStr = input ("您输入的坐标点己有棋子了，请重新输入\n")   continue

#如果要下棋的点不为空if board[int(y_str) - 1) [int(x_str) - 1) != "╋":   #引发默认的RuntimeError 异常   raise

#定义一个字符串列表my_list =["Hello", "Python", "Spring"]#使用异常处理来遍历arr数组的每个元素try:   i = 0   while True:   print (my_list [i])   i += 1except:   pass

i = 0while i < len(my_list):   print(my_list[i])   i += 1

import logginglogging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')

import logginglogging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')logging.debug('Start of program')def factorial(n):   logging.debug('Start of factorial(%s%%)' % (n))   total = 1   for i in range(n + 1):       total *= i       logging.debug('i is ' + str(i) + ', total is ' + str(total))   logging.debug('End of factorial(%s%%)' % (n))   return totalprint(factorial(5))logging.debug('End of program')

s_age = input("请输入您的年龄:")age = int(s_age)assert 20 < age < 80 , "年龄不在 20-80 之间"print("您输入的年龄在20和80之间")

try:   s_age = input("请输入您的年龄:")   age = int(s_age)   assert 20 < age < 80 , "年龄不在 20-80 之间"   print("您输入的年龄在20和80之间")except AssertionError as e:   print("输入年龄不正确",e)

当在命令行模式运行 Python 程序时，传入 -O(注意是大写)参数，可以禁用程序中包含的 assert 语句。

通过在程序的适当位置，使用 assert 语句判断变量或表达式的值，可以起到调试代码的作用。

请输入您的年龄:10输入年龄不正确 年龄不在 20-80 之间

程序运行结果为：

通常情况下，assert 可以和 try except 异常处理语句配合使用，以前面代码为例：

通过运行结果可以看出，当 assert 中条件表达式的值为假时，程序将抛出异常，并附带异常的描述性信息，与此同时，程序立即停止执行。

请输入您的年龄:10Traceback (most recent call last):File "C:\Users\mengma\Desktop\1.py", line 3, in assert 20 < age < 80 , "年龄不在 20-80 之间"AssertionError: 年龄不在 20-80 之间

程序运行结果为：

例如：

assert 语句的作用是：当条件表达式的值为真时，该语句什么也不做，程序正常运行；反之，若条件表达式的值为假，则 assert 会抛出 AssertionError 异常。其中，[,描述信息] 作为可选参数，用于对条件表达式可能产生的异常进行描述。

assert 条件表达式 [,描述信息]

《Python assert断言》一节中，已经对 assert 的基本用法做了简单介绍，assert 语句的完整语法格式为：

前面章节介绍了如何使用 IDLE 自身的调试工具调试程序，除此之外，Python 还提供了 assert 语句，也可以用来调试程序。

10.15 Python assert调试程序

打开 Python Shell，在主菜单上选择“Debug -> Debugger”选项，打开 Debug Control 对话框，同时 Python Shell 窗口中会显示“[DEBUG ON]”，表示已经处于调试状态，如图 1 所示：

图 1 处于调试状态的 Python Shell

在 Python Shell 窗口中，选择“File -> Open”菜单项，打开要调试的程序文件，并向程序中的代码添加断点，其作用是：当程序执行至断点位置时，会暂时中断执行。根据需要，程序还可以恢复执行。

向程序中添加断点，不能胡乱地添加，要有目的的添加。一般情况下，当想要查看某个变量运行至某处代码的值，就可以在该代码位置添加一个断点。

程序中添加断点的方法是：在想要添加断点的行上，点击鼠标右键，在弹出的快捷菜单中选择“Set BreakPoint”菜单项，添加断点的代码行，其背景会变成黄色，如图 2 所示。

图 2 给代码添加断点

同样，如果想删除已添加的断点，可以选中已添加断点的行，然后点击鼠标右键，选择“Clear Breakpoint”。

添加完断点之后，可以按 F5 快捷键，或者在打开的程序文件菜单栏中选择“Run -> Run Module”执行程序，这时 Debug Control 对话框中将显示程序的执行信息。如图 3 所示。

图 3 显示程序的执行信息

需要注意的是，勾选 Globals 复选框，将显示全局变量，Debug Control默认只显示局部变量。

图 3 中，调试工具栏中的 5 个按钮的作用分别是：

Go 按钮：直接运行至下一个断点处；

Step 按钮：用于进入要执行的函数；

Over 按钮：表示单步执行；

Out 按钮：表示跳出当前运行的函数；

Quit 按钮：表示结束调试。

通过使用这 5 个按钮，可以查看程序执行过程中各个变量值的变化，直至程序运行结束。程序调试完毕后，可以关闭 Debug Control 窗口，此时在 Python Shell 窗口中将显示 “[DEBUG OFF]”，表示已经结束调试。

在保证程序没有语法错误的前提下，使用 IDLE 调试程序的基本步骤如下：

掌握一定的程序调试方法，是每一名合适的程序员的必备技能。多数的集成开发工具都提供了程序调试功能，本教程中使用的 IDLE 也不例外。本节将给大家演示如何使用 IDLE 调试 Python 程序。

当遇到程序有逻辑错误时，最好的解决方法就是对程序进行调试，即通过观察程序的运行过程，以及运行过程中变量(局部变量和全局变量)值的变化，可以快速找到引起运行结果异常的根本原因，从而解决逻辑错误。

在程序开发过程中，免不了会出现一些错误，既有语法方面的，也有逻辑方面的。语法方面的相对比较好检测，因为当程序中有语法错误时，程序运行会直接停止，同时 Python 解释器会给出错误提示。而对于逻辑错误，可能并不太容易发现，因为程序本身运行没有问题，只是运行结果是错误的。

10.14 Python IDLE调试程序详解

此程序中，将日志消息存储到了 demo.txt 文件中，该文件就位于运行的程序文件所在的目录。

>>> import logging>>> logging.basicConfig(filename='demo.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

将日志消息输出到文件中的实现方法很简单，只需要设置 logging.basicConfig() 函数中的 filename 关键字参数即可，例如：

虽然日志消息很有用，但它们可能塞满屏幕，让你很难读到程序的输出。考虑到这种情况，可以将日志信息写入到文件，既能使屏幕保持干净，又能保存信息，一举两得。

将日志消息输出到文件中

因为 logging.disable() 将禁用它之后的所有消息，所以可以将其添加到程序中更接近 import logging 的位置，这样更容易找到它，方便根据需要注释掉它，或取消注释，从而启用或禁用日志消息。

>>> import logging>>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s - %(levelname)s - %(message)s')>>> logging.critical('Critical error! Critical error!')2019-09-11 14:42:14,833 - CRITICAL - Critical error! Critical error!>>> logging.disable(logging.CRITICAL)>>> logging.critical('Critical error! Critical error!')>>> logging.error('Error! Error!')

logging.disable() 函数的用法是，向其传入一个日志级别，它会禁止该级别以及更低级别的所有日志消息。因此，如果想要禁用所有日志，只要在程序中添加 logging.disable(logging.CRITICAL) 即可，例如：

在调试完程序后，可能并不希望所有这些日志消息出现在屏幕上，这时就可以使用 logging.disable() 函数禁用这些日志消息，从而不必进入到程序中，手工删除所有的日志调用。

Python logging禁用日志

日志级别的好处在于，我们可以改变想看到的日志消息的优先级。比如说，向 basicConfig() 函数传入 logging.DEBUG 作为 level 关键字参数，这将显示所有级别为 DEBUG 的日志消息。当开发了更多的程序后，我们可能只对错误感兴趣，在这种情况下，可以将 basicConfig() 的 level 参数设置为 logging.ERROR，这将只显示 ERROR 和 CRITICAL 消息，跳过 DEBUG、INFO 和 WARNING 消息。

>>>import logging>>> logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s - %(message)s')>>> logging.debug('Some debugging details.')2019-09-11 14:32:34,249 - DEBUG - Some debugging details.>>> logging.info('The logging module is working.')2019-09-11 14:32:47,456 - INFO - The logging module is working.>>> logging.warning('An error message is about to be logged.')2019-09-11 14:33:02,391 - WARNING - An error message is about to be logged.>>> logging.error('An error has occurred.')2019-09-11 14:33:14,413 - ERROR - An error has occurred.>>> logging.critical('The program is unable to recover!')2019-09-11 14:33:24,071 - CRITICAL - The program is unable to recover!

举个例子：

日志消息将会作为一个字符串，传递给这些函数。另外，日志级别只是一种建议，归根到底还是由程序员自己来决定日志消息属于哪一种类型。

级别对应的函数描述

DEBUG

logging.debug()

最低级别，用于小细节，通常只有在诊断问题时，才会关心这些消息。

INFO

logging.info()

用于记录程序中一般事件的信息，或确认一切工作正常。

WARNING

logging.warning()

用于表示可能的问题，它不会阻止程序的工作，但将来可能会。

ERROR

logging.error()

用于记录错误，它导致程序做某事失败。

CRITICAL

logging.critical()

最高级别，用于表示致命的错误，它导致或将要导致程序完全停止工作。

“日志级别”提供了一种方式，按重要性对日志消息进行分类。5 个日志级别如表 1 所示，从最不重要到最重要。利用不同的日志函数，消息可以按某个级别记入日志。

Python logging日志级别

2019-09-11 14:21:18,047 - DEBUG - Start of program2019-09-11 14:21:18,067 - DEBUG - Start of factorial(5%)2019-09-11 14:21:18,072 - DEBUG - i is 1, total is 12019-09-11 14:21:18,082 - DEBUG - i is 2, total is 22019-09-11 14:21:18,087 - DEBUG - i is 3, total is 62019-09-11 14:21:18,093 - DEBUG - i is 4, total is 242019-09-11 14:21:18,101 - DEBUG - i is 5, total is 1202019-09-11 14:21:18,106 - DEBUG - End of factorial(5%)1202019-09-11 14:21:18,123 - DEBUG - End of program

将代码行 for i in range(n + 1)：改为 for i in range(1，n + 1)：，再次运行程序，输出结果为：

分析程序的运行结果，factorial(5) 返回 0 作为 5 的阶乘的结果，这显然是不对的。for 循环应该用从 1 到 5 的数，乘以 total 的值，但 logging.debug() 显示的日志信息表明，i 变量从 0 开始，而不是 1。因为 0 乘任何数都是 0，所以接下来的迭代中，total 的值都是错的。日志消息提供了可以追踪的痕迹，帮助我们弄清楚程序运行过程哪里不对。

可以看到，通过 logging.debug() 函数可以打印日志信息，这个 debug() 函数将调用 basicConfig() 打印一行信息，这行信息的格式是在 basicConfig() 函数中指定的，并且包括传递给 debug() 的消息。

2019-09-11 14:14:56,928 - DEBUG - Start of program2019-09-11 14:14:56,945 - DEBUG - Start of factorial(5%)2019-09-11 14:14:56,959 - DEBUG - i is 0, total is 02019-09-11 14:14:56,967 - DEBUG - i is 1, total is 02019-09-11 14:14:56,979 - DEBUG - i is 2, total is 02019-09-11 14:14:56,991 - DEBUG - i is 3, total is 02019-09-11 14:14:57,000 - DEBUG - i is 4, total is 02019-09-11 14:14:57,013 - DEBUG - i is 5, total is 02019-09-11 14:14:57,024 - DEBUG - End of factorial(5%)02019-09-11 14:14:57,042 - DEBUG - End of program

运行结果为：

假如我们编写了如下一个函数，其设计的初衷是用来计算一个数的阶乘，但该函数有些问题，需要调试：

读者不需要关心这两行代码的具体工作原理，但基本上，当 Python 记录一个事件的日志时，它会创建一个 LogRecord 对象，保存关于该事件的信息。

启用 logging 模块很简单，直接将下面的代码复制到程序开头：

在 Python 中，有一种比频繁使用 print() 调试程序更简便的方法，就是使用 logging 模块，该模块可以很容易地创建自定义的消息记录，这些日志消息将描述程序执行何时到达日志函数调用，并列出指定的任何变量当时的值。

无论使用哪种编程语言，最常用的调试代码的方式是：使用输出语句(比如 C 语言中使用 printf，Python 中使用 print() 函数)输出程序运行过程中一些关键的变量的值，查看它们的值是否正确，从而找到出错的地方。这种调试方法最大的缺点是，当找到问题所在之后，需要再将用于调试的输出语句删掉。

10.13 Python logging模块用法快速攻略

处理异常。对异常进行合适的修复，然后绕过异常发生的地方继续运行；或者用别的数据进行计算，以代替期望的方法返回值；或者提示用户重新操作……总之，程序应该尽量修复异常，使程序能恢复运行。

重新引发新异常。把在当前运行环境下能做的事情尽量做完，然后进行异常转译，把异常包装成当前层的异常，重新传给上层调用者。

在合适的层处理异常。如果当前层不清楚如何处理异常，就不要在当前层使用 except 语句来捕获该异常，让上层调用者来负责处理该异常。

except 块为空就是假装不知道甚至瞒天过海，这是最可怕的事情，程序出了错误，所有人都看不到任何异常，但整个应用可能已经彻底坏了。仅在 except 块里打印异常传播信息稍微好一点，但仅仅比空白多了几行异常信息。通常建议对异常采取适当措施，比如：

不要忽略异常！既然己捕获到异常，那么 except 块理应做些有用的事情，及处理并修复异常。except 块整个为空，或者仅仅打印简单的异常信息都是不妥的！

不要忽略捕获到的异常

正确的做法是，把大块的 try 块分割成多个可能出现异常的程序段落，并把它们放在单独的 try 块中，从而分别捕获并处理异常。

而且当时块过于庞大时，就难免在 try 块后紧跟大量的 except 块才可以针对不同的异常提供不同的处理逻辑。在同一个 try 块后紧跟大量的 except 块则需要分析它们之间的逻辑关系，反而增加了编程复杂度。

很多初学异常机制的读者喜欢在 try 块里放置大量的代码，这看上去很“简单”，但这种“简单”只是一种假象，只是在编写程序时看上去比较简单。但因为 try 块里的代码过于庞大，业务过于复杂，就会造成 try 块中出现异常的可能性大大增加，从而导致分析异常原因的难度也大大增加。

不要使用过于庞大的 try 块

注意，异常只应该用于处理非正常的情况，不要使用异常处理来代替正常的流程控制。对于一些完全可预知，而且处理方式清楚的错误，程序应该提供相应的错误处理代码，而不是将其笼统地称为异常。

运行上面程序确实可以实现遍历 my_list 列表的功能，但这种写法可读性较差，而且运行效率也不高。程序完全有能力避免产生 indexError 异常，程序“故意”制造这种异常，然后使用 except 块去捕获该异常，这是不应该的。将程序改为如下形式肯定要好得多：

另外，异常机制的效率比正常的流程控制效率差，所以不要使用异常处理来代替正常的程序流程控制。例如，对于如下代码：

必须指出，异常处理机制的初衷是将不可预期异常的处理代码和正常的业务逻辑处理代码分离，因此绝不要使用异常处理来代替正常的业务逻辑判断。

上面这种处理方式没有提供有效的错误处理代码，当程序检测到用户试图下棋的坐标点己经有棋子时，并没有提供相应的处理，而是简单地引发一个异常。这种处理方式虽然简单，但 Python 解释器接收到这个异常后，还需要进入相应的 except 块来捕获该异常，所以运行效率要差一些。而且用户下棋重复这个错误完全是可预料的，所以程序完全可以针对该错误提供相应的处理，而不是引发异常。

如果将上面的处理机制改为如下方式：

上面这种处理方式检测到用户试图下棋的坐标点己经有棋子，立即打印一条提示语句，并重新开始下一次循环。这种处理方式简洁明了、逻辑清晰，程序的运行效率也很好程序进入 if 块后，即结束了本次循环。

对比前面五子棋游戏中，处理用户输入坐标点己有棋子的两种方式。如果用户试图下棋的坐标点己有棋子：

熟悉了异常使用方法后，程序员可能不再愿意编写烦琐的错误处理代码，而是简单地引发异常。实际上这样做是不对的，对于完全己知的错误和普通的错误，应该编写处理这种错误的代码，增加程序的健壮性。只有对于外部的、不能确定和预知的运行时错误才使用异常。

把异常和普通错误混淆在一起，不再编写任何错误处理代码，而是以简单地引发异常来代苦所有的错误处理。

使用异常处理来代替流程控制。

不可否认，Python 的异常机制确实方便，但滥用异常机制也会带来一些负面影响。过度使用异常主要表现在两个方面：

不要过度使用异常

下面介绍达到这些效果的基本准则。

使程序代码混乱最小化。

捕获并保留诊断信息。

通知合适的人员。

采用合适的方式结束异常活动。

成功的异常处理应该实现如下 4 个目标：

前面介绍了使用异常处理的优势、便捷之处，本节将进一步从程序性能优化、结构优化的角度给出异常处理的一般规则。

10.12 Python异常机制使用细则，正确使用Python异常处理机制

注意，只要自定义的类继承自 Exception，则该类就是一个异常类，至于此类中包含的内容，并没有做任何规定。

error: 1 is invalid input

运行结果为：

下面也是自定义的异常类，和上面的异常类相比，其内部实现了 init() 方法和 str() 方法：

另外，系统自带的异常只要触发会自动抛出(比如 NameError、ValueError 等)，但用户自定义的异常需要用户自己决定什么时候抛出。也就是说，自定义的异常需要使用 raise 手动抛出。

注意，虽然所有类同时继承自 BaseException，但它是为系统退出异常而保留的，假如直接继承 BaseException，可能会导致自定义异常不会被捕获，而是直接发送信号退出程序运行，脱离了我们自定义异常类的初衷。

图 1 Python 异常类继承图

需要注意的是，自定义一个异常类，通常应继承自 Exception 类(直接继承)，当然也可以继承自那些本身就是从 Exception 继承而来的类(间接继承 Exception)。

由于大多数 Python 内置异常的名字都以 "Error" 结尾，所以实际命名时尽量跟标准的异常命名一样。

可以看到，此程序中就自定义了一个名为 SelfExceptionError 的异常类，只不过该类是一个空类。

捕捉到自定义异常

运行结果为：

其实，在前面章节中，已经涉及到了异常类的创建，例如：

答案是肯定的，Python 允许用户自定义异常类型。实际开发中，有时候系统提供的异常类型不能满足开发的需求。这时就可以创建一个新的异常类来拥有自己的异常。

前面的例子里充斥了很多 Python 内置的异常类型，读者也许会问，我可以创建自己的异常类型吗？

10.11 Python自定义异常类及用法

运行上面程序，同样可以看到在控制台输出异常传播信息，而且在程序目录下生成了一个 log.txt 文件，该文件中同样记录了异常传播信息。

上面程序第一行先导入了 traceback 模块，接下来程序使用 except 捕获程序的异常，并使用 traceback 的 print_exc() 方法输出异常传播信息，分别将它输出到控制台和指定文件中。

借助于 traceback 模块的帮助，我们可以使用 except 块捕获异常，并在其中打印异常传播信息，包括把它输出到文件中。例如如下程序：

limit：用于限制显示异常传播的层数，比如函数 A 调用函数 B，函数 B 发生了异常，如果指定 limit=1，则只显示函数 A 里面发生的异常。如果不设置 limit 参数，则默认全部显示。

file：指定将异常传播轨迹信息输出到指定文件中。如果不指定该参数，则默认输出到控制台。

也就是说，使用 print_exc([limit[, file]]) 会自动处理当前 except 块所捕获的异常。该方法还涉及两个参数：

print_exception(sys.exc_etype, sys.exc_value, sys.exc_tb[, limit[, file]])

简单来说， print_exc([limit[, file]]) 相当于如下形式：

当程序处于 except 块中时，该 except 块所捕获的异常信息可通过 sys 对象来获取，其中 sys.exc_type、sys.exc_value、sys.exc_traceback 就代表当前 except 块内的异常类型、异常值和异常传播轨迹。

etype：指定异常类型；

value：指定异常值；

tb：指定异常的traceback 信息；

可能有读者好奇，从上面方法看不出它们到底处理哪个异常的传播轨迹信息。实际上我们常用的 print_exc() 是 print_exc([limit[, file]]) 省略了 limit、file 两个参数的形式。而 print_exc([limit[, file]]) 的完整形式是 print_exception(etype, value, tb[,limit[, file]])，在完整形式中，前面三个参数用于分别指定异常的如下信息：

traceback.print_exc()：将异常传播轨迹信息输出到控制台或指定文件中。

format_exc()：将异常传播轨迹信息转换成字符串。

使用 traceback 模块查看异常传播轨迹，首先需要将 traceback 模块引入，该模块提供了如下两个常用方法：

其实，上面程序的运算结果显示的异常传播轨迹信息非常清晰，它记录了应用程序中执行停止的各个点。最后一行信息详细显示了异常的类型和异常的详细消息。从这一行向上，逐个记录了异常发生源头、异常依次传播所经过的轨迹，并标明异常发生在哪个文件、哪一行、哪个函数处。

很多初学者一看到输出结果所示的异常提示信息，就会惊慌失措，他们以为程序出现了很多严重的错误，其实只有一个错误，系统提示那么多行信息，只不过是显示异常依次触发的轨迹。

所以，当应用程序运行时，经常会发生一系列函数或方法调用，从而形成“函数调用战”。异常的传播则相反，只要异常没有被完全捕获(包括异常没有被捕获，或者异常被处理后重新引发了新异常)，异常就从发生异常的函数或方法逐渐向外传播，首先传给该函数或方法的调用者，该函数或方法的调用者再传给其调用者，直至最后传到 Python解释器，此时 Python 解释器会中止该程序，并打印异常的传播轨迹信息。

在实际应用程序的开发中，大多数复杂操作都会被分解成一系列函数或方法调用。这是因为，为了具有更好的可重用性，会将每个可重用的代码单元定义成函数或方法，将复杂任务逐渐分解为更易管理的小型子任务。由于一个大的业务功能需要由多个函数或方法来共同实现，在最终编程模型中，很多对象将通过一系列函数或方法调用来实现通信，执行任务。

从输出结果可以看出，异常从 thirdMethod() 函数开始触发，传到 secondMethod() 函数，再传到 firstMethod() 函数，最后传到 main() 函数，在 main() 函数止，这个过程就是整个异常的传播轨迹。

Traceback (most recent call last):File "C:\Users\mengma\Desktop\1.py", line 11, in main()File "C:\Users\mengma\Desktop\1.py", line 4, in main

上面程序中 main() 函数调用 firstMethod()，firstMethod() 调用 secondMethod()，secondMethod() 调用 thirdMethod()，thirdMethod() 直接引发一个 SelfException 异常。运行上面程序，将会看到如下所示的结果：

下面示例显示了如何显示异常传播轨迹：

除了使用 sys.exc_info() 方法获取更多的异常信息之外，还可以使用 traceback 模块，该模块可以用来查看异常的传播轨迹，追踪异常触发的源头。

10.10 Python traceback模块：获取异常信息

print_tb 方法也仅是 traceback 模块众多方法中的一个，有关 traceback 模块如何获取更多异常信息，后续章节会做详细介绍。

可以看到，输出信息中包含了更多的异常信息，包括文件名、抛出异常的代码所在的行数、抛出异常的具体代码。

请输入一个被除数：0File "C:\Users\mengma\Desktop\demo.py", line 7, in print("30除以",x,"等于",30/x)其他异常...

输入 0，程序运行结果为：

要查看 traceback 对象包含的内容，需要先引进 traceback 模块，然后调用 traceback 模块中的 print_tb 方法，并将 sys.exc_info() 输出的 traceback 对象作为参数参入。例如：

输出结果中，第 2 行是抛出异常的全部信息，这是一个元组，有 3 个元素，第一个元素是一个 ZeroDivisionError 类；第 2 个元素是异常类型 ZeroDivisionError 类的一个实例；第 3 个元素为一个 traceback 对象。其中，通过前 2 个元素可以看出抛出的异常类型以及描述信息，对于第 3 个元素，是一个 traceback 对象，无法直接看出有关异常的信息，还需要对其做进一步处理。

请输入一个被除数：0(, ZeroDivisionError('division by zero',), )其他异常...

当输入 0 时，程序运行结果为：

举个例子：

type：异常类型的名称，它是 BaseException 的子类(有关

value：捕获到的异常实例。

traceback：是一个 traceback 对象。

exc_info() 方法会将当前的异常信息以元组的形式返回，该元组中包含 3 个元素，分别为 type、value 和 traceback，它们的含义分别是：

模块 sys 中，有两个方法可以返回异常的全部信息，分别是 exc_info() 和 last_traceback()，这两个函数有相同的功能和用法，本节仅以 exc_info() 方法为例。

有关 sys 模块更详细的介绍，可阅读《

本节首先介绍如何使用 sys 模块中的 exc_info() 方法获得更多的异常信息。

使用 sys 模块中的 exc_info 方法；

使用 traceback 模块中的相关函数。

捕获异常时，有 2 种方式可获得更多的异常信息，分别是：

在实际调试程序的过程中，有时只获得异常的类型是远远不够的，还需要借助更详细的异常信息才能解决问题。

10.9 Python sys.exc_info()方法：获取异常信息

输入一个数：a引发异常： RuntimeError('No active exception to reraise',)

程序执行结果为：

当在没有引发过异常的程序使用无参的 raise 语句时，它默认引发的是 RuntimeError 异常。例如：

这里重点关注位于 except 块中的 raise，由于在其之前我们已经手动引发了 ValueError 异常，因此这里当再使用 raise 语句时，它会再次引发一次。

输入一个数：a引发异常： ValueError('a 必须是数字',)Traceback (most recent call last):File "D:\python3.6\1.py", line 4, in raise ValueError("a 必须是数字")ValueError: a 必须是数字

程序执行结果为：

正如前面所看到的，在使用 raise 语句时可以不带参数，例如：

raise 不需要参数

因此，虽然程序中使用了 raise 语句引发异常，但程序的执行是正常的，手动抛出的异常并不会导致程序崩溃。

可以看到，当用户输入的不是数字时，程序会进入 if 判断语句，并执行 raise 引发 ValueError 异常。但由于其位于 try 块中，因为 raise 抛出的异常会被 try 捕获，并由 except 块进行处理。

输入一个数：a引发异常： ValueError('a 必须是数字',)

程序运行结果为：

当然，我们手动让程序引发异常，很多时候并不是为了让其崩溃。事实上，raise 语句引发的异常通常用 try except(else finally)异常处理结构来捕获并进行处理。例如：

>>> raiseTraceback (most recent call last):File "", line 1, in raiseRuntimeError: No active exception to reraise>>> raise ZeroDivisionErrorTraceback (most recent call last):File "", line 1, in raise ZeroDivisionErrorZeroDivisionError>>> raise ZeroDivisionError("除数不能为零")Traceback (most recent call last):File "", line 1, in raise ZeroDivisionError("除数不能为零")ZeroDivisionError: 除数不能为零

显然，每次执行 raise 语句，都只能引发一次执行的异常。首先，我们来测试一下以上 3 种 raise 的用法：

想了解一下常用的异常类名称，可以阅读《

raise：单独一个 raise。该语句引发当前上下文中捕获的异常(比如在 except 块中)，或默认引发 RuntimeError 异常。

raise 异常类名称：raise 后带一个异常类名称，表示引发执行类型的异常。

raise 异常类名称(描述信息)：在引发指定类型的异常的同时，附带异常的描述信息。

也就是说，raise 语句有如下三种常用的用法：

其中，用 [] 括起来的为可选参数，其作用是指定抛出的异常名称，以及异常信息的相关描述。如果可选参数全部省略，则 raise 会把当前错误原样抛出；如果仅省略 (reason)，则在抛出异常时，将不附带任何的异常描述信息。

raise [exceptionName [(reason)]]

raise 语句的基本语法格式为：

读者可能会感到疑惑，即我们从来都是想方设法地让程序正常运行，为什么还要手动设置异常呢？首先要分清楚程序发生异常和程序执行错误，它们完全是两码事，程序由于错误导致的运行异常，是需要程序员想办法解决的；但还有一些异常，是程序正常运行的结果，比如用 raise 手动引发的异常。

在前面章节的学习中，遗留过一个问题，即是否可以在程序的指定位置手动抛出一个异常？答案是肯定的，Python允许我们在程序中手动设置异常，使用 raise 语句即可。

10.8 Python raise用法

尽量避免在 finally 块里使用 return 或 raise 等导致方法中止的语句，否则可能出现一些很奇怪的情况。

但是，如果在 finally 块里也使用了 return 或 raise 等导致方法中止的语句，finally 块己经中止了方法，系统将不会跳回去执行 try 块、except 块里的任何代码。

同样，如果 Python 程序在执行 try 块、except 块包含有 return 或 raise 语句，则 Python 解释器执行到该语句时，会先去查找 finally 块，如果没有 finally 块，程序才会立即执行 return 或 raise 语句；反之，如果找到 finally 块，系统立即开始执行 finally 块，只有当 finally 块执行完成后，系统才会再次跳回来执行 try 块、except 块里的 return 或 raise 语句。

False

上面程序在 finally 块中定义了一条 return False 语句，这将导致 try 块中的 return true 失去作用。运行上面程序，输出结果为：

另外在通常情况下，不要在 finally 块中使用如 return 或 raise 等导致方法中止的语句(raise 语句将在后面介绍)，一旦在 finally 块中使用了 return 或 raise 语句，将会导致 try 块、except 块中的 return、raise 语句失效。看如下程序：

运行程序，没有任何输出。因此，除非在 try 块、except 块中调用了退出 Python 解释器的方法，否则不管在 try 块、except 块中执行怎样的代码，出现怎样的情况，异常处理的 finally 块总会被执行。

注意，如果程序中运行了强制退出 Python 解释器的语句(如 os._exit(1) )，则 finally 语句将无法得到执行。例如：

其中，很多初学者分不清 finally 和 else 的区别，这里着重说一下。else 语句块只有在没有异常发生的情况下才会执行，而 finally 语句则不管异常是否发生都会执行。不仅如此，无论是正常退出、遇到异常退出，还是通过 break、continue、return 语句退出，finally 语句块都会执行。

如果没有 try 块，则不能有后面的 except 块、else 块和 finally 块。但是也不能只使用 try 块，要么使用 try except 结构，要么使用 try finally 结构；

except 块、else 块、finally 块都是可选的，当然也可以同时出现；

可以有多个 except 块，但捕获父类异常的 except 块应该位于捕获子类异常的 except 块的后面；

多个 except 块必须位于 try 块之后，finally 块必须位于所有的 except 块之后。

要使用 else 块，其前面必须包含 try 和 except。

注意，在整个异常处理结构中，只有 try 块是必需的，也就是说：

图 1 异常处理语句块的执行流程

整个异常处理结构的执行过程，如图 1 所示。

try:#业务实现代码except Exception1 as e:#异常处理块1...except Exception2 as e:#异常处理块2...#可以有多个 except...else:#正常处理块finally :#资源回收块...

首先，Python 完整的异常处理语法结构如下：

到本节为止，读者已经学习了整个 Python 的异常处理机制的结构，接下来带领大家回顾一下，在此过程还会讲解一些新的知识。

10.7 Python异常处理机制结构详解

可以看到，当 try 块中代码发生异常，导致程序崩溃时，在崩溃前 Python 解释器也会执行 finally 块中的代码。

执行 finally 块中的代码Traceback (most recent call last):File "D:\python3.6\1.py", line 3, in print(20/0)ZeroDivisionError: division by zero

程序执行结果为：

finally 块的强大还远不止此，即便当 try 块发生异常，且没有合适和 except 处理异常时，finally 块中的代码也会得到执行。例如：

可以看到，当 try 块中代码发生异常时，except 块得到执行，而 else 块中的代码将不执行，finally 块中的代码仍然会被执行。

请输入 a 的值:a发生异常！执行 finally 块中的代码

再次运行程序：

可以看到，当 try 块中代码为发生异常时，except 块不会执行，else 块和 finally 块中的代码会被执行。

请输入 a 的值:45.0执行 else 块中的代码执行 finally 块中的代码

运行此程序：

举个例子：

读者可能会问，回收这些物理资源，必须使用 finally 块吗？当然不是，但使用 finally 块是比较好的选择。首先，try 块不适合做资源回收工作，因为一旦 try 块中的某行代码发生异常，则其后续的代码将不会得到执行；其次 except 和 else 也不适合，它们都可能不会得到执行。而 finally 块中的代码，无论 try 块是否发生异常，该块中的代码都会被执行。

Python 垃圾回收机制，只能帮我们回收变量、类对象占用的内存，而无法自动完成类似关闭文件、数据库连接等这些的工作。

基于 finally 语句的这种特性，在某些情况下，当 try 块中的程序打开了一些物理资源(文件、数据库连接等)时，由于这些资源必须手动回收，而回收工作通常就放在 finally 块中。

在整个异常处理机制中，finally 语句的功能是：无论 try 块是否发生异常，最终都要进入 finally 语句，并执行其中的代码块。

注意，和 else 语句不同，finally 只要求和 try 搭配使用，而至于该结构中是否包含 except 以及 else，对于 finally 不是必须的(else 必须和 try except 搭配使用)。

Python异常处理机制还提供了一个 finally 语句，通常用来为 try 块中的程序做扫尾清理工作。

10.6 Python try except finally：资源回收

可以看到，如果不使用 else 块，try 块捕获到异常并通过 except 成功处理，后续所有程序都会依次被执行。

请输入除数:a必须输入整数没有出现异常继续执行

程序执行结果为：

也就是说，else 的功能，只有当 try 块捕获到异常时才能显现出来。在这种情况下，else 块中的代码不会得到执行的机会。而如果我们直接把 else 块去掉，将其中的代码编写到 try except 的后面：

可以看到，当我们试图进行非法输入时，程序会发生异常并被 try 捕获，Python 解释器会调用相应的 except 块处理该异常。但是异常处理完毕之后，Python 解释器并没有接着执行 else 块中的代码，而是跳过 else，去执行后续的代码。

请输入除数:a必须输入整数继续执行

当然不一样，现在再次执行上面的代码：

读者可能会问，既然 Python 解释器按照顺序执行代码，那么 else 块有什么存在的必要呢？直接将 else 块中的代码编写在 try except 块的后面，不是一样吗？

如上所示，当我们输入正确的数据时，try 块中的程序正常执行，Python 解释器执行完 try 块中的程序之后，会继续执行 else 块中的程序，继而执行后续的程序。

请输入除数:45.0没有出现异常继续执行

可以看到，在原有 try except 的基础上，我们为其添加了 else 块。现在执行该程序：

举个例子：

使用 else 包裹的代码，只有当 try 块没有捕获到任何异常时，才会得到执行；反之，如果 try 块捕获到异常，即便调用对应的 except 处理完异常，else 块中的代码也不会得到执行。

在原本的try except结构的基础上，Python异常处理机制还提供了一个 else 块，也就是原有 try except 语句的基础上再添加一个 else 块，即try except else结构。

10.5 Python try except else详解

当一个 try 块配有多个 except 块时，这些 except 块应遵循这样一个排序规则，即可处理全部异常的 except 块(参数为 Exception，也可以什么都不写)要放到所有 except 块的后面，且所有父类异常的 except 块要放到子类异常的 except 块的后面。

如果用户输入的 a 或者 b 是其他字符，而不是数字，会发生 ValueError 异常，try 块会捕获到该类型异常，同时 Python 解释器会调用第一个 except 块处理异常；

如果用户输入的 a 和 b 是数字，但 b 的值为 0，由于在进行除法运算时除数不能为 0，因此会发生 ArithmeticError 异常，try 块会捕获该异常，同时 Python 解释器会调用第二个 except 块处理异常；

当然，程序运行过程中，还可能由于其他因素出现异常，try 块都可以捕获，同时 Python 会调用最后一个 except 块来处理。

该程序中，根据用户输入 a 和 b 值的不同，可能会导致 ValueError、ArithmeticError 异常：

下面看几个简单的异常捕获的例子：

图 2 Python 异常捕获流程示意图

图 2 演示了位于 try 块中的程序发生异常时，从捕获异常到处理异常的整个流程。

当 try 块捕获到异常对象后，Python 解释器会拿这个异常类型依次和各个 except 块指定的异常类进行比较，如果捕获到的这个异常类，和某个 except 块后的异常类一样，又或者是该异常类的子类，那么 Python 解释器就会调用这个 except 块来处理异常；反之，Python 解释器会继续比较，直到和最后一个 except 比较完，如果没有比对成功，则证明该异常无法处理。

因此，如果用户要实现自定义异常，不应该继承 BaseException ，而应该继承 Exception 类。关于如何自定义一个异常类，可阅读《

从图 1 中可以看出，BaseException 是 Python 中所有异常类的基类，但对于我们来说，最主要的是 Exception 类，因为程序中可能出现的各种异常，都继承自 Exception。

图 1 Python 的常见异常类之间的继承关系

这里就要详细介绍一下 Exception。要知道，为了表示程序中可能出现的各种异常，Python 提供了大量的异常类，这些异常类之间有严格的继承关系，图 1 显示了 Python 的常见异常类之间的继承关系。

注意，对于可以接收任何异常的 except 来说，其后可以跟 Exception，也可以不跟任何参数，但表示的含义都是一样的。

这种情况下，对于 try 块中可能出现的任何异常，Python 解释器都会交给仅有的这个 except 块处理，因为它的参数是 Exception，表示可以接收任何类型的异常。

我们知道，一个 try 块也可以对应多个 except 块，一个 except 块可以同时处理多种异常。如果我们想使用一个 except 块处理所有异常，就可以这样写：

前面章节中，我们详细介绍了try except异常处理的用法，简单来说，当位于 try 块中的程序执行出现异常时，会将该种异常捕获，同时找到对应的 except 块处理该异常，那么这里就有一个问题，它是如何找到对应的 except 块的呢？

10.4 Python异常处理机制的底层实现

在 Python 2.x 的早期版本中，除了使用 as e 这个格式，还可以将其中的 as 用逗号(，)代替。

从程序中可以看到，由于 except 可能接收多种异常，因此为了操作方便，可以直接给每一个进入到此 except 块的异常，起一个统一的别名 e。

除此之外，如果想要更加详细的异常信息，可以使用 traceback 模块。有兴趣的读者，可自行查阅资料学习。

('division by zero',)division by zeroZeroDivisionError('division by zero',)

输出结果为：

举个例子：

args：返回异常的错误编号和描述字符串；

str(e)：返回异常信息，但不包括异常信息的类型；

repr(e)：返回较全的异常信息，包括异常信息的类型。

其实，每种异常类型都提供了如下几个属性和方法，通过调用它们，就可以获取当前处理异常类型的相关信息：

通过前面的学习，我们已经可以捕获程序中可能发生的异常，并对其进行处理。但是，由于一个 except 可以同时处理多个异常，那么我们如何知道当前处理的到底是哪种异常呢？

获取特定异常的有关信息

除此之外，由于 try 块中引发了异常，并被 except 块成功捕获，因此程序才可以继续执行，才有了“程序继续运行”的输出结果。

上面程序中，第 6 行代码使用了(ValueError, ArithmeticError)来指定所捕获的异常类型，这就表明该 except 块可以同时捕获这 2 种类型的异常；第 8 行代码只有 except 关键字，并未指定具体要捕获的异常类型，这种省略异常类的 except 语句也是合法的，它表示可捕获所有类型的异常，一般会作为异常捕获的最后一个 except 块。

输入被除数：a程序发生了数字格式异常、算术异常之一程序继续运行

程序运行结果为：