码迷,mamicode.com
首页 > 编程语言 > 详细

Python基础教程(第八章 异常)

时间:2016-04-27 18:41:08      阅读:295      评论:0      收藏:0      [点我收藏+]

标签:

本文内容全部出自《Python基础教程》第二版,在此分享自己的学习之路。

______欢迎转载:http://www.cnblogs.com/Marlowes/p/5428641.html______

 

                                Created on Marlowes

 

在编写程序的时候,程序员通常需要辨别事件的正常过程和异常(非正常)的情况。这类异常事件可能是错误(比如试图除以0),或者是不希望经常发生的事情。为了能够处理这些异常事件,可以在所有可能发生这类事件的地方都使用条件语句(比如让程序检查除法的分母是否为零)。但是,这么做可能不仅会没效率和不灵活,而且还会让程序难以阅读。你可能会想直接忽略这些异常事件,期望它们永不发生,但Python的异常对象提供了非常强大的替代解决方案。

本章介绍如何创建和引发自定义的异常,以及处理异常的各种方法。

 

8.1 什么是异常

Python用异常对象(exception object)来表示异常情况。遇到错误后,会引发异常。如果异常对象并未被处理或捕捉,程序就会用所谓的回溯(traceback, 一种错误信息)终止执行:

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

如果这些错误信息就是异常的全部功能,那么它也就不必存在了。事实上,每个异常都是一些类(本例中是ZeroDivisionError)的实例,这些实例可以被引发,并且可以用很多种方法进行捕捉,使得程序可以捉住错误并且对其进行处理,而不是让整个程序失效。

 

8.2 按自己的方式出错

异常可以在某些东西出错的时候自动引发。在学习如何处理异常之前,先看一下自己如何引发异常,以及创建自己的异常类型。

 

8.2.1 raise语句

为了引发异常,可以使用一个类(应该是Exception的子类)或者实例参数调用raise语句。使用类时,程序会自动创建类的一个实例。下面是一些简单的例子,使用了内建的Exception的异常类:

>>> raise Exception
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception
>>> raise Exception("hyperdrive overload")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: hyperdrive overload

第一个例子raise Exception引发了一个没有任何有关错误信息的普通异常。后一个例子中,则添加了错误信息hyperdrive overload。

内建的异常类有很多。Python库参考手册的Built-in Exceptions一节中有关与它们的描述。用交互式解释器也可以分析它们,这些内建异常都可以在exceptions模块(和内建的命名空间)中找到。可以使用dir函数列出模块内容,这部分会在第十章中讲到:

>>> import exceptions
>>> dir(exceptions)
[ArithmeticError, AssertionError, AttributeError, ...]

读者的解释器中,这个名单可能要长得多——出于对易读性的考虑,这里删除了大部分名字,所有这些异常都可以用在raise语句中:

>>> raise ArithmeticError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ArithmeticError

表8-1描述了一些最重要的内建异常类:

表8-1 一些内建异常类

 

Exception            所有异常的基类

AttributeError           特性引用或赋值失败时引发

IOError             试图打开不存在文件(包括其他情况)时引发

IndexError                                         在使用序列中不存在的索引时引发

KeyError              在使用映射中不存在的键时引发

NameError             在找不到名字(变量)时引发

SyntaxError            在代码为错误形式时引发

TypeError             在内建操作或者函数应用于错误类型的对象时引发

ValueError            在内建操作或者函数应用于正确类型的对象,但是该对象使用不合适的值时引发

ZeroDivisionError         在除法或者模除操作的第二个参数为0时引发

 

8.2.2 自定义异常类

尽管内建的异常类已经包括了大部分的情况,而且对于很多要求都已经足够了,但是有些时候还是需要创建自己的异常类。比如在超光速推进装置过载(hyperdrive overload)的例子中,如果能有个具体的HyperDriveError类来表示超光速推进装置的错误状况是不是更自然一些?错误信息是足够了,但是会在8.3节中看到,可以根据异常所在的类,选择性地处理当前类型的异常。所以如果想要使用特殊的错误处理代码处理超光速推进装置的错误,那么就需要一个独立于exceptions模块的异常类。

