Python--异常处理

于 2019-05-23 11:34:19 发布
阅读量961 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/python_lqx/article/details/90404184
版权

异常处理

异常 Exception

错误 Error

  • 逻辑错误：算法写错了，例如加法写成了减法
  • 笔误：例如变量名写错了，语法错误
  • 函数或类使用错误，其实这也属于逻辑错误
  • 总之，错误是可以避免的

异常 Exception

  • 本意就是意外情况
  • 这有个前提，没有出现上面说的错误，也就是说程序写的没有问题，但是在某些情况下，会出现一些意外，导致程序无法正常的执行下去
  • 例如open函数操作一个文件，文件不存在，或者创建一个文件时已经存在了，或者访问一个网络文件，突然断网了，这就是异常，是个意外的情况
  • 异常不可能避免

错误和异常

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

对比异常和错误

print( 1/ 0) # 除0异常

def 1a(): pass # 语法错误

一个健壮的程序，应尽可能避免错误，尽可能捕获、处理各种异常

产生异常

  • 产生：
    raise 语句显式的抛出异常
    Python解释器自己检测到异常并引发它
def foo():
    print('before')
    print(1/0) # 除零异常
    print('after')

foo()
# 打印结果
before
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/test/Task/Temporary.py", line 6, in <module>
    foo()
  File "C:/Users/Administrator/PycharmProjects/test/Task/Temporary.py", line 3, in foo
    print(1/0) # 除零异常
ZeroDivisionError: division by zero

def bar():
    print('before')
    raise Exception('my exception') # raise 主动抛出异常
    print('after')
    
bar()
# 打印结果
before
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/test/Task/Temporary.py", line 6, in <module>
    bar()
  File "C:/Users/Administrator/PycharmProjects/test/Task/Temporary.py", line 4, in bar
    raise Exception('my exception') # raise 主动抛出异常
Exception: my exception

Process finished with exit code 1

程序会在异常抛出的地方中断执行，如果不捕获，就会提前结束程序（其实是终止当前线程的执行）

异常的捕获

try:
	待捕获异常的代码块
except [异常类型]:
	异常的处理代码块

def foo():
    try:
        print('before')
        c = 1/0
        print('after')
    except:
        print('error')

    print('catch the exception')

foo()
print("=====end=====")

# 打印结果
before
error
catch the exception
=====end=====

上例执行到c = 1/0 时产生异常并抛出，由于使用了try…except语句块则捕捉到了这个异常，异常生成位置之后语句将不再执行，转而执行对应的except部分的语句，最后执行try...except语句块之外的语句

捕获指定类型的异常

def foo():
	try:
		print('before')
		print(1/0)
		print('after')
	except ArithmeticError: # 指定捕获的类型
		print('error')
	print('catch the exception')
	
foo()
print('======= end =========')

异常类及集成层次

# Python异常的继承

BaseException
	+-- SystemExit # 系统推出
	+-- KeyboardInterrupt # 键盘打断
	+-- GeneratorExit
	+-- Exception # 自己写的所有异常类，从这里开始继承
		+-- RuntimeError # 运行时异常
		|	 +-- RecursionError # 递归异常
		+-- MemoryError # 内存异常
		+-- NameError # 名称不存在
		+-- StopIteration # 迭代次数超出
		+-- StopAsyncIteration
		+-- ArithmeticError # 算数异常
		|	 +-- FloatingPointError # 浮点数异常
		| 	+-- OverflowError
		|	 +-- ZeroDivisionError # 除0异常
		+-- LookupError # 找位置找不着
		|	 +-- IndexError # 超界
		|	 +-- KeyError
		+-- SyntaxError # 语法错误
		+-- OSError # 操作系统里的错误
		|	 +-- BlockingIOError
		|	 +-- ChildProcessError # 子进程错误
		|	 +-- ConnectionError
		|	 |	 +-- BrokenPipeError
		|	 |	 +-- ConnectionAbortedError
		|	 |	 +-- ConnectionRefusedError
		|	 |	 +-- ConnectionResetError
		|	 +-- FileExistsError # 文件已存在
		|	 +-- FileNotFoundError # 文件不存在
		|	 +-- InterruptedError
		|	 +-- IsADirectoryError
		|	 +-- NotADirectoryError
		|	 +-- PermissionError
		|	 +-- ProcessLookupError
		|	 +-- TimeoutError

