python异常处理的方法_Python异常处理详解

异常处理也是现代编程语言的基本特性，使用异常处理可以将正常分支和异常分支分割开来，而不像 C 语言那样，正常分支和异常分支是混在一起的。在 Python 中，异常就是一个特殊的对象，通过该异常对象可以给异常处理函数传递异常发生时的信息。

Python 2 和 Python 3 中异常处理的语法稍有不同，但内部实现机制是一样的。本节以 Python 3 为例介绍异常处理的方法。

多数情况下，我们自己的代码是不会主动抛出异常对象的，我们只是处理其他系统调用抛出的异常对象，所以异常处理往往是开发人员比较关心的内容。

最常见的异常是使用某个未定义的对象，如下：

>>> non_exists         # 访问一个不存在的对象non_exists

Traceback (most recent call last):

File "", line 1, in

NameError: name 'non_exists' is not defined

如果不对异常进行处理，程序会直接退出。因此我们希望能够捕捉到该异常，得到异常发生的原因，然后继续做后面的事情。对异常的处理就是如果某个异常发生，哪些代码会被执行，以及执行后会从哪里继续执行后面的代码。

和 C++ 类似，一旦出现了异常，代码会从正常分支直接跳到该异常对象对应的处理分支上进行异常处理。在处理完之后，就会执行所有异常处理分支后面的代码，而不会跳回到正常分支继续执行。

except：捕捉异常

捕捉异常就是如果某个代码段中出现了异常，需要定义好相应的异常处理代码。这样异常就被处理掉了，而不是一直向上传递，直到最后导致整个程序退出。

下面介绍几种捕捉异常的方法。

1) 捕捉任意异常

最简单的处理方式是捕捉任意异常，方法是使用下面的分支语句：

except:

该分支会捕捉任意没有被捕捉到的异常。

>>> try:

...     a = 12 / 0                     # 正常分支

... except:                            # 异常处理分支

...     print("Got and exception")     # 异常分支处理函数

...                                                  # 所有异常分支结束了

Got and exception                      # 第4行代码执行的结果

2) 捕捉特定类型的异常

当然也可以捕捉特定的异常，就是只对特定的异常进行处理，其他异常要么被更高阶的代码捕捉到，要么导致整个程序退出。

>>> try:                           # 异常捕捉区

...     a = 12 / 0

... except ZeroDivisionError:      # 仅捕捉ZeroDivisionError类型的异常

...     print("Divided By Zero")

...                                            # 异常分支结束

Divided By Zero                    # 第4行的输出

如果抛出的异常和捕捉的类型不一致，那么不会被捕捉到。

>>> try:                                  # 异常捕捉区

...     a = non_exist_var                 # 使用了不存在的对象

... except ZeroDivisionError:             # 仅捕捉被0除的异常

...     print("Divided By Zero")

...                                       # 所有的异常处理分支结束

Traceback (most recent call last):        # 由于没有被处理，导致程序结束

File "", line 2, in

NameError: name 'non_exist_var' is not defined

可以通过捕捉 Expection 类型的异常对象来达到捕捉任意类型异常的目的。由于 Exception 可以匹配任意的异常，所以不用担心异常遗漏到高层的代码。最常见的用法是在前面对某些特定的异常进行处理，在最后放一个捕捉任意异常的分支来处理那些所有漏掉的异常。如下面的例子：

>>> def div(a, b):                            # 定义除法函数

...     try:                                                                            # 进入异常捕捉区

...         c = a / b

...         return c

...     except ZeroDivisionError as ex_obj:   # 被0除的异常

...         print(u"被0除的异常,错误信息: %s" % ex_obj)

...     except Exception as e:                # 其他所有的异常

...         print(u"不知道的异常, 错误信息: %s" % e)

...

>>> div(20, 0)                                # 被第5行捕捉到

被0除的异常,错误信息: division by zero

>>> div("abc", 0)                             # 被第7行捕捉到

不知道的异常, 错误信息: unsupported operand type(s) for /: 'str' and 'int'

3) 捕捉多个异常

可以定义多个捕捉语言，用来捕捉不同的异常。这样可以对不同的异常进行不同的处理。

>>> def try_demo(x, y, z):

...     try:                                   # 异常捕捉区

...             a = x[y] / z

...     except ZeroDivisionError:              # 捕捉被0除的异常

...             print("Divided By Zero")

...     except IndexError:                     # 捕捉下标错误

...             print("Index Error")

...                                            # 异常捕捉区结束

>>> try_demo([1, 2], 3, 3)

Index Error                                    # 第7行的输出

>>> try_demo([1, 2], 1, 0)

Divided By Zero                                # 第5行的输出

这里要注意的是，一个异常对象只能被捕捉到一次。如果有两个异常处理分支都可以处理该类型异常，那么前面的那个分支被触发，后面的不会被触发。这也是为何 Exception 分支要放到最后的缘故，因为它可以捕捉到任意异常，如果放在最前面，其他异常处理分支就永远也不会被触发。如下面的例子：

>>> def div(a, b):                         # 定义除法函数

...     try:                                                                            # 进入异常捕捉区

...         c = a / b

...         return c

...     except Exception:                   # 它会捕捉任意异常

...         print(u"捕捉得到Exception类型的异常") # 它没有机会捕捉任意异常，因为前面的分支已经捕捉了所有异常

...     except ZeroDivisionError :

...         print(u"捕捉得到ZeroDivisionError 类型的异常")