那么如何创建自己的异常类呢?就像其他类一样,只是要确保从Exception类继承(不管是间接还是直接,也就是说继承其他的内建异常类也是可以的)。那么编写一个自定义异常类基本上就像下面这样:

class SomeCustomException(Exception): pass

还不能做太多事,对吧?(如果你愿意,也可以向你的异常类中增加方法)

 

8.3 捕捉异常

前面曾经提到过,关于异常的最有意思的地方就是可以处理它们(通常叫做诱捕或者捕捉异常)。这个功能可以使用try/except语句来实现。假设创建了一个让用户输入两个数,然后进行相除的程序,像下面这样:

x = input("Enter the first number: ")
y = input("Enter the second number: ")
print x / y

程序工作正常,假如用户输入0作为第二个数

Enter the first number: 10
Enter the second number: 0
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 6, in <module>
    print x / y
ZeroDivisionError: integer division or modulo by zero

为了捕捉异常并且做出一些错误处理(本例中只是输出一些更友好的错误信息),可以这样重写程序:

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ")
    print x / y
except ZeroDivisionError:
    print "The second number can‘t be zero!"

看起来用if语句检查y值会更简单一些,本例中这样做的确很好。但是如果需要给程序加入更多除法,那么就得给每个除法加个if语句。而且使用try/except的话只需要一个错误处理器。

注:如果没有捕捉异常,它就会被“传播”到调用的函数中。如果在那里依然没有捕获,这些异常就会“浮”到程序的最顶层,也就是说你可以捕捉到在其他人的函数中所引发的异常。有关这方面的更多信息,请参见8.10节。

看,没参数

如果捕捉到了异常,但是又想重新引发它(也就是说要传递异常,不进行处理),那么可以调用不带参数的raise(还能在捕捉到异常时显式地提供具体异常,在8.6节会对此进行解释)。

举个例子吧,看看这么做多么有用:考虑一下一个能“屏蔽”ZeroDivisionError(除零错误)的计算器类。如果这个行为被激活,那么计算器就打印错误信息,而不是让异常传播。如果在与用户交互的过程中使用,那么这就有用了,但是如果是在程序内部使用,引发异常会更好些。因此“屏蔽”机制就可以关掉了,下面是这样一个类的代码:

class MuffledCalculator():
    
    muffled = False
    
    def calc(self, expr):
        try:
            return eval(expr)
        except ZeroDivisionError:
            if self.muffled:
                print "Division by zero is illegal"
            else:
                raise

注:如果除零行为发生而屏蔽机制被打开,那么calc方法会(隐式地)返回None。换句话说,如果打开了屏蔽机制,那么就不应该依赖返回值。

下面是这个类的用法示例,分别打开和关闭了屏蔽:

>>> calculator = MuffledCalculator()
>>> calculator.calc("10 / 2")
5
>>> calculator.calc("10 / 0")
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 28, in <module>
    calculator.calc("10 / 0")
  File "/home/marlowes/MyPython/My_Exception.py", line 19, in calc
    return eval(expr)
  File "<string>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero
>>> calculator.muffled = True
>>> calculator.calc("10 / 0")
Division by zero is illegal

当计算器没有打开屏蔽机制时,ZeroDivisionError被捕捉但已传递了。

 

8.4 不止一个except子句

如果运行上一节的程序并且在提示符后面输入非数字类型的值,就会产生另一个异常:

Enter the first number: 10
Enter the second number: "Hello, world!"
Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 8, in <module>
    print x / y
TypeError: unsupported operand type(s) for /: int and str

因为except子句只寻找ZeroDivisionError异常,这次的错误就溜过了检查并导致程序终止。为了捕捉这个异常,可以直接在同一个try/except语句后面加上另一个except子句:

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ")
    print x / y
except ZeroDivisionError:
    print "The second number can‘t be zero!"