BasaException及子类

BasaException

所有内建异常类的基类是BasaException

SystemExit

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

import sys

print('before')
sys.exit(1)
print('SysExit')
print('outer') # 不会执行
  • 捕获异常
# 捕获异常
import sys

try:
    sys.exit(1)
except SystemExit: # 换成Exception无法捕获
    print('SysExit')
print('outer')

# 打印结果
SysExit
outer

如果except语句捕获了异常，则继续向后面执行，如果没有捕获住该异常SystemExit，解释器直接退出程序

KeyboardInterrupt

对应的捕获用户终端行为Ctrl + C

try:
	import time
	while True:
		time.sleep(1)
		print('~~~')
except KeyboardInterrupt:
	print('ctrl + c')
print('=== end ===')

Exception及子类

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

SyntaxError 语法错误

Python将这种错误也归到异常类下面的Exception下的子类，但是这种错误是不可捕获的

def a():
		try:
			0a = 5
		except:
			pass

# 错误
File "test2.py", line 3
	0a = 5
	 ^
SyntaxError：invalid syntax
ArithmeticError

所有算术计算引发的异常，其子类有除零异常等

LookupError

使用映射的键或序列的索引无效时引发的异常的基类：IndexError，KeyError

自定义异常类

从Exception继承的类

class MyException(Exception):
    pass

try:
    raise MyException()
except MyException: # 捕获自定义异常
    print('catch the exception')

多种捕获

except可以指定捕获的类型，捕获多种异常

import sys

class MyException(Exception):
    pass

try:
    a = 1/0
    raise MyException
    open('t1')
    sys.exit(1)
except ZeroDivisionError:
    print('zero')
except ArithmeticError:
    print('ari')
except MyException:
    print('catch my exception')
except Exception:
    print('excption')
except:
    print('sysexit')
  • 捕获规则
    捕获是从上到下依次比较，如果匹配，则执行匹配的except语句块
    如果被一个except语句捕获，其他except语句就不会再次捕获了
    如果没有任何一个except语句捕获到这个异常，则该异常向外抛出
  • 捕获的原则
    从小到大，从具体到宽泛

as字句

class A:pass

try:
    # 1/0
    raise 1
    # raise 'abc'
    # raise {}
    # raise A
    # raise A()
except:
    print('catch the exception')

被抛出的异常，应该是异常类的实例，可以使用as子句获得这个对象

class MyException(Exception):
    def __init__(self, code, message):
        self.code = code
        self.message = message

try:
    raise MyException
except MyException as e:
    print('catch my exception: {} {}')

except Exception as e:
    print('catch')

# 运行结果
catch

修改代码如下

class MyException(Exception):
    def __init__(self, code, message):
        self.code = code
        self.message = message

try:
    raise MyException
except MyException as e:
    print('catch my exception: {} {}')

except Exception as e:
    print('{}'.format(e))
 
# 运行结果
__init__() missing 2 required positional arguments: 'code' and 'message'

raise后跟类名是无参构造实例，因此需要2个参数

class MyException(Exception):
    def __init__(self, code, message):
        self.code = code
        self.message = message

try:
    raise MyException(200, 'OK')
except MyException as e:
    print('catch my exception: {} {}'.format(e.code, e.message))

except Exception as e:
    print('{}'.format(e))

# 执行结果
catch my exception: 200 OK

raise子句

  • raise后要求应该是BaseException类的子类或实例，如果是类，将被无参实例化
  • raise后什么都没有，表示抛出最近一个被激活的异常，如果没有被激活的异常，则抛类型异常。这种方式很少用

finally子句

  • finally
    最终，即最后一定要执行的，try...finally语句块中，不管是否发生了异常，都要执行finally的部分
try:
    f = open('test.txt')
except FileNotFoundError as e:
    print('{} {} {}'.format(e.__class__, e.errno, e.strerror))
finally:
    print('清理工作')
    # f.close()

