3.3.3 异常处理机制

那么，有没有办法使我们既能增强程序的健壮性，又不影响程序逻辑的清晰和完整呢？

现代编程语言提供了异常处理机制来解决这个问题。异常处理机制的基本思想是：程序运行时如果发生错误，就“抛出”一个异常，而系统能够“捕获”这个异常并执行特定的异常处理代码。图 3.7 中给出了异常抛出和捕获的示意图，从图中可见，异常实际上是一种可能改变程序控制流的事件，使我们能跳出某个正常执行的程序块。

图 3.7 异常的抛出、捕获和处理

打个比方，当厨师在按照预定的菜谱做菜时，如果执行到某个步骤发现酱油没了或炉具坏了，就只能跳出正常步骤，转到能处理这种意外的程序：酱油没了可以去买酱油，买回来后可以继续做菜；炉子坏了一般只好中止做菜。

Python 语言也提供了这样的异常处理机制。在 Python 中，异常处理是通过一种特殊的控制结构来实现的，即 try-except 结构。try 语句的最简单形式如下：

try:
    <语句块> 
except:
    <异常处理语句块>

其语义是：执行<语句块>，如果一切正常，执行结束后控制转向 try-except 的下一条语句；如果执行过程中发生了异常，则控制转向异常处理语句块，执行结束后控制转向 try-except 的下一条语句。

缺省异常处理

我们前面所写的程序都没有使用异常处理，这时如果程序出现运行时错误，实际上会由 Python 进行缺省的异常处理。Python 所做的事情只是简单地中止程序运行，并显示一些错误信息。例如：

>>> a = "Hello"
>>> print a[5]
Traceback (most recent call last): File "<stdin>", line 1, in <module>
IndexError: string index out of range

上面第二条语句导致索引越界错误，这个异常被 Python 捕获并显示标准错误信息。从例中可见，错误信息包括两个部分：错误类型（如 IndexError）和错误描述（如 string index out of range），两者用冒号分隔。另外，Python 还追溯错误发生的地方，并显示有关信息。

程序自己处理异常

Python 的缺省异常处理使应用程序中止，控制转给 Python 解释器。如果应用程序需要在发生异常的情况下仍能正常结束，就需要使用 try-except 语句来自己捕获并处理异常。例如：

>>> a = "Hello"
>>> try:
        print a[5] 
    except IndexError:
        print "Index wrong!"
Index wrong!

索引越界错误发生之后，控制自动转到 except 子句下面的处理代码，处理完毕还可以继续执行程序的其他语句。如果没有错误，则忽略 except 部分。

异常处理机制的优点

相对于错误检测代码，使用异常处理机制可以使程序的核心算法代码与错误处理代码相互分离，从而保持程序结构的清晰。如果要了解程序的主要算法，只需读 try 下面的语句块，完全不会被繁杂的错误检测打扰。例如，如果用 try-except 语句来实现上一小节中的“三步走”例子，只需用一个 except 子句来捕获 doStep1、doStep2 和 doStep3 等步骤可能抛出的各种异常，代码形如：

try:
    doStep1() 
    doStep2() 
    doStep3()
except:
    doErrorProcessing()

显然，这种形式的代码既能保持算法逻辑的清晰完整，又能实现错误检测，圆满解决了上一小节中提到的错误检测的弊端。

如果要做的事情步骤很多、流程很复杂，将所有代码堆积在 try 之下又会使程序结构不清晰。这时可以利用模块化设计将程序逻辑表达为许多函数①，然后在 try 部分调用各函数，形如：

def doMyJob(): 
    doStep1() 
    doStep2()
    ...
    doStep100()
    try:
        doMyJob() 
    except:
        doErrorProcessing()

也可以让程序的每个模块各自具有自己的异常处理，而不是将异常抛出给其他模块处理。

分类处理异常

以上用到的简单形式的 try 语句不加区分地对所有错误进行相同的处理，如果需要对不同错误类型进行不同的处理，则可使用更精细的控制：