except TypeError:
    print "That wasn‘t a number, was it?"

这次用if语句实现可就复杂了。怎么检查一个值是否能被用在除法中?方法很多,但是目前最好的方式是直接将值用来除一下看看是否奏效。

还应该注意到,异常处理并不会搞乱原来的代码,而增加一大堆if语句检查可能的错误情况会让代码相当难读。

 

8.5 用一个块捕捉两个异常

如果需要用一个块捕捉多个类型异常,那么可以将它们作为元组列出,像下面这样:

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ")
    print x / y
except (ZeroDivisionError, TypeError, NameError):
    print "Your numbers were bogus..."

上面的代码中,如果用户输入字符串或者其他类型的值,而不是数字,或者第2个数为0,都会打印同样的错误信息。当然,只打印一个错误信息并没有什么帮助。另外一个方法就是继续要求输入数字直到可以进行除法运算为止。8.8节中会介绍如何实现这一功能。

注意,except子句中异常对象外面的圆括号很重要。忽略它们是一种常见的错误,那样你会得不到想要的结果。关于这方面的解释,请参见8.6节。

 

8.6 捕捉对象

如果希望在except子句中访问异常对象本身,可以使用两个参数(注意,就算要捕捉到多个异常,也只需向except子句提供一个参数——一个元组)。比如,如果想让程序继续运行,但是又因为某种原因想记录下错误(比如只是打印给用户看),这个功能就很有用。下面的示例程序会打印异常(如果发生的话),但是程序会继续运行:

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ")
    print x / y
except (ZeroDivisionError, TypeError), e:
    print e

(在这个小程序中,except子句再次捕捉了两种异常,但是因为你可以显式地捕捉对象本身,所以异常可以打印出来,用户就能看到发生什么(8.8节会介绍一个更有用的方法)。——译者注)

注:在Python3.0中,except子句会被写作except (ZeroDivisionError, TypeError) as e。

 

8.7 真正的捕捉

就算程序能处理好几种类型的异常,但是有些异常还会从眼皮地下溜走。比如还用那个除法程序来举例,在提示符下面直接按回车,不输入任何东西,会的到一个类似下面这样的错误信息(栈跟踪):

Traceback (most recent call last):
  File "/home/marlowes/MyPython/My_Exception.py", line 33, in <module>
    x = input("Enter the first number: ")
  File "<string>", line 0
    
    ^
SyntaxError: unexpected EOF while parsing

这个异常逃过了try/except语句的检查,这很正常。程序员无法预测会发生什么,也不能对其进行准备。在这些情况下,与其用那些并非捕捉这些异常的try/except语句隐藏异常,还不如让程序立刻崩溃。

但是如果真的想用一段代码捕捉所有异常,那么可以在except子句中忽略所有的异常类:

try:
    x = input("Enter the first number: ")
    y = input("Enter the second number: ")
    print x / y
except:
    print "Something wrong happened..."

现在可以做任何事情了:

Enter the first number: "This" is *completely* illegal 123
Something wrong happened...

警告:像这样捕捉所有异常是危险的,因为它会隐藏所有程序员未想到并且未做好准备处理的错误。它同样会捕捉用户终止执行的Ctrl+C企图,以及用sys.exit函数终止程序的企图,等等。这时使用except Exception, e会更好些,或者对异常对象e进行一些检查。

 

8.8 万事大吉

有些情况中,没有坏事发生时执行一段代码是很有用的;可以像对条件和循环语句那样,给try/except语句加个else子句:

try:
    print "A simple task"
except:
    print "What? Something went wrong?"
else:
    print "Ah... It went as planned."

运行之后会的到如下输出:

A simple task
Ah... It went as planned.

使用else子句可以实现在8.5节中提到的循环:

while True:
    try:
        x = input("Enter the first number: ")
        y = input("Enter the second number: ")
        value = x / y
        print "x / y is", value
    except:
        print "Invalid input. Please try again."
    else:
        break

