Python中异常处理

Posted Python爱好者666

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python中异常处理相关的知识,希望对你有一定的参考价值。

1、异常 Exception

错误Error

逻辑错误:算法写错了,加法写成了减法。

笔误:变量名写错了,语法错误。

错误可以避免的

 

异常Exception

本身就是意外情况。一些意外,导致程序无法正常的执行下去。

是不可避免的。

 

错误和异常

在高级编程语言中,一般都有错误和异常的概念,异常是可以捕获的并被处理的,但是错误是不能捕获的。

with open(‘test‘) as f:
    pass

 

错误信息:

Traceback (most recent call last):

  File "C:/Users/WCL/PycharmProjects/untitled1/package/test1/异常处理.py", line 1, in <module>

    with open(‘test‘) as f:

FileNotFoundError: [Errno 2] No such file or directory: ‘test‘

 

def 0A():
    pass

 

  File "C:/Users/WCL/PycharmProjects/untitled1/package/test1/参数检查.py", line 142

    class typeassert

                   ^

SyntaxError: invalid syntax

 

一个健壮的程序,尽可能的避免错误。

尽可能的捕获,处理各种异常。

 

2、产生异常

产生:raise语句显示的抛出异常。

Python解释器自己检测到异常并引发他。

def foo():
    print(‘-----‘)
    def bar():
        print(1/0)
    bar()
    print(‘after‘)
foo()

def bar():
    print(‘+++++++++++++‘)
    raise Exception(‘Exc‘)
    print(‘+-+-+-+-+-+‘)
bar()

 

程序会在异常抛出的地方中断执行,如果不进行捕获,就会提前结束程序。

 

raise语句

raise后什么都没有,表示抛出最近一个被激活的异常,如果没有被激活的异常,则抛出类型异常。很少利用的方式。

raise

后要求应该是BaseException类的子类或实例,如果是类,将被无参实例化。

异常必须出自BaseException

sys.exc_info()查看异常所在的元素。

sys.exc_info() ,后面是个元组。(异常类、异常对象,trackback)

 

 

3、异常捕获

try:

  待捕获异常的代码块  

except[异常类型]:

异常的处理代码块

 

try:
    print(‘++++++++++++++++‘)
    c = 1/0
    print(‘----------------‘)
except:
    print(‘catch the exception‘)
print(‘outer‘)

 

++++++++++++++++

catch the exception

Outer

执行到c = 1/0时候产生异常并抛出,由于使用了语句捕捉这个异常,所以产生异常位置后面的语句将不再执行了,转而执行对象except以外的语句。

2)捕获指定类型的异常。

try:
    print(‘++++++++++++++++‘)
    c = 1/0
    print(‘----------------‘)
except ArithmeticError:
    print(‘catch the ArithmeticError:‘)
print(‘outer‘)

 

 

++++++++++++++++

catch the ArithmeticError:

Outer

 

 

 

 

 

特别关心的异常放在最上面。

自己定义的异常。

Exception 非退出性异常。

捕获原则:

4、异常类即继承层次

def exc_hierarchy(exc=BaseException, level=-1):
    name = exc.__name__
    if level == -1:
        print(name)
    else:
        print("{} +-- {}".format(‘    ‘ * level, name))
    for sub in exc.__subclasses__():
        exc_hierarchy(sub, level+1)

 