...

>>> div(8, 0)

捕捉得到Exception类型的异常                    # 第6行的输出

还有一个异常类型，即 BaseException，Exception 即派生自该类型，所以该类型和 Exception 一样，也可以捕捉一切类型的异常。下面是将 BaseException 放在最前面的情况，其会屏蔽所有的捕捉分支。

>>> def div(a, b):

...     try:

...         c = a / b

...         return c

...     except BaseException:

...         print(u"捕捉得到BaseException类型的异常")

...     except ZeroDivisionError :

...         print(u"捕捉得到ZeroDivisionError 类型的异常")

...

>>> div(8, 0)          # 被0除的异常ZeroDivisionError，被第5行的分支捕捉

捕捉得到BaseException类型的异常

>>> div("abc", 2)      # 类型错误异常TypeError，也被第5行的分支捕捉

捕捉得到BaseException类型的异常

4) 得到异常对象

也可以得到捕捉到的异常对象，这样便可以获得更多异常发生时的信息。

>>> try:                    # 异常捕捉区

...     a = 12 / 0          # 被0除的操作

... except ZeroDivisionError as except_obj:

...     print("Got Expection")

...     print("Exception Message = %s", except_obj.message)

...                         # 异常捕捉区结束

Got Expection

('Exception Message = %s', 'integer division or modulo by zero')

else：没有异常才执行的分支

前面介绍的都是 except 分支，也就是异常分支。except 分支在发生异常时被执行。本节介绍的分支在没有抛出异常时才被执行，这就是 else 分支。

下面演示了这种用法。

>>> def except_demo(a, b):            # 定义一个包含异常处理的函数

...     try:

...             a = a / b

...     except ZeroDivisionError, except_obj:   # 捕捉被0除的异常

...             print("Exception Message = %s" % except_obj.message)

...     else:                         # 没有异常时会触发的else分支

...             print("No Exception is Got")

...

>>> except_demo(12, 0)                # 被0除了

# 第5行的输出

Exception Message = integer division or modulo by zero

>>> except_demo(12, 2)

No Exception is Got                   # 第7行的输出，在没有发生异常时执行

需要注意的是，如果没有捕捉到异常，而且在正常分支中直接使用 return 来返回，则 else 分支不会被执行。如下面的例子：

>>> def div(a, b):

...     try:

...         c = a / b

...         return c        # 这个很关键，导致else分支永远不会被执行

...     except ZeroDivisionError as ex_obj:

...         print(u"捕捉到了异常: %s" % ex_obj)

...     else:               # 该分支不会被执行，不论是否有异常抛出

...         print(u"没有捕捉到异常")

...

>>> div(8, 2)               # 没有抛出异常，else分支也不会被执行

4.0

>>> div(8, 0)               # 抛出异常，else分支不会被执行

捕捉到了异常: division by zero

finially：无论有无异常都要执行的分支

前面介绍了 except 分支和 else 分支，它们分别在有异常抛出和没有异常抛出时被执行。接下来介绍另一个分支，该分支在任何情况下都会被执行，而且是在最后被执行，这就是 finially 分支。

下面是 finally 分支的一个例子。

>>> def finally_demo(a, b):            # 定义一个包含异常处理的函数

...     try:

...             a = a / b

...     except ZeroDivisionError, except_obj:   # 捕捉被0除的异常

...             print("Exception Message = %s" % except_obj.message)

...     else:                          # 没有异常时会触发的分支

...             print("No Exception is Got")

...     finally:                       # 不论有无异常都被触发的分支

...             print("Finnally Branch is Running")

...

>>> finally_demo(12, 2)

No Exception is Got                    # finally分支的输出，第9行的输出

Finnally Branch is Running

>>> finally_demo(12, 0)

Exception Message = integer division or modulo by zero  # 第5行的输出

Finnally Branch is Running             # 第9行的输出

即使发生了异常但是没有被捕捉到，该分支还是会被执行。如下面的例子：

>>> def finally_demo(a, b):            # 定义函数

...     try:                           # 异常捕捉区

...             a = a / b

...     except EOFError, except_obj:   # 如果出现文件，则结束异常

...             print("Exception Message = %s" % except_obj.message)

...     else:                          # 如果没有出现该异常

...             print("No Exception is Got")

...     finally:                       # 不论是否出现异常，都要执行的分支

...             print("Finnally Branch is Running")

...                                    # 函数定义结束

>>> finally_demo(12, 4)                # 没有出现异常

No Exception is Got                    # else分支会执行

Finnally Branch is Running             # finally分支会执行

>>> finally_demo(12, 0)                # 抛出异常，但是没有被捕捉到

Finnally Branch is Running             # finally分支仍然会被执行

Traceback (most recent call last):     # 异常信息

File "", line 1, in

File "", line 3, in finally_demo  # 没有被捕捉的异常

ZeroDivisionError: integer division or modulo by zero

而且在正常分支中包含 return 语句并且没有引发异常，finnally 分支也会被执行。这和 else 分支是不同的，下面就是这样的一个例子。

>>> def div(a, b):                  # 定义一个除法函数

...     try:                        # 正常分支

...         c = a / b

...         return c

...     except ZeroDivisionError as ex_obj:

...         print("Got Exception: %s" % ex_obj)

...     finally:

...         print(u"finnally分支在执行")

...                      # 函数定义结束

>>> div(8, 2)

finnally分支在执行        # finally分支的输出

4                        # 结果，即返回值