zoukankan      html  css  js  c++  java
  • python学习笔记10异常处理

    一、异常基础
    try/except:捕捉由代码中的异常并恢复,匹配except里面的错误,并自行except中定义的代码,后继续执行程序(发生异常后,由except捕捉到异常后,不会中断程序,继续执行try语句后面的程序)
    try/finally: 无论异常是否发生,都执行清理行为 (发生异常时程序会中断程序,只不过会执行finally后的代码)
    raise: 手动在代码中接触发异常。
    assert: 有条件地在程序代码中触发异常。
    with/as 在Python2.6和后续版本中实现环境管理器。
    用户定义的异常要写成类的实例,而不是字符串、。
    finally可以和except和else分句出现在相同的try语句内、
    1、异常的角色
    错误处理
    事件通知
    特殊情况处理:有时发生很罕见的情况,很难调整代码去处理。通常会在异常处理器中处理这些罕见的情况,从而省去编写应对特殊情况的代码
    终止行为
    非常规控制流程
    >>> x='diege
    >>> def fetcher(obj,index):
    ... return obj[index]
    ...
    >>> fetcher(x,4)
    'e'
    >>> fetcher(x,5)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<stdin>", line 2, in fetcher
    IndexError: string index out of range
    >>> try:
    ... fetcher(x,5) #尝试抓取第5个字符
    ... except IndexError: #如果发生异常【指出引发的异常名称】
    ... print fetcher(x,-1) #那就抓取最后一个字符
    ...
    e
    >>> def catcher():
    ... try:
    ... fetcher(x,5)
    ... except IndexError:
    ... print fetcher(x,-1)
    ... print "continuing"
    ...
    >>> catcher()
    e
    continuing
    可以看到从异常中恢复并继续执行。
    try/finally: 无论异常是否发生,都执行清理行为(发生异常时程序也会终端,只不过会执行finally后的代码)

    >>> try:
    ... fetcher(x,4)
    ... finally:
    ... print 'after fetch'
    ...
    'e'
    after fetch
    没有发生异常的情况,也执行finally语句中的代码
    发生异常的情况下
    >>> try:
    ... fetcher(x,5)
    ... finally:
    ... print 'after fetch'
    ...
    after fetch
    Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
    File "<stdin>", line 2, in fetcher
    IndexError: string index out of range
    发生异常的情况下,也执行了finally语句中的代码
    实际应用镇南关,try/except的组合可用于捕捉异常并从中恢复,而try/finally的组合则很方便,可以确保无论try代码块内的
    代码是否发生异常,终止行为一定会运行。如,try/except来捕捉第三方库导入的代码所引发的错误,然后以try/finally来确保
    关闭文件,或者终止服务器连接等调用。
    可以在同一个try语句内混合except和finally分句:finally一定回执行,无论是否有异常引发,而且不也不关异常是否被except分句捕捉到
    2、try/except/else语句
    try的完整形式:try/多个except/else语句
    else是可选的
    try首行底下的代码块代表此语句的主要动作:试着执行的程序代码。except分句定义try代码块内引发的异常处理器,而else分句(如果有)则是提供没有发生异常时候要执行的处理器。
    *如果try代码块语句执行时发生了异常,Python就跳回try,执行第一个符合引发的异常的except分句下面的语句。当except代码执行后(除非 except代码块引发另一异常),控制全就会到整个try语句后继续执行。
    *如果异常发生在try代码块内,没有符合的except分句,异常就会向上传递到程序的之前进入try中,或者到这个进程的顶层(使用Python终止这个程序并打印默认的错误消息)
    *如果try首行底下执行的语句没有发生异常,Python就会执行else行下的语句(如果有的话),控制权会在整个try语句下继续。
    也就是说except分句会捕捉try代码块执行时所有发生的任何异常,而else分句只在try代码执行没有发生异常时才执行,finally分句无法释放发生异常都执行。
    3、try语句分句形式
    分句形式 说明
    except: 捕捉所有(其他)异常类型
    except name: 只捕捉特定的异常
    except name,value: 捕捉所有的异常和其额外的数据(或实例)
    except (name1,name2) 捕捉任何列出的异常
    except (name1,name2),value: 捕捉任何列出的异常,并取得其额外数据
    else: 如果没有引发异常,就运行
    finally: 总是会运行此代码块,无论是否发生异常
    except:用在想不到异常情况,在except:前面可以定义可以想到的异常:except name1: except name2:
    3、try/else分句
    try:
    customer=getargv[1]
    except IndexError:
    print "please give argv as customer!"
    else:
    scene=PizzaShop()
    scene.order(customer)
    print '...'
    如把else:语句的内容放到try:中,也能执行。模拟出else分句。不过这可能造成不正确的异常分类。如果“没有异常发生”这个行为触发了
    IndexError,就会视为try代码块的失败,因此错误地触发try底下的异常处理器。改为明确的else分句,让逻辑封明确。保证except处理器
    只会因为包装在try中代码真正的失败而执行,而不是为else中的情况行为失败而执行。
    4、try/finally分句
    python先运行try: 下的代码块:
    如果try代码块运行时没有异常发生,Python会跳至finally代码块。然后整个try语句后继续执行下去。
    如果try代码块运行时有发生异常,Python依然会回来运行finally代码块,但是接着会把异常向上传递到较高的try语句或顶层的默认处理器。程序不会在try语句继续执行。
    try:
    Uppercase(open('/etc/rc.conf'),output).process()
    finally:
    open('/etc/rc.conf').close
    5、统一try/except/finally分句
    try:
    main-action:
    except Exception1,e:
    hander1
    print e
    except Exception2:
    hander2
    ...
    else:
    else-block
    finally:
    finally-block
    这语句中main-action代码会先执行。如果该程序代码(main-action)引发异常,那么except代码块都会逐一测试,寻找与抛出的异常相符的语句。如果引发异常的是Exception1则会执行hander1代码块,如果引发异常的是Exception2,则会执行hander2代码块。以此类推。如果没有
    引发异常,将会执行else-block代码块。
    无论前面发生什么,当main-action代码块完成时。finally-block都会执行。
    6、通过嵌套合并except和finally
    try:
    try:
    main-action:
    except Exception1:
    hander1
    except Exception2:
    hander2
    ...
    else:
    else-block
    finally:
    finally-block
    和5的效果一样
    7、raise语句
    要故意触发异常,可以使用raise语句。raise语句组成是: raise关键字,后面跟着要引发的异常名称(选用),以及一个可选的额外的数据项,后可随着异常传递
    raise <name>
    raise <name>,<data>
    raise
    注意:<name>需要预先定义好,不然会由未定义错误。
    第二种形式随着异常传递额外的数据项,在raise语句中,数据是列在异常名称的后面的;在try语句中,取得该数据是通过引入一个进行接收
    它的变量实现的。例如,如果try引入一个exceptname,X:语句,则变量X就会被赋值为raise内所列出的额外的数据项,如果没有定义默认接受到
    的就是特殊对象None。一旦被程序中任意的except分句捕捉,异常就死了(也就是说,不会传递给另一个try),除非又被另一个raise语句或
    错误所引发。现在用户定义的异常应该是类实例对象。

    rasie 语法 描述
    raise exclass 触发一个异常,从exclass 生成一个实例(不含任何异常参数)
    raise exclass() 同上,除了现在不是类;通过函数调用操作符(function calloperator:
    "()")作用于类名生成一个新的exclass 实例,同样也没有异常参数
    raise exclass, args 同上,但同时提供的异常参数args,可以是一个参数也可以元组
    raise exclass(args) 同上
    raise exclass,args, tb 同上,但提供一个追踪(traceback)对象tb 供使用
    raise exclass,instance 通过实例触发异常(通常是exclass 的实例);如果实例是exclass
    的子类实例,那么这个新异常的类型会是子类的类型(而不是
    exclass);如果实例既不是exclass 的实例也不是exclass 子类的
    实例,那么会复制此实例为异常参数去生成一个新的exclass 实例.
    raise instance 通过实例触发异常: 异常类型是实例的类型; 等价于raise
    instance.__class__, instance (同上).
    raise string (过时的) 触发字符串异常
    raise string, args 同上,但触发伴随着args
    raise string, args, tb 同上,但提供了一个追踪(traceback)对象tb 供使用
    raise (1.5 新增)重新触发前一个异常,如果之前没有异常,触发TypeError.

    8、assert语句 断言
    assert可以有条件地在程序代码中触发异常,可以认为是有条件的raise.
    牢记:assert几乎都是用来收集用户定义的约束条件,而不是捕捉内在的程序设计错误。因为Python会自动收集程序的设计错误,通常咩有必要写assert去捕捉超出索引值,类型不匹配以及除数为0之类的事。
    引发的异常为:AssertionError。如果没有被try捕捉到,就会终止程序。
    该语句形式:
    assert <test>,<data>
    实例
    >>> def f(x):
    ... assert x>0,'x must be great zerot'
    ... return x**2
    ...
    >>> f(2)
    4
    >>> f(-1)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<stdin>", line 2, in f
    AssertionError: x must be great zerot

    二、with/as环境管理
    python2.6引入新的异常相关的语句:with及其可选的as分句。这个语句的设计是为了和环境管理器对象(支持新的方法协议)一起工作。
    简而言之, with/as语句的设计作为常见try/finally用法模式的替代方案。就像try/finally语句, with/as语句也用于定义必须执行的
    终止或“清理"行为,无论步骤中是否发生异常。和try/finally不同的是,with语句支持更丰富的基于对象的协议,可以代码块定义支持进入
    和离开动作。
    with语句基本格式:
    with expression [as variable]:
    with block
    在这里expression要返回一个对象,从而支持环境管理协议。如果选用as分句存在时,此对象也可返回一个值,赋值给变量名variable.
    注意:variable并非赋值为expression的结果,expression的结果是支持环境协议的对象,而variable则是赋值为其他的东西(??)
    然后,expression返回的对象可在with-block开始前,先自行启动程序,并且在该代码块完成后,执行终止程序代码,无论代码块是否引发异常
    有些内置的Python对象已得到强化,支持环境管理协议,因此可以用于with语句。例如,文件对象有环境管理器,可在with代码块后自动关闭
    文件,无法是否引发异常。
    >>> with open('/etc/rc.conf') as myfile:
    ... for line in myfile:
    ... line=line.upper()
    ... print line
    在这里,对open的调用,会返回一个简单文件对象,赋值给变量名myfile。我们可以用一般的文件工具使用myfile:就此而言,文件迭代器会在
    for循环内逐行读取。
    然后,此对象也支持with语句所使用的环境协议。在这个with语句执行后。环境管理机制保证由myfile所引用的文件对象自动关闭。即时处理
    该文件时,for循环引发了异常。
    环境管理器是有写高级的机制。还不是Python的正式组成部分。就较为简单的用途来说,try/finally语句可对终止活动提供足够的支持。

    with工作于上下文管理协议的对象,比如文件和线程
    with比try更简洁
    因为已经从你手边拿走了一堆细节,所以实际上只是进行了两层处理:
    第一,发生用户层 —— 和 in 类似,你所需要关心的只是被使用的对象
    第二,在对象层.既然这个对象支持上下文管理协议,它干的也就是"上下文管理".

    上下文管理协议介绍
    1)上下文表达式(context_expr),上下文管理器
    当with 语句执行时,便执行上下文符号(译者注:就是with 与as 间内容)来获得一个上下文管理
    器.上下文管理器的职责是提供一个上下文对象.这是通过调用__context__()方法来实现的.该方法
    返回一个上下文对象,用于在with 语句块中处理细节.有点需要注意的是上下文对象本身就可以是上
    下文管理器.所以context_expr 既可以为一个真正的上下文管理器,也可以是一个可以自我管理的上
    下文对象.在后一种情况时,上下文对象仍然有__context__()方法,返回其自身,如你所
    2)上下文对象,with 语句块
    一旦我们获得了上下文对象,就会调用它的__enter()__方法.它将完成with 语句块执行前的所
    有准备工作.你可以注意到在上面的with 行的语法中有一个可选的as 声明变量跟随在context_expr
    之后.如果提供提供了变量,以__enter()__返回的内容来赋值;否则,丢弃返回值.在我们的文件对象
    例子中,上下文对象的__enter()__返回文件对象并赋值给f.
    现在,执行了with 语句块.当with 语句块执行结束,无论是"和谐地"还是由于异常,都会调用上
    下文对象的__exit()__方法.__exit__()有三个参数.如果with 语句块正常结束,三个参数全部是
    None.如果发生异常,三个参数的值的分别等于调用sys.exc_info()函数(见10.12)返回的三个值:类
    型(异常类),值(异常实例),和回溯(traceback),相应的回溯对象.
    你可以自己决定如何在__exit__()里面处理异常.惯例是当你处理完异常时不返回任何值,或
    返回None,或返回其他布尔值为False 对象.这样可以使异常抛给你的用户来处理.如果你明确的想
    屏蔽这个异常,返回一个布尔为True 的值.如果没有发生异常或你在处理异常后返回True,程序会继
    续执行with 子句后的下一段代码.
    因为上下文管理器主要作用于共享资源,你可以想象到__enter()__和__exit()__方法基本是干
    的需要分配和释放资源的低层次工作,比如:
    数据库连接,锁分配,信号量加减,状态管理,打开/关闭文件,异常处理,等等.
    为了帮助你编写对象的上下文管理器, 有一个contextlib 模块, 包含了实用的
    functions/decorators, 你可以用在你的函数/ 对象上而不用去操心关于类或
    __context__(),__enter()__,__enter()__,__exit()__这些方法的实现.

    _context__()方法 __enter()__方法 _exit()__方法 有一个contextlib 模块

    三、异常对象
    基于类的异常可以创建各种异常类,有附加状态信息,而且支持继承。尽量都适用类异常。类异常有如下特点;
    * 提供类型分类,对今后的修改有更好的支持:以后增加新异常时,通常不需要在try语句中进行修改。
    * 同了存储在try处理器中所使用的环境信息的合理地点:这样的话,可以拥有状态信息,以及可调用的方法,并且可通过实例进行读取。
    * 允许异常参与继承层次,从而可获得共同的行为。例如,继承的显示方法可提供通用的错误消息外观。
    所有内置异常都类组织成继承树。
    Python2.5版本 字符串异常会产生'deprecation‘(不建议使用)’警告。python3.0将不再支持字符串异常。
    1、基于字符串的异常
    >>> myexc="My exception string"
    >>> try:
    ... raise myexc
    ... except myexc:
    ... print "caught"
    ...
    Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
    TypeError: exceptions must be old-style classes or derived from BaseException, not str
    Python 2.7版本已经不在支持了
    2、基于类的异常
    >>> class General:pass
    >>> class Spec1(General):pass
    >>> class Spec2(General):pass
    >>> def raiseer0():
    ... X=General()
    ... raise X
    >>> def raiseer1():
    ... X=Spec1()
    ... raise X
    >>> def raiseer2():
    ... X=Spec2()
    ... raise X
    >>> for func in (raiseer0,raiseer1,raiseer2):
    ... try:
    ... func()
    ... except General:#使用异常的超类General,这样子类也捕捉到,可以在未来增加函数异常(在子类里),而不影响程序。
    ... import sys
    ... print 'caught:',sys.exc_info()[0]
    ...
    caught:__main__.General
    caught:__main__.Spec1
    caught:__main__.Spec2
    在try语句中,捕捉其超类就会捕捉这个类,以及类树中超类下的所有子类:超类会变成异常分类的名称,而子类会变成该分类中特定的
    异常类型。
    Python2.5以后版本将每个异常都写成类(必须),从异常树顶层继承Exception(非必须)。
    sys.exc_info() 一种抓取最近发生异常的常用方式。
    对基于类的异常而言,其结果中第一个元素就是引发异常类,而第二个是实际引发的实例。
    注意:目前Python的说明文件指出,用户定义的异常最好继承自Exception内置的异常(但不是必须要求)。
    class General(Exception):pass
    就大型多层次的异常而言,在一个except分句使用类捕捉分类,会比列出一个分类中每个成员更简单。新增子类扩展异常层次,。也不会破坏
    先有的代码。
    如果不用类,在excpet中就会是excpet (General,Spec1,Spec2): 这样捕捉字符串类。
    基本原则是:在异常处理器中,通常来说具体要优于一般。
    3、内置Exception类
    Python把内置异常组织成层次,来支持各种捕捉模式
    Exception: 异常的顶层根超类
    StandardError: 所有内置错误异常的超类
    ArithmeticError: 所有数值错误的超类
    OverflowError: 识别特定的数值错误的子类
    可以在Python库手册或exceptionsn模块的帮助文本中查阅。
    >>> import exceptions
    >>> help(exceptions)
    BaseException
    Exception
    StandardError
    ArithmeticError
    FloatingPointError
    OverflowError
    ZeroDivisionError
    AssertionError
    4、定义异常文本
    对基于类的异常而言,其结果中第一个元素就是引发异常类,而第二个是实际引发的实例。
    >>> raise MyBad():
    >>> raise MyBad()
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    __main__.MyBad: <__main__.MyBad instance at 0x2850d26c>
    这样的显示不友好。改进显示,可以在类中定义__repr__或__str__显示字符串重载方法,从而返回异常达到想要默认处理器显示字符串。
    >>> class MyBad():
    ... def __repr__(self):
    ... return "Sorry--my mistake!"
    ...
    >>> raise MyBad()
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    __main__.MyBad: Sorry--my mistake
    这样把显示类的实例改为了我们定义的文本。
    注意:如果继承自内置异常类,错误测试会有细微的改变,构造方法参数会自动存储并显示在消息中。【同样也可以把继承的重载】
    >>> class MyBad(Exception):pass
    ... >>> raise MyBad()
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    __main__.MyBad
    >>> raise MyBad('the','bright','side','of')
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    __main__.MyBad: ('the', 'bright', 'side', 'of')
    5、发送额外数据和实例行为
    把环境信息附加在基于类的异常的办法是:在引发的实例对象中填写实例的属性,通常是在类的构造器方法中。在异常处理器中,是列出
    要赋值为引发的实例的变量,然后通过这个变量名来读取附加的转改信息,并且调用任何基础的类方法。【很强大的功能】
    >>> class FormatError:
    ... def __init__(self,line,file):
    ... self.line=line
    ... self.file=file
    >>> def parser():
    ... raise FormatError(42,file='diege.txt') #手动定义异常,基于类的异常,类构造函数传递两个数据。
    ...
    >>> try:
    ... parser()
    ... except FormatError,X: #定义接受异常(类的实例-异常引发时产生的实例)传递过来数据的变量。
    ... print 'Error at',X.file,X.line #显示实例传递过来的数据
    ...
    Error at diege.txt 42
    字符串的格式为【已过时】
    raise formatError,{'file':'diege.txt','line':43}
    except FormatError,X:
    print 'Error at',X['file'],X['line']
    6、raise的一般形式
    raise string #基于字符串的异常,已过时
    raise string,data #基于字符串的异常,已过时
    raise instance #最常用的模式,直接接一个实例:raise FormatError(42,file='diege.txt')
    raise class,instance
    raise
    为了和内置异常为字符串的的旧版兼容,也可以
    raise class #same as :raise class()
    raise class,arg # same as :raise class(arg)
    raise clase(arg1,arg2,...) #same as:raise class(arg1,arg2...)
    这些都相当于raise class(arg),等效于raise instance形式
    >>> def parse():
    ... raise FormatError,(42,'diege.txt')

    四、异常的设计
    1、嵌套异常处理器
    把内部的try写成函数来嵌套
    >>> def action2():
    ... print 1+[]
    >>> def action1():
    ... try:
    ... action2()
    ... except TypeError:
    ... print "inner try"
    >>> try:
    ... action1()
    ... except TypeError:
    ... print "outer try"
    ...
    inner try
    使用语法嵌套
    >>> try:
    ... try:
    ... action2()
    ... except TypeError:
    ... print "inner try"
    ... except TypeError:
    ... print "outer try"
    ...
    inner try
    嵌套的finally语句会因一个异常全部启动。
    >>> try:
    ... try:
    ... raise IndexError
    ... finally:
    ... print "diege"
    ... finally:
    ... print "DIEGE"
    ...
    diege
    DIEGE
    Traceback (most recent call last):
    File "<stdin>", line 3, in <module>
    IndexError
    2、异常的习惯用户
    1)异常不总是错误
    在Python中,所有的错误都是异常。但并非所有的异常都是错误。
    >>> while 1:
    ... try:
    ... line=raw_input()
    ... except EOFError:
    ... break
    ... else:
    ... print "print ...process nex line here.."
    raw_input()在文件末尾引发内置的EOFError
    2)函数信号条件和raise
    用户定义的异常也可以引发非错误的情况。
    用于任何无法返回警示值以表明成功或失败的函数。
    class Failure(Exception):pass
    def searcher():
    if ...success...;
    return ...founditem...
    else:
    raise Failure()
    try:
    item=searcher()
    except Failure:
    ...report...
    else:
    ...use item here...
    Python核心是动态类型和多态,通常更倾向于是用异常来发出这类情况的信号,而不是警示性的返回值。
    3)在try外进行调试
    空的except分句会捕捉任何程序执行时所引发的而未被捕捉到的异常。要取得发生的实际异常,可以从内置的
    sys模块取出sys.exc_info函数的调用结果。这会返回一个元组,而元组之前两个元素会自动包含当前异常的名称,
    以及相关的额外数据(如果有)。就基于类的异常而言,这两个元素分别对应的是异常的类以及引发类的实例。
    4)运行进程中的测试
    5)关于sys.exc_info
    sys.exc_info结果是获得最近引发的异常更好的方式。如果没有处理器正在处理,就返回包含了三个None值的元组。
    否则,将会返回(type,value和traceback)
    *type是正在处理的异常的异常类型(一个基于类的异常的类对象)
    *value是异常参数(它的关联值或raise的第二个参数,如果异常类型为类对象,就一定是类实例)
    *traceback是一个traceback对象,代表异常最初发生时所调用的堆栈。
    2、与异常有关的技巧
    大致来说,Python的异常在使用上都很简单。异常背后真正的技巧在于确定except分句要具体或多通用,以及try语句中要包括多少代码。
    1)应该包装什么?
    try语句中要包括多少代码。
    简要原则
    *经常会失败的运算一般都应该包装在try语句内。例如:和系统状态衔接的运算(文件开启,套接字调用等等)就是try的主要候选者。
    *尽管这样,上一条规则有写特例:在简单的脚本中,你会希望这类运算失败时终止程序,而不是被捕捉或被忽略。如果是一个重大的错误,
    更应如此。Python的错误会产生有用的错误信息,而且这通常就是所期望的最好的结果。
    *应该try/finally中实现终止动作,从而保证它们的执行。这个语句形式可执行代码,无论异常是否发生。
    *偶尔,把对大型函数的调用包装在单个try语句内,而不是让函数本身零散着放入若干try的语句中。这样会更方便。这样的话,函数中的异常
    就会往上传递到调用周围的try,而你也可以减少函数中的代码量。
    2)捕捉太多:避免空except语句
    如果使用空except语句,可能拦截到异常嵌套结构中较高层的try处理器所期待的事件这类代码可能会捕捉无关的系统异常。如内存错误,一
    程序错误,迭代停止以及系统推出等等,都会在Python中引发异常。这里异常通常是不应该拦截的。
    3)捕捉太少:使用基于类的分类
    3、核心语言总结
    1)Python工具集
    一般而言,Python提供了一个有层次的工具集。
    内置工具:
    像字符串,列表和字典这些内置类型,会让编写程序更为迅速。
    Python扩展:
    就更重要的任务来说,可以编写自己的函数,模块以及类来扩展Python
    已编译的扩展:
    Python的工具箱类型。
    分类 例子
    对象类型 列表,字典,文件和字符串
    函数 len,range,apply,open
    异常 IdexError,KeyError
    模块 os,TKinter,pickle,re
    属性 __dict__,__name__,__class__
    外部工具 NumPY,SWIG,Jython,IronPython
    2)大型项目的开放工具
    PyDoc
    PyChecker 检查
    PyUnit 测试
    doctest 测试
    IDE 图形界面
    配置工具 profile是标准块模块,为python实现源代码配置工具。
    调试器:源代码调试器模块,称为pdb, 类似C的命令行调试器gdb
    >>> import pdb
    >>> pdb.run("main()") #下面就可以在交互模式下执行代码调试命令
    > <string>(1)<module>()
    (Pdb) action1
    <function action1 at 0x28495bc4>
    (Pdb) action1()
    inner try
    发布选择:Python程序常见打包工具。py2exe,PyInstaller以及freeze都可以打包字节码以及Python虚拟机
    优化选项:Psyco系统提供了实时的编译器,可以把Python字节码翻译成二进制码。
    对大型醒目的提示


    五、标准异常
    核心编程375页

    六、异常和sys 模块
    另一种获取异常信息的途径是通过sys 模块中exc_info()函数. 此功能提供了一个3 元组
    (3-tuple)的信息, 多于我们单纯用异常参数所能获得. 让我们看看如何用sys.exc_info() :
    >>> try:
    ... float('abc123')
    ... except:
    ... import sys
    ... exc_tuple = sys.exc_info()
    >>> for eachItem in exc_tuple:
    ... print eachItem
    ... exceptions.ValueError
    invalid literal for float(): abc123
    <traceback object at 10de18>
    我们从sys.exc_info()得到的元组中是:
    ?? exc_type: 异常类
    ?? exc_value: 异常类的实例
    ?? exc_traceback: 追踪(traceback)对象
    我们所熟悉的前两项:实际的异常类, 和这个异常类的实例(和在上一节我们讨论的异常参数
    是一样的) . 第三项, 是一个新增的追踪(traceback)对象. 这一对象提供了的发生异常的上下文.
    它包含诸如代码的执行帧,异常发生时的行号等信息.
    在旧版本中的Python 中, 这三个值分别存在于sys 模块, 为sys.exc_type , sys.exc_value ,
    sys.exc_traceback . 不幸的是, 这三者是全局变量而不是线程安全的. 我们建议亡羊补牢, 用
    sys.exc_info()来代替. 在未来版本Python 中,所有这三个变量都将被逐步停用,并最终移除.

    七、异常相关模块
    模块 描述
    exceptions 内建异常(永远不用导入这个模块)
    contextliba 为使用with 语句的上下文对象工具
    sys 包含各种异常相关的对象和函数(见sys.ex*)

  • 相关阅读:
    河北工业大学2021年高等代数考研试题, 湖南大学2021年数学分析考研试题, 湖南大学2021年高等代数考研试题
    锦哥湖南大学2021年高等代数考研试题参考解答
    锦哥湖南大学2021年数学分析考研试题参考解答
    锦哥河北工业大学2021年高等代数考研试题参考解答
    76套2021年数学分析高等代数考研试题pdf
    DevComponents.DotNetBar2 添加到工具栏方法
    在创建maven简单项目时,Description Resource Path Location Type web.xml is missing and <failOnMissingWebXml> is set to true
    jsp头部报错:The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path
    windows查看8080端口并杀死进程
    Spring MVC方式搭建Dubbo监听器后台
  • 原文地址:https://www.cnblogs.com/diege/p/2709432.html
Copyright © 2011-2022 走看看