这里的循环只有在没有异常引发的情况下才会退出(由else子句中的break语句退出)。换句话说,只要有错误发生,程序会不断要求重新输入。下面是一个例子的运行情况:

Enter the first number: 1
Enter the second number: 0
Invalid input. Please try again.
Enter the first number: "foo"
Enter the second number: "bar"
Invalid input. Please try again.
Enter the first number: baz
Invalid input. Please try again.
Enter the first number: 10
Enter the second number: 2
x / y is 5

之前提到过,可以使用空的except子句来捕捉所有Exception类的异常(也会捕捉其所有子类的异常)。百分之百捕捉到所有的异常是不可能的,因为try/except语句中的代码可能会出现问题,比如使用旧风格的字符串异常或者自定义的异常类不是Exception类的子类。不过如果需要使用except Exception的话,可以使用8.6节中的技巧在除法程序中打印更加有用的错误信息:

while True:
    try:
        x = input("Enter the first number: ")
        y = input("Enter the second number: ")
        value = x / y
        print "x / y is", value
    except Exception, e:
        print "Invalid input:", e
        print "Please try again"
    else:
        break

下面是示例运行:

Enter the first number: 1
Enter the second number: 0
Invalid input: integer division or modulo by zero
Please try again
Enter the first number: "x"
Enter the second number: "y"
Invalid input: unsupported operand type(s) for /: str and str
Please try again
Enter the first number: quuux
Invalid input: name quuux is not defined
Please try again
Enter the first number: 10
Enter the second number: 2
x / y is 5

 

8.9 最后······

最后,是finally子句。它可以用来在可能的异常后进行清理。它和try子句联合使用:

x = None
try:
    x = 1 / 0
finally:
    print "Cleaning up..."
    del x

上面的代码中,finally子句肯定会被执行,不管try子句中是否发生异常(在try子句之前初始化x的原因是如果不这样做,由于ZeroDivisionError的存在,x就永远不会被赋值。这样就会导致在finally子句中使用del删除它的时候产生异常,而且这个异常是无法捕捉的)。

运行这段代码,在程序崩溃之前,对于变量x的清理就完成了:

Cleaning up...
  File "/home/marlowes/MyPython/My_Exception.py", line 36, in <module>
    x = 1 / 0
ZeroDivisionError: integer division or modulo by zero

注:在Python2.5之前的版本内,finally子句需要独立使用,而不能作为try语句的except子句使用。如果都要使用的话,那么需要两条语句。但在Python2.5及其之后的版本中,可以尽情地组合这些子句。

 

8.10 异常和函数

异常和函数能很自然地一起工作。如果异常在函数内引发而不被处理,它就会传播至(浮到)函数调用的地方。如果在那里也没有处理异常,它就会继续传播,一直到达主程序(全局作用域)。如果那里没有异常处理程序,程序会带着栈跟踪中止。看个例子:

>>> def faulty():
...     raise Exception("Something is wrong")
... 
>>> def ignore_exception():
...     faulty()
... 
>>> def handle_exception():
...     try:
...         faulty()
...     except:
...         print "Exception handled"
... 
>>> ignore_exception()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in ignore_exception
  File "<stdin>", line 2, in faulty
Exception: Something is wrong
>>> handle_exception()
Exception handled

可以看到,faulty中产生的异常通过faulty和ignore_exception传播,最终导致了栈跟踪。同样地,它也传播到了handle_exception,但在这个函数中被try/except语句处理。

 

8.11 异常之禅

异常处理并不是很复杂。如果知道某段代码可能会导致某种异常,而又不希望程序以堆栈跟踪的形式终止,那么就根据需要添加try/except或者try/finally语句(或者它们的组合)进行处理。

有些时候,条件语句可以实现和异常处理同样的功能,但是条件语句可能在自然性和可读性上差些。而从另一方面来看,某些程序中使用if/else实现会比使用try/except要好。让我们看几个例子。

假设有一个字典,我们希望打印出存储在特定的键下面的值。如果该键不存在,那么什么也不做。代码可能像下面这样写:

def describePerson(person):
    print "Description of", person["name"]
    print "Age:", person["age"]
    if "occupation" in person:
        print "Occupation:", person["occupation"]

如果给程序提供包含名字Throatwobbler Mangrove和年龄42(没有职业)的字典的函数,会得到如下输出:

Description of Throatwobbler Mangrove
Age: 42

如果添加了职业camper,会的到如下输出:

Description of Throatwobbler Mangrove
Age: 42
Occupation: camper

代码非常直观,但是效率不高(尽管这里主要关心的是代码的简洁性)。程序会两次查找"occupation"键,其中一次用来检查键是否存在(在条件语句中),另外一次获得值(打印)。另外一个解决方案如下:

def describePerson(person):
    print "Description of", person["name"]
    print "Age:", person["age"]
    try:
        print "Occupation: " + person["occupation"]
    except KeyError: pass

注:这里在打印职业时使用加号而不是逗号。否则字符串"Occupation:"在异常引发之前就会被输出。

这个程序直接假定"occupation"键存在。如果它的确存在,那么就会省事一些。直接取出它的值再打印输出即可——不用额外检查它是否真的存在。如果该键不存在,则会引发KeyError异常,而被except子句捕捉到。

在查看对象是否存在特定特性时,try/except也很有用。假设想要查看某对象是否有write特性,那么可以使用如下代码:

try:
    obj.write
except AttributeError:
    print "The object is not writeable"
else:
    print "The object is writeable"

这里的try子句仅仅访问特性而不用对它做别的有用的事情。如果AttributeError异常引发,就证明对象没有这个特性,反之存在该特性。这是实现第七章中介绍的getattr(7.2.8节)方法的替代方法,至于更喜欢哪种方法,完全是个人喜好。其实在内部实现getattr时也是使用这种方法:它试着访问特性并且捕捉可能引发的AttributeError异常。

注意,这里所获得的效率提高并不多(微乎其微),一般来说(除非程序有性能问题)程序开发人员不用过多担心这类优化问题。在很多情况下,使用try/except语句比使用if/else会更自然一些(更“Python化”),应该养成尽可能使用try/except语句的习惯。

 

8.12 小结

本章的主题如下。

? 异常对象:异常情况(比如发生错误)可以用异常对象表示。它们可以用几种方法处理,但是如果忽略的话,程序就会中止。

? 警告:警告类似于异常,但是(一般来说)仅仅打印错误信息。

? 引发异常:可以使用raise语句引发异常。它接受异常类或者异常实例作为参数。还能提供两个参数(异常和错误信息)。如果在except子句中不使用参数调用raise,它就会“重新引发”该子句捕捉到的异常。

? 自定义异常类:用继承Exception类的方法可以创建自己的异常类。

? 捕捉异常:使用try语句的except子句捕捉异常。如果在except子句中不特别指定异常类,那么所有的异常都会被捕捉。异常可以放在元组中以实现多个异常的指定。如果给except提供两个参数,第二个参数就会绑定到异常对象上。同样,在一个try/except语句中能包含多个except子句,用来分别处理不同的异常。

? else子句:除了except子句,可以使用else子句。如果主try块中没有引发异常,else子句就会被执行。

? finally:如果需要确保某些代码不管是否有异常引发都要执行(比如清理代码),那么这些代码可以放置在finally(注意,在Python2.5以前,在一个try语句中不能同时使用except和finally子句——但是一个子句可以放置在另一个子句中)子句中。

? 异常和函数:在函数内引发异常时,它就会被传播到函数调用的地方(对于方法也是一样)。

 

8.12.1 本章的新函数

本章涉及的新函数如表8-2所示。

表8-2 本章的新函数

warnings,filterwarnings(action, ...)          用于过滤警告

 

8.12.2 接下来学什么

本章讲异常,内容可能有些意外(双关语),而下一章的内容真的很不可思议,恩,近乎不可思议。

Python基础教程(第八章 异常)

标签:

原文地址:http://www.cnblogs.com/Marlowes/p/5428641.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!