BaseException

 +-- Exception

     +-- StopAsyncIteration

     +-- OSError

         +-- BlockingIOError

         +-- FileNotFoundError

         +-- IsADirectoryError

         +-- TimeoutError

         +-- InterruptedError

         +-- ProcessLookupError

         +-- NotADirectoryError

         +-- ConnectionError

             +-- BrokenPipeError

             +-- ConnectionAbortedError

             +-- ConnectionRefusedError

             +-- ConnectionResetError

         +-- UnsupportedOperation

         +-- FileExistsError

         +-- ChildProcessError

         +-- PermissionError

     +-- ArithmeticError

         +-- FloatingPointError

         +-- OverflowError

         +-- ZeroDivisionError

     +-- AttributeError

     +-- SyntaxError

         +-- IndentationError

             +-- TabError

     +-- SystemError

         +-- CodecRegistryError

     +-- ImportError

         +-- ZipImportError

     +-- BufferError

     +-- LookupError

         +-- IndexError

         +-- KeyError

         +-- CodecRegistryError

     +-- NameError

         +-- UnboundLocalError

     +-- TypeError

     +-- error

     +-- StopIteration

     +-- AssertionError

     +-- Warning

         +-- UserWarning

         +-- DeprecationWarning

         +-- UnicodeWarning

         +-- PendingDeprecationWarning

         +-- ImportWarning

         +-- RuntimeWarning

         +-- ResourceWarning

         +-- SyntaxWarning

         +-- BytesWarning

         +-- FutureWarning

     +-- Error

     +-- ValueError

         +-- UnicodeError

             +-- UnicodeEncodeError

             +-- UnicodeDecodeError

             +-- UnicodeTranslateError

         +-- UnsupportedOperation

     +-- ReferenceError

     +-- RuntimeError

         +-- RecursionError

         +-- NotImplementedError

         +-- _DeadlockError

     +-- MemoryError

     +-- EOFError

 +-- GeneratorExit

 +-- KeyboardInterrupt

 +-- SystemExit

 

 

 

 

5、BaseException及子类

1)BaseException所有内建异常类的基类是BaseException。

 

2)SystemExit

sys.exit()函数引发的异常,异常不捕获处理,就直接交给Python解释器,解释器退出。

 

import sys
print(‘++++‘)
sys.exit(1)
print(‘sysexit‘)
print(‘-----‘)

 

++++

 

Process finished with exit code 1

未进行捕获的情况下,

解释器直接退出了。

 

 

import sys
try:
    print(‘++++‘)
    sys.exit(1)
except SystemExit:
    print(‘sysexit‘)
print(‘-----‘)

 

++++

sysexit

-----

捕获的情况下正常执行,且被捕获。

 

3)Keyboardinterrupt

对应捕获用户中断的行为 Ctrl + c

 

6、Exception及子类

Exception是所有内建的,非系统退出的异常的基类,自定义异常应该定义继承自它。

 

1)SyntaxError语法错误,Python中也归到Exception类中,但是语法错误是不可被捕获的。

2)ArithmeticError所有算数计算引发的异常,其子类有除零异常等。

3)LookupError 使用映射的键或者序列的索引无效是引发的异常的基类:indexerror keyerror

4)自定义的异常:从Exception继承的类。

 

7、异常的捕获

Except可以捕获多个异常。

捕获的原则:捕获是从上到下依次比较,如果匹配,则执行匹配的except语句块。

如果被一个except语句块捕获,其他的except就不会再次捕获了。

如果没有任何一个except语句捕获到这个异常,则该异常向外抛出。

捕获的原则,从小到大,从具体到广泛。

8、as子句

被抛出的异常,应该是异常的实例,获得这个对象的话,使用as子句。

class MyException(Exception):
    def __init__(self,code,message):
        self.code = code
        self.message = message
try:
    raise MyException
except MyException as e:
    print(11111111)
    print(‘{}{}‘.format(e.code,e.message))
except Exception as e:
    print(‘{}‘.format(e))

 

__init__() missing 2 required positional arguments: ‘code‘ and ‘message‘

raise后面有特定的参数,如果没有的话就是无参形式。

 

9、finally 子句

Finally 最终,即最后都会是要一定执行的。try.....finally不管有没有异常都会执行。

Finally中一般都是放置资源的清理,释放工作的语句。

也可以在finally中再次捕获异常。

10、finally执行时机

def foo():
    try:
        return 3
    finally:
        print(‘finally‘)
    print(‘---‘)
print(foo())

 

尽管函数有return返回语句,但是finally语句还是要执行的,最后才返回return语句。

拿的值是最后一个return。

11、异常传递

