python异常介绍

1、异常

                例如:

                def fetcher(obj,index):

                                return obj[index]

                def catcher():

                                try:

                                                fetcher(x,4)

                                except IndexError:

                                                print('got exception')

                                print('continuing')

2、引发异常

                raise IndexError

3、用户定义的异常: 用户定义的异常继承自内置异常类Exception

                class Bad(Exception):

                                pass

4、try/finally

                如果try部分没有发生异常,则finally中部分会执行,finally后面也会执行。如果try部分发生异常,则在finally中的部分会执行,finally后面部分不执行。

5、try/except/else语句

                try:

                                statement

                except name1:

                                statements

                except (name2,name3):

                                statements

                except name4 as data:

                                statements

                except :

                                statements

                else:  #没有发生异常时,执行这部分

                                statements

                解释

                except:   #捕获所有异常

                except name: 捕获特定异常

                except name,value:  捕获所列异常和额外的数据

                except (name1,name2): 捕获列出的异常

                except (name1,name2) value: 捕获列出的异常,并取得额外的数据

                else:  如果没有发生异常,就运行

                finally:  总是会运行此代码

               

               

                Exception的异常几乎与一个空的except具有相同的效果,但是忽略和系统退出相关的异常:

                try:

                                ation()

                except Exception:

                                ...

6、统一try/except/finally语句

                try:

                                main-action

                except Exception1:

                                handler1

                except Exception2:

                                handler2

                else:

                                else-block

                finally:

                                finally-block

                无论发生什么,当main-action代码完成时,而任何引发的异常都已处理后,finally-block就会被执行。事实上,即使异常处理器或者else-block内部有错误发生而引发的新的异常,finally-block内部代码依然会执行

                就像往常一样,finally字句并没有终止异常,当finally-block执行时,如果异常还在,就会在finally-block代码执行后继续传递。而控制权会跳至程序其他地方(到另外一个try,或者默认顶层处理器)如果finally执行时,没有异常处于激活状态,控制权就会在整个try语句之后继续执行。

7、raise语句

                raise <instance>  #抛出一个类的实例

                raise <class>     #产生一个类的实例并抛出

                raise                                        #重新抛出最近最常用的异常

                例如:

                raise  IndexError   #class (instance create)

                raise  IndexError               #instance(create in statement)

               

                如果一个try包含了一个名为except name as X:字句,变量x将会分配给引发中提供的实例:

                try :

                                ...

                except IndexError as X:  #x被赋予成IndexError的实例

                                ...

                利用raise传递异常

                raise语句不包括异常名称或额外数据值时,就是重新引发当前异常。如果需要捕捉异常和处理一个异常,又不希望异常在程序中死掉时,一般就会使用这种形式。

                例如:

                try:

                                raise IndexError('spam')

                except IndexError:

                                print('propagating')

                                raise

                通过这种方式执行raise时,会重新引发异常,并将其传递给更高层的处理器(或者顶层的默认处理器,他会停止程序,打印标准错误消息)     。

8、python3.0异常链:raise  from

                raise exception from otherexception

                当使用from的时候,第二个表达式指定了另一个异常类或实例,他会附加到引发异常的__cause__属性。如果引发的异常没有捕获,python把异常也作为标准出错信息的一部分打印出来。

9、assert语句

                assert <test>,<data>

                1、assert语句用来声明某个条件是真的。

                2、如果你非常确信某个你使用的列表中至少有一个元素,而你想要检验这一点,并且在它非真的时候引发一个错误,那么assert语句是应用在这种情形下的理想语句。

                3、当assert语句失败的时候,会引发一AssertionError。

10、with/as环境管理器

                在python2.6和python3.0中引入了一种新的异常相关的语句

                如果想在python2.5中使用的话,必须使用如下语句来激活

                from __future__ import with_statement

                基本使用

                with expression [as varible]:

                                with-block

11、环境管理协议

                1、计算表达式,所得到的对象称为环境管理器,它必须有__enter__和 __exit__方法

                2、环境管理器的__enter__方法会被调用,如果as字句存在,其返回值会赋值给as子句中的变量,否则抛弃。

                3、代码嵌套代码会执行

                4、如果with代码块引发异常,__exit__(type,value,traceback)方法会被调用.这些也是由sys.exc_info返回相同的值。否则 异常会终止。正常情况下异常应该重新引发,这样的话才能传递到with语句之外

                5、如果with代码没有引发异常,__exit__方法依然会被调用,其type,value以及traceback参数都会以 None传递

                例如:

                class TraceBlock:

                                def         message(self,arg):

                                                print('running',arg)

                                def __enter__(self):

                                                print('starting with block')

                                                return self

                                def __exit__(self,exc_type,exc_value,exc_tb):

                                                if exc_type is None:

                                                                print('exited normally
')

                                                else:

                                                                print('raise an exception!',exc_type)

                                                                return False

                with TraceBlock() as action:

                                action.message('test 1')

                                print(reached)

                with TraceBlock() as action:

                                action.message('test 2')

                                raise TypeError

                                print('not reached')

12、内置Exception类

                BaseException   异常的顶级根类。这个类不能当作用户定义的类直接继承(使用Exception)。它提供了子类所继承的默认的打印和状态保持行为。如果在这个类的一个实例上调用str内置函数时,该类返回创建实例的时候所传递的构造函数的显示字符串(如果没有参数的话,返回一个空字符串),此外除非子类替换了这个类的构造函数,在实例构造时候传递给这个类的所有参数都将作为一个元组存储在args属性中

                Exception            与应用相关的异常的顶层超类。这是BaseException的一个直接子类,并且是所有其他内置异常类的超类,除了系统退出实践之类(SystemExit.KeyboardInterrupt和GenatorExit)。几乎所有用户定义的类都应该继承自这个类,而不是BaseException。当遵循这个惯例的时候,在一条try预计的处理器中指名Exception,确保你的程序将捕获出系统退出事件之外的所有异常,通常该事件是允许通过的。实际上,Exception变成了try预计中的一个全捕获,并且比一条空的Except更精确。

                ArithmeticError   所有数值错误的超类(并且是Exception的一个子类)

                OverflowError   识别特定数值错误的子类

  

原文地址:https://www.cnblogs.com/hbcb533/p/3712183.html