① 见第 4 章。

try:
    <语句块>
except <错误类型 1>:
    <异常处理语句块 1>
    ...
except <错误类型 n>:
    <异常处理语句块 n> 
except:
    <缺省异常处理语句块>

其语义是：执行<语句块>，如果一切正常，执行结束后控制转向 try-except 的下一条语句；如果执行过程中发生了异常，则系统依次检查各个 except 子句试图找到与所发生的异常相匹配的错误类型。如果找到，就执行相应的异常处理语句块，如果找不到则执行最后一个 except 子句下的缺省异常处理语句块。异常处理结束后控制转到 try-except 的下一条语句。注意，最后一个不含错误类型的 except 子句是可选的，用于捕获所有未预料到的错误类型。如果未使用最后这个 except 子句，那么当异常与所有错误类型都不匹配时，则由 Python 解释器捕获异常并处理之①。如前所述，Python 的缺省异常处理是中止程序并显示错误信息。

理解了异常处理的基本知识后，下面我们利用 try-except 语句来改写一元二次方程求解程序，代码如下：

【程序 3.7】eg3_7.py

import math 
try:
    a, b, c = input("Enter the coefficients (a, b, c): ") 
    discRoot = math.sqrt( b * b - 4 * a * c)
    root1 = (-b + discRoot) / (2 * a) 
    root2 = (-b - discRoot) / (2 * a)
    print "The solutions are:", root1, root2 
except ValueError:
    print "The equation has no real roots!"

程序 3.7 这个版本和程序 3.5 中的版本非常相似，只是在程序 3.5 所示的核心算法之外增加了一个 try-except 结构。从而做到了既保持清晰的核心算法逻辑，又避免因判别式为负数而导致程序崩溃。让我们再次以系数 1、2、3 来执行这个程序：

>>> import eg3_7
Enter the coefficients (a, b, c): 1,2,3
The equation has no real roots!

可见不适当的系数并没有使程序崩溃，异常处理代码捕获了 math.sqrt 引起的异常，使程序得以正常结束。

除了判别式为负导致 math.sqrt 出错之外，还有多种可能导致程序出错的情形。例如：用户输入系数的个数不足或者输入的是字符串而非数值均可导致 TypeError，输入未定义的变量而非字面值可导致 NameError，为系数 a 输入 0 可导致 ZeroDivisionError，等等。使用 try...except 语句可以捕获任何预先想到的异常类型，使用缺省 except 还可以捕获所有未预料到的异常，从而使程序在任何运行时错误发生的情况下都不会崩溃。下面是更完善的解方程程序版本：

① 对于多层的程序结构（外层调用内层，内层又调用更内层），当发生异常时，如果本层没有匹配的异常处理代码，则该异常被交给上一层处理。上一层没有匹配的异常处理代码就继续往上传，直至要么找到匹配，要么到达顶层（即 Python 解释器）进行缺省异常处理。

【程序 3.8】eg3_8.py

import math 
try:
    a, b, c = input("Enter the coefficients (a, b, c): ") 
    discRoot = math.sqrt( b * b - 4 * a * c)
    root1 = (-b + discRoot) / (2 * a) 
    root2 = (-b - discRoot) / (2 * a)
    print "The solutions are:", root1, root2 
except ValueError:
    print "The equation has no real roots!" 
except TypeError:
    print "Wrong coefficients!" 
except NameError:
    print "Undefined variable!" 
except:
    print "Something wrong!"

总之，使用了 try 语句后，不管发生什么错误（除了 Python 系统之外的问题，如操作系统错误、硬件故障等）程序都可以避免崩溃。

使用 try-except 语句尽管看上去有点繁琐，但它确实是编写健壮程序所必需的。在实际应用开发中，要想写出职业水准的程序，就应该考虑各种可能的异常情形，以防止用户得到难以理解的结果。当然，初学编程时，经常不去考虑错误输入等程序健壮性问题，而是把注意力放在算法和数据结构等方面。