# 执行结果
<class 'FileNotFoundError'> 2 No such file or directory
清理工作

注意上例中的f的作用域，解决的办法是在外部定义f
finally中一般放置资源的清理、释放工作的语句

f = None
try:
    f = open('test.txt')
except FileNotFoundError as e:
    print('{} {} {}'.format(e.__class__, e.errno, e.strerror))
finally:
    print('清理工作')
    if f:
        f.close()

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

try:
    f = open('test.txt')
except FileNotFoundError as e:
    print('{}'.format(e))
finally:
    print('清理工作')
    try:
        f.close()
    except Exception as e:
        print(e)

# 执行结果
[Errno 2] No such file or directory: 'test.txt'
清理工作
name 'f' is not defined

finally 执行时机

try后如果有finally，保证finally一定可以执行

# 测试
def foo():
    return 1
    try:
        return 3
    finally:
        return 5
        print('finally')
    print('==')
print(foo())

# 执行结果
# 1

# 关闭return 1 return 5
# 执行结果
# finally
# 3

# 关闭return 1 打开return 5
# 执行结果
# 5 # 说明return 3 返回值被覆盖
  • 当打开return 1 时，后面语句将不再执行
  • 当关闭return 1 ，进入try，执行return 3 ，虽然函数要返回，但是finally一定还要执行，所有执行return 5，函数返回。5被压在栈顶，所以返回5。简单说，函数的返回值取决于最后一个执行的return语句，而finally则是try...finally中最后执行的语句块

异常的传递

def foo1():
    return 1/0

def foo2():
    print('foo2 start')
    foo1()
    print('foo2 stop')

foo2()

foo2调用了foo1，foo1产生的异常，传递到了foo2中
异常总是向外层抛出，如过外层没有处理这个异常，就会继续向外抛出
如果内层捕获并处理了异常，外部就不能捕获到了
如果到了最外层还是没有被处理，就会中断异常所在的线程的执行。注意整个程序结束的状态返回值

import threading
import time

def foo1():
    return 1/0

def foo2():
    time.sleep(3) # 3秒后抛出异常
    # print('foo2 start')
    foo1()
    # print('foo2 stop')

t = threading.Thread(target=foo2)
t.start()
while True:
    time.sleep(1)
    # print('Everything OK')
    print(threading.enumerate()) # 打印当前所有线程

执行结果
在这里插入图片描述
虽然线程报错了，但是主线程还在执行
异常会向外抛出，到线程以及，如果线程以及没人管，则会结束此线程

try嵌套

try:
    try:
        ret = 1 / 0
    except KeyError as e:
        print(e)
    finally:
        print('inner fin')
except:
    print('outer catch')
finally:
    print('outer fin')

# 执行结果
inner fin
outer catch
outer fin

内层捕获不到异常，会向外层传递异常
但是如果内层有finally且其中有return、break语句，则异常就不会继续向外抛出

def foo():
    try:
        ret = 1 / 0
    except KeyError as e:
        print(e)
    finally:
        print('inner fin')
        return # 异常被丢弃
try:
    foo()
except:
    print('outer catch')
finally:
    print('outer fin')

# 执行结果
inner fin
outer fin

异常的捕获时机

立即捕获

  • 需要立即返回一个明确的结果
def parse_int(s):
    try:
        return int(s)
    except:
        return 0

print(parse_int('s'))

# 执行结果
0

边界捕获

  • 封装产生了边界
    例如，写了一个模块，用户调用这个模块的时候捕获异常，模块内部不需要捕获、处理异常，一旦内部处理了，外部调用者就无法感知
    例如，open函数，出现的异常交给调用者处理，文件存在了，就不用再创建了，看是否修改还是删除
    例如，自己写了一个类，使用了open函数，但是出现了异常不知道如何处理，就继续向外层抛出，一般来说最外层也是边界，必须处理这个异常，否则线程退出

else子句

在except之后，finally之前
没有异常的时候会执行else语句

try:
    ret = 1 * 0
except ArithmeticError as e:
    print(e)
else:
    print('ok')
finally:
    print('fin')

esle子句
没有任何异常发生，则执行

总结

在这里插入图片描述

鹿夏
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值