def foo1():
    return 1/0

def foo2():
    print(‘foo2 ----‘)
    foo1()
    print(‘foo2++++‘)
foo2()

foo2调用了foo1,foo1产生的异常传递到了foo2中

异常总是向外层抛出,如果外层没有处理这个异常,就会继续向外抛出,如果内层捕获并处理了异常,外部就不能捕获的到了。

如果到了最外层还是没有被处理,就会中断异常所在的线程的执行。

import threading
import time

def foo1():
    return 1/0

def foo2():
    time.sleep(3)
    print(‘foo2----‘)
    foo1()
    print(‘foo2++++‘)
t = threading.Thread(target=foo2)
t.start()

while True:
    time.sleep(1)
    print(‘Everything OK‘)
    if t.is_alive():
        print(‘live‘)
    else:
        print(‘dead‘)

 

未进行捕获异常,异常抛出直接中断了线程。

sys.exc_info() ,后面是个元组。(异常类、异常对象,trackback)

 

 

 

 

12、try 的嵌套

try:
    try:
        ret = 1/0
    except KeyError as k:
        print(k)
    else:
        print(‘ok‘)
    finally:
        print(‘finally‘)
except:
    print(‘c ok‘)
finally:
    print(‘fin‘)

 

内部捕获不到异常,会向外层传递异常。

但是如果内层有且有finally而且其中有return、break语句,否则就不会继续往外抛出异常。

 

def foo():
    try:
        ret = 1/0
    except KeyError as F:
        print(k)
    finally:
        print(‘finally a ‘)
        return   #异常直接被丢弃
try:
    foo()
except:
    print(‘+++++‘)
finally:
    print(‘-------‘)

 

有return语句,异常直接被丢弃。

 

13、异常的捕获时机

1)立即捕获

需要立即返回一个明确的结果


def parse_int(s):
    try:
        return int(s)
    except:
        return 0
print(parse_int(‘s‘))

 

被return直接返回0

2)边界捕获

封装产生了边界。

(1)一个模块,用户调用了这个模块的时候捕获异常,异常内部不需要捕获,处理异常,一旦内部处理了,外部调用者无法感知异常了

(2)Open函数,出现的异常交给调用者处理,文件存在,就不用创建了,看是否修改修改还是删除。

(3)自己写了一个类,使用open函数,但是文件出现异常不知道如何处理,就继续向外层抛出,一般来说最外层也是边界,必须处理异常,如果不处理的话,线程就会推出。

14、else子句

 else子句,没有异常发生,则执行。

try:
    ret = 1/0
except ArithmeticError as e:
    print(e)
else:
    print(‘ok‘)
finally:
    print(‘fin‘)
####division by zero
###fin

 

15、总结

 try:

<语句> #运行别的代码

except<异常类>:

<语句>  #捕获某种类型的异常

except<异常类> as <变量名>:

<语句>   #捕获某种类型的异常并获得对象

else:

<语句> #如果没有异常发生

finally:

<语句>  #推出try的时候总会执行

try的工作原理

(1)如果try中语句执行时候会发生异常,搜索except子句,并执行第一个匹配该异常的except子句。

(2)如果try中语句执行时发生异常,却没有匹配except子句,异常将被递交到外层的try,如果外层不处理这个异常,异常将继续向外层传递,如果都不处理该异常,则会传递到最外层,如果还没有处理,就会终止异常所在的线程。

(3)如果try执行时候没有异常,将执行else子句中的语句。

(4)无论try中是否发生异常,finally子句最终都会执行。































































































































以上是关于Python中异常处理的主要内容,如果未能解决你的问题,请参考以下文章

使用片段中的处理程序时出现非法状态异常

你如何在 python 中处理 graphql 查询和片段?

Java异常处理机制

PCL异常处理:pcl 1.8.13rdpartyoostincludeoost-1_64oost ypeofmsvc ypeof_impl.hpp(125): error(代码片段

python常用代码片段总结

常用python日期日志获取内容循环的代码片段