Java自学者论坛

 找回密码
 立即注册

手机号码,快捷登录

恭喜Java自学者论坛(https://www.javazxz.com)已经为数万Java学习者服务超过8年了!积累会员资料超过10000G+
成为本站VIP会员,下载本站10000G+会员资源,会员资料板块,购买链接:点击进入购买VIP会员

JAVA高级面试进阶训练营视频教程

Java架构师系统进阶VIP课程

分布式高可用全栈开发微服务教程Go语言视频零基础入门到精通Java架构师3期(课件+源码)
Java开发全终端实战租房项目视频教程SpringBoot2.X入门到高级使用教程大数据培训第六期全套视频教程深度学习(CNN RNN GAN)算法原理Java亿级流量电商系统视频教程
互联网架构师视频教程年薪50万Spark2.0从入门到精通年薪50万!人工智能学习路线教程年薪50万大数据入门到精通学习路线年薪50万机器学习入门到精通教程
仿小米商城类app和小程序视频教程深度学习数据分析基础到实战最新黑马javaEE2.1就业课程从 0到JVM实战高手教程MySQL入门到精通教程
查看: 28|回复: 0

Python异常处理详解

[复制链接]
  • TA的每日心情
    奋斗
    昨天 21:54
  • 签到天数: 95 天

    [LV.6]常住居民II

    1378

    主题

    1435

    帖子

    5万

    积分

    管理员

    Rank: 9Rank: 9Rank: 9

    积分
    50644
    发表于 2021-6-14 06:19:06 | 显示全部楼层 |阅读模式

    在shell脚本中,常用if来判断程序的某个部分是否可能会出错,并在if的分支中做出对应的处理,从而让程序更具健壮性。if判断是异常处理的一种方式,所有语言都通用。对于特性完整的编程语言来说,都有专门的异常处理机制,有些语言用起来可能会很复杂,要求一堆堆的,有些语言则非常简洁,用起来非常通畅。

    入门示例

    异常处理:try/except

    对于索引查找的操作,在索引越界搜索的时候会报错。例如:

    >>> s="long"
    >>> s[4]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    IndexError: string index out of range
    

    所报的错误是IndexError。如果将索引查找放在一个函数里:

    >>> def fetcher(obj,index):
    ...     return obj[index]
    

    那么调用函数的时候,如果里面的索引越界了,异常将汇报到函数调用者。

    >>> fetcher(s,3)
    'g'
    
    >>> fetcher(s,4)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 2, in fetcher
    IndexError: string index out of range
    

    可以使用try/except来捕获异常。作为入门示例,下面是简单版的格式:

    try:
        statement1
        ...
        statementN
    except <ERRORTYPE>:
        ...statementS...
    

    例如,try中是要监视正确执行与否的语句,ERRORTYPE是要监视的错误类型。

    • 只要try中的任何一条语句抛出了错误,try中该异常语句后面的语句都不会再执行;
    • 如果抛出的错误正好是except所监视的错误类型,就会执行statementS部分的语句;
    • 如果异常正好被except捕获(匹配)到了,程序在执行完statementS后会继续执行下去,如果没有捕获到,程序将终止;
      • 换句话说,except捕获到错误后,相当于处理了这个错误,程序不会因为已经被处理过的错误而停止

    例如捕获上面的函数调用:

    def fetcher(obj, index):
        return obj[index]
    
    s = "long"
    try:
        print(fetcher(s, 3) * 4)
        print(fetcher(s, 4) * 4)
    except IndexError:
        print("something wrong")
    
    print("after Exception, Continue")
    

    输出结果:

    gggg
    something wrong
    after Exception, Continue
    

    因为上面的fetcher(s, 4)会抛出异常,且正好匹配except监视的异常类型,所以输出something wrong,异常被处理之后,程序继续执行,即try/except后面的print()。

    异常处理:try/finally

    finally是try之后一定会执行的语句段落。可以结合except一起使用。

    try:
        statement1
        ...
        statementN
    finally:
        ...statementF...
    
    try:
        statement1
        ...
        statementN
    except <ERRORTYPE>:
        ...statementS...
    finally:
        ...statementF...
    

    不论try中的语句是否出现异常,不论except是否捕获到对应的异常,finally都会执行:

    • 如果异常没有被捕获,则在执行finally之后程序退出
    • 如果异常被except捕获,则执行完except的语句之后执行finally的语句,然后程序继续运行下去

    一般来说,finally中都会用来做程序善后清理工作。

    例如:

    def fetcher(obj, index):
        return obj[index]
    
    s = "long"
    try:
        print(fetcher(s, 3) * 4)
        print(fetcher(s, 4) * 4)
    except IndexError:
        print("something wrong")
    finally:
        print("in finally")
    
    print("after Exception, Continue")
    

    输出:

    gggg
    something wrong
    in finally
    after Exception, Continue
    

    如果把except那段代码删掉,得到的结果将是:

    gggg
    in finally      # 输出了finally的内容
    Traceback (most recent call last):
      File "g:/pycode/list.py", line 8, in <module>
        print(fetcher(s, 4) * 4)
      File "g:/pycode/list.py", line 2, in fetcher
        return obj[index]
    IndexError: string index out of range
    

    产生异常:raise和assert

    使用raise或assert可以主动生成异常情况。其中raise可以直接抛出某个异常,assert需要通过布尔值来判断,然后再抛出给定的错误。

    例如,在函数里做个没什么用的的判断,用来演示raise:

    def fetcher(obj, index):
        if index >= len(obj):
            raise IndexError
        return obj[index]
    

    这和直接索引越界是以一样的。上面raise抛出的异常IndexError是一个内置异常,可以直接引用这些内置异常。稍后会演示如何自定义自己的异常。

    抛出异常后,就可以按照前面介绍的try来处理异常。

    assert是一种断言,在计算机语言中表示:如果断言条件为真就跳过,如果为假就抛出异常信息。它可以自定义异常信息。

    例如:

    def fetcher(obj, index):
        assert index < len(obj),  "one exception"
        return obj[index]
    

    很多时候会直接在assert中使用False、True的布尔值进行程序的调试。

    assert True, "assert not hit"
    assert False, "assert hit"
    

    自定义异常

    python中的异常是通过类来定义的,而且所有的异常类都继承自Exception类,而Exception又继承自BaseException(这个类不能直接作为其它异常类的父类)。所以自定义异常的时候,也要继承Exception,当然,继承某个中间异常类也可以。

    例如,定义索引越界的异常类,注意这个类中直接pass,但因为继承了Exception,它仍然会有异常信息。

    class MyIndexError(Exception):
        pass
    

    例如,判断字母是否是大写,如果是,就抛异常:

    def fetcher(obj,index):
        if index >= len(obj):
            raise MyIndexError
        return obj[index]
    

    测试一下:

    s = "long"
    
    print(fetcher(s, 3) * 4)
    print(fetcher(s, 4) * 4)
    

    结果:

    gggg
    Traceback (most recent call last):
      File "g:/pycode/list.py", line 12, in <module>
        print(fetcher(s, 4) * 4)
      File "g:/pycode/list.py", line 6, in fetcher
        raise MyIndexError
    __main__.MyIndexError
    

    需要注意,因为异常类都继承字Exception,except监视Exception异常的时候,也会匹配其它的异常。更标准地说,监视异常父类,也会捕获到这个类的子类异常

    如何看抛出的异常

    看异常信息是最基本的能力。例如,下面的这段代码会报除0错误:

    def a(x, y):
        return x/y
    
    def b(x):
        print(a(x, 0))
    
    b(1)
    

    执行时,报错信息如下:

    Traceback (most recent call last):
      File "g:/pycode/list.py", line 7, in <module>
        b(1)
      File "g:/pycode/list.py", line 5, in b
        print(a(x, 0))
      File "g:/pycode/list.py", line 2, in a
        return x/y
    ZeroDivisionError: division by zero
    

    这个堆栈跟踪信息中已经明确说明了(most recent call last),说明最近产生异常的调用在最上面,也就是第7行。上面的整个过程是这样的:第7行出错,它是因为第5行的代码引起的,而第5行之所以错是第2行的源代码引起的。

    所以,从最底部可以看到最终是因为什么而抛出异常,从最顶部可以看到是执行到哪一句出错。

    深入异常处理

    try/except/else/finally

    try:
        <statements>
    except <name1>:           # 捕获到名为name1的异常
        <statements>
    except (name2, name3):    # 捕获到name2或name3任一异常
        <statements>
    except <name4> as <data>: # 捕获name4异常,并获取异常的示例
        <statements>
    except:                   # 以上异常都不匹配时
        <statements>
    else:                     # 没有产生异常时
        <statements>
    finally:                  # 一定会执行的
        <statements>
    

    注意,当抛出的异常无法被匹配时,将归类于空的except:,但这是很危险的行为,因为很多时候的异常是必然的,比如某些退出操作、内存不足、Ctrl+C等等,而这些都会被捕获。与之大致等价的是捕获异常类的"伪"祖先类Exception,即except Exception:,它和空异常匹配类似,但能解决不少不应该匹配的异常。但使用Exception依然是危险的,能不用尽量不用。

    如果一个异常既能被name1匹配,又能被name2匹配,则先匹配到的处理这个异常。

    通过as关键字可以将except捕获到的异常对象赋值给data变量。用法稍后会解释,现在需要知道的是,在python 3.x中,变量data只在当前的except块范围内有效,出了范围就会被回收。如果想要保留异常对象,可以将data赋值给一个变量。例如下面的b在出了try范围都有效,但是a在这个except之后就无效了。

    except Exception as a:
        print(a)
        b=a
    

    通过else分句可以知道,这段try代码中没有出现任何异常。否则就不会执行到else分句。

    raise

    raise用于手动触发一个异常。而每一种异常都是一个异常类,所以触发实际上是触发一个异常类的实例对象。

    raise <instance>  # 直接触发一个异常类的对象
    raise <class>     # 构建此处所给类的一个异常对象并触发
    raise             # 触发最近触发的异常
    raise <2> from <1>  # 将<1>的异常附加在<2>上
    

    其中第二种形式,raise会根据给定类不传递任何参数地自动构建一个异常对象,并触发这个异常对象。第三种直接触发最近触发的异常对象,这在传播异常的时候很有用。

    例如,下面两种方式实际上是等价的,只不过第一种方式传递的是类,raise会隐式地自动创建这个异常类的实例对象。

    raise IndexError
    raise IndexError()
    

    可以为异常类构建实例时指定点参数信息,这些参数会保存到名为args的元组。例如:

    try:
        raise IndexError("something wrong")
    except Exception as E:
        print(E.args)
    

    输出:

    ('something wrong',)
    

    不仅如此,只要是异常类或异常对象,不管它们的存在形式如何,都可以放在raise中。例如:

    err = IndexErro()
    raise err
    
    errs = [IndexError, TypeError]
    raise errs[0]
    

    对于第三种raise形式,它主要用来传播异常,一般用在except代码段中。例如:

    try:
        raise IndexError("aaaaa")
    except IndexError:
        print("something wrong")
        raise
    

    因为异常被except捕获后,就表示这个异常已经处理过了,程序会跳转到finally或整个try块的尾部继续执行下去。但是如果不想让程序继续执行,而是仅仅只是想知道发生了这个异常,并做一番处理,然后继续向上触发异常。这就是异常传播。

    因为实际触发的异常都是类的实例对象,所以它有属性。而且,可以通过在except中使用as来将对象赋值给变量:

    try:
        1/0
    except Exception as a:
        print(a)
    

    变量a在出了except的范围就失效,所以可以将它保留给一个不会失效的变量:

    try:
        1/0
    except Exception as a:
        print(a)
        b=a
    
    print(b)
    

    如果在一个except中触发了另一个异常,会造成异常链

    try:
        1/0
    except Exception as E:
        raise TypeError('Bad')
    

    将会报告两个异常,并提示处理异常E的时候,触发了另一个异常TypeError。

    Traceback (most recent call last):
      File "g:/pycode/list.py", line 2, in <module>
        1/0
    ZeroDivisionError: division by zero
    
    During handling of the above exception, another exception occurred:
    
    Traceback (most recent call last):
      File "g:/pycode/list.py", line 4, in <module>
        raise TypeError('Bad')
    TypeError: Bad
    

    使用from关键字,可以让关系更加明确。

    try:
        1/0
    except Exception as E:
        raise TypeError('Bad') from E
    

    下面是错误报告:

    Traceback (most recent call last):
      File "g:/pycode/list.py", line 2, in <module>
        1/0
    ZeroDivisionError: division by zero
    
    The above exception was the direct cause of the following exception:
    
    Traceback (most recent call last):
      File "g:/pycode/list.py", line 4, in <module>
        raise TypeError('Bad') from E
    TypeError: Bad
    

    实际上,使用from关键字的时候,会将E的异常对象附加到TypeError的__cause__属性上。

    但无论如何,这里都触发了多个异常。在python 3.3版本,可以使用from None的方式来掩盖异常的来源,也就是禁止输出异常E,停止异常链:

    try:
        1/0
    except Exception as E:
        raise TypeError('Bad') from None
    

    错误报告如下:

    Traceback (most recent call last):
      File "g:/pycode/list.py", line 4, in <module>
        raise TypeError('Bad') from None
    TypeError: Bad
    

    可见,异常信息中少了很多内容。

    assert

    assert断言常用于调试。用法如下:

    assert test, data
    

    它实际上等价于是条件判断的raise。它等价于下面的方式:

    if __debug__:
        if not test:
            raise AssertionError(data)
    

    如果条件test的测试为真,就跳过,否则就抛出异常。这个异常是通过AssertionError类构造的,构造异常对象的参数是data。data会放进名为args的元组属性中。

    try:
        assert False,"something wrong"
    except Exception as E:
        print(E.args)
    

    同样,assert产生的是名为AssertionError的异常,如果不捕获这个AssertionError异常,程序将会终止。

    除了调试,assert还偶尔用来判断必要的条件,不满足条件就异常,以便让程序更加健壮。例如:

    def f(x):
        assert x >= 0, "x must great or equal than 0"
        return x ** 2
    
    print(f(2))
    print(f(0))
    print(f(-2))   # 触发AssertionError异常
    

    需要注意的是,写assert的测试条件时,测试结果为假才触发异常。所以,应该以if not true的角度去考虑条件,或者以unless的角度考虑。或者说,后面触发的异常信息,和测试条件应该是正相关的,例如示例中异常信息的说法是x必须大于等于0,和测试条件x >= 0是正相关的。

    assert还常用于父类方法的某些方法中,这些方法要求子类必须重写父类的方法。于是:

    class cls:
        ...
        def f(self):
            assert False, "you must override method: f"
    

    此外,assert不应该用来触发那些python早已经定义好的异常。例如索引越界、类型错误等等。这些python已经定义好的异常,我们再去用AssertionError触发,这是完全多余的。例如:

    def f(obj,index):
        assert index > len(obj), "IndexError"
        return obj[index]
    

    sys.exc_info()

    该函数用来收集正在处理的异常的信息。

    它返回一个包含3个值的元组(type, value, traceback),它们是当前正在处理的异常的信息。如果没有正在处理的异常,则返回3个None组成的元组。

    其中:

    • type表示正在处理的异常类
    • value表示正在处理的异常实例
    • traceback表示一个栈空间的回调对象(参考官方手册traceback object)

    看一个示例即可知道。

    class General(Exception):pass
    
    def raise0():
        x = General()
        raise x
    
    try:
        raise0()
    except Exception:
        import sys
        print(sys.exc_info())
    

    执行结果:

    (<class '__main__.General'>, General(), <traceback object at 0x0388F2B0>)
    

    结果很明显,第一个返回值是异常类General,第二个返回值是抛出的异常类的实例对象,第三个返回值是traceback对象。

    实际上,当需要获取当前处理的异常类时,还可以通过异常对象的__class__来获取,因为异常对象可以在except/as中赋值给变量:

    class General(Exception):pass
    
    def raise0():
        x = General()
        raise x
    
    try:
        raise0()
    except Exception as E:
        import sys
        print(sys.exc_info()[0])
        print(E.__class__)
    

    它们的的结果是完全一样的:

    <class '__main__.General'>
    <class '__main__.General'>
    

    什么时候要获取异常类的信息?当except所监视的异常类比较大范围,同时又想知道具体的异常类。比如,except:except Exception:这两种监视的异常范围都非常大,前者会监视BaseException,也就是python的所有异常,后者监视的是Exception,也就是python的所有普通的异常。正因为监视范围太大,导致不知道具体是抛出的是哪个异常。

    区分异常和错误

    错误都是异常,但异常并不一定都是错误

    很常见的,文件结尾的EOF在各种语言中它都定义为异常,是异常就能被触发捕获,但在逻辑上却不认为它是错误。

    除此之外,还有操作系统的异常,比如sys.exit()引发的SystemeExit异常,ctrl+c引发的的中断异常KeyboardInterrupt都属于异常,但它们和普通的异常不一样。而且python中的普通异常都继承字Exception类,但SystemExit却并非它的子类,而是BaseException的子类。所以能通过空的except:捕获到它,却不能通过except Exception:来捕获。

    异常类的继承

    所有异常类都继承自Exception,要编写自定义的异常时,要么直接继承该类,要么继承该类的某个子类。

    例如,下面定义三个异常类,General类继承Exception,另外两个继承General类,表示这两个是特定的、更具体的异常类。

    class General(Exception):pass
    class Specific1(General): pass
    class Specific2(General): pass
    
    def raise0():
        x = General()
        raise x
    
    def raise1():
        x = Specific1()
        raise x
    
    def raise2():
        x = Specific2()
        raise x
    

    测试下:

    for func in (raise0, raise1, raise2):
        try:
            func()
        except General as E:
            import sys
            print("caught: ", E.__class__)
    

    执行结果:

    caught:  <class '__main__.General'>
    caught:  <class '__main__.Specific1'>
    caught:  <class '__main__.Specific2'>
    

    前面说过,except监视父类异常的时候,也会捕获该类的子类异常。正如这里监视的是Gereral类,但触发了Specific子类异常也会被捕获。

    异常类的嵌套

    这是非常常见的陷阱。有两种异常嵌套的方式:try的嵌套;代码块的异常嵌套(比如函数嵌套)。无论是哪种嵌套模式,异常都只在最近(或者说是最内层)的代码块中被处理,但是finally块是所有try都会执行的。

    第一种try的嵌套模式:

    try:
        try:
            (1)
        except xxx:
            (2)
        finally:
            (3)
    except yyy:
        ...
    finally:
        (4)
    

    如果在(1)处抛出了异常,无论yyy是否匹配这个异常,只要xxx能匹配这个异常,就会执行(2)。但(3)、(4)这两个finally都会执行。

    第二种代码块嵌套,常见的是函数调用的嵌套,这种情况可能会比较隐式。例如:

    def action2():
        print(1 + [])
    
    def action1():
        try:
            action2()
        except TypeError:
            print('inner try')
    
    try:
        action1()
    except TypeError:
        print('outer try')
    

    执行结果:

    inner try
    

    上面的action2()会抛出一个TypeError的异常。在action1()中用了try包围action2()的调用,于是action2()的异常汇报给action1()层,然后被捕获。

    但是在最外面,使用try包围action1()的调用,看上去异常也会被捕获,但实际上并不会,因为在action2()中就已经通过except处理好了异常,而处理过的异常将不再是异常,不会再触发外层的异常,所以上面不会输出"outer try"。

    except应该捕获哪些异常

    在考虑异常捕获的时候,需要注意几点:

    1. except监视的范围别太大了
    2. except监视的范围别太小了
    3. 有些异常本就该让它中断程序的运行,不要去捕获它

    第三点很容易理解,有些异常会导致程序无法进行后续的运行,改中断还是得中断。

    对于第一点,可能常用的大范围异常监视就是下面两种方式:

    except:
    except Exception:
    

    这两种方式监视的范围都太大了,比如有些不想处理的异常也会被它们监视到。更糟糕的可能是本该汇报给上层的异常,结果却被这种大范围捕获了。例如:

    def func():
        try:
            ...
        except:
            ...
    
    try:
        func()
    except IndexErro:
        ...
    

    本来是想在外层的try中明确捕获func触发的IndexError异常的,但是func()内却使用了空的except:,使得异常直接在这里被处理,外层的try永远也捕获不到任何该函数的异常。

    关于第二点,不应该监视范围太小的异常。范围小,意味着监视的异常太过具体,太过细致,这种监视方式虽然精确,但却不利于维护。例如E1异常类有2个子异常类E2、E3,在代码中监视了E2、E3,但如果未来又添加了一个E1的子异常类E4,那么又得去改代码让它监视E4。如果代码是写给自己用的倒无所谓,但如果像通用模块一样交给别人用的,这意味着让别的模块使用者也去改代码。

    自定义异常类

    在前面设计异常类的时候,总是使用pass跳过类代码体。但却仍然能使用这个类作为异常类,因为它继承了Exception,在Exception中有相关代码可以输出异常信息。

    前面说过,在构造异常类的时候可以传递参数,它们会放进异常实例对象的args属性中:

    try:
        raise IndexError("something wrong")
    except Exception as E:
        print(E.args)
    
    try:
        assert False,"something wrong too"
    except Exception as E:
        print(E.args)
    
    I = IndexError('text')
    print(I.args)
    

    对于用户自定义的类,也一样如此:

    class MyError(Exception):pass
    try:
        raise MyError('something wrong')
    except MyError as E:
        print(E.args)
    

    不仅如此,虽然异常实例对象是一个对象,但如果直接输出实例对象,那么得到的结果将是给定的异常信息,只不过它不在元组中。

    I = IndexError("index wrong")
    print(I)      # 输出"index wrong"
    

    很容易想到,这是因为Exception类中重写了__str__或者__repr__中的某一个或两个都重写了。

    自定义异常输出

    于是,自定义异常类的时候,也可以重写这两个中的一个,从而可以定制属于自己的异常类的输出信息。一般来说只重写__str__,因为Exception中也是重写该类,且它的优先级高于__repr__

    例如下面自定义的异常类。当然,这个示例的效果非常简陋,但已足够说明问题。

    class MyError(Exception):
        def __str__(self):
            return 'output this message for something wrong'
    
    try:
        raise MyError("hahhaha")
    except MyError as E:
        print(E)
    

    输出结果:

    output this message for something wrong
    

    提供构造方法

    自定义异常类的时候,可以重写构造方法__init__(),这样raise异常的时候,可以指定构造的数据。而且更进一步的,还可以重写__str__来自定义异常输出。

    例如,格式化文件的程序中定义一个异常类,用来提示解析到哪个文件的哪一行出错。

    class MyError(Exception):
        def __init__(self,line,file):
            self.line = line
            self.file = file
        def __str__(self):
            return "format failed: %s at %s" % (self.file, self.line)
    
    def format():
        ...
        raise MyError(42, "a.json")
        ...
    
    try:
        format()
    except MyError as E:
        print(E)
    

    提供异常类的其它方法

    异常类既然是类,说明它可以像普通类一样拿来应用。比如添加其它类方法。

    例如,可以将异常信息写入到文件中。只需提供一个向文件写入的方法,并在except的语句块中调用这个方法即可。

    class MyError(Exception):
        def __init__(self, line, file):
            self.line = line
            self.file = file
    
        def logerr(self):
            with open('Error.log', 'a') as logfile:
                print(self, file=logfile)
    
        def __str__(self):
            return "format failed: %s at %s" % (self.file, self.line)
    
    def format():
        raise MyError(42, "a.json")
    
    try:
        format()
    except MyError as E:
        E.logerr()
    
    哎...今天够累的,签到来了1...
    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    QQ|手机版|小黑屋|Java自学者论坛 ( 声明:本站文章及资料整理自互联网,用于Java自学者交流学习使用,对资料版权不负任何法律责任,若有侵权请及时联系客服屏蔽删除 )

    GMT+8, 2021-8-3 09:48 , Processed in 0.059992 second(s), 29 queries .

    Powered by Discuz! X3.4

    Copyright © 2001-2020, Tencent Cloud.

    快速回复 返回顶部 返回列表