一篇文章告诉你Python上下文管理器怎么用

通常咱们操做文件的时候，你们都会知道咱们使用with的方式去写，通常以下

with open('xxxx/test.txt') as f: 'xxxxxx'

那么咱们为何要使用这种方式去操做文件呢？由于with这种方式自动帮咱们执行了close关闭文件句柄的操做，免的咱们忘记关闭句柄，浪费资源。

那咱们为何是使用with方式就能够达到这种效果呢？这就是咱们今天说的python的上下文管理器的做用。简单来讲上下文管理器必须在这个对象的类中声明__enter__和__exit__方法

下面咱们看看怎么定义本身的上下文管理器：

class Context: def init(self,name): self.name=name

# 下面使用with语句, 对象的__enter__被触发, 返回值则赋值给as声明的变量，这里就是f
def __enter__(self):
    print('自定义上下文管理器')
    # return self
#with中代码块执行完毕时触发执行，用来释放资源，例如文件句柄，数据库链接等
def __exit__(self, exc_type, exc_val, exc_tb):
    print('程序运行结束，释放资源')
    print(exc_type)
    print(exc_val)
    print(exc_tb)
    # return True
复制代码

with Context('test.txt') as f: print('主逻辑过程')

结果： 自定义上下文管理器 主逻辑过程 程序运行结束，释放资源 None None None

咱们能够看看执行的顺序 with触发__enter__方法 而后执行主逻辑过程 全部程序执行完以后触发__exit__方法，释放资源

这就是为何咱们用with方法操做文件时候不用f.close的缘由，由于在__exit__方法中帮咱们自动释放了文件句柄

exit()中的三个参数分别表明异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都没法执行

下面咱们在类中加入异常代码块，看看什么状况，是否with后的代码都没法执行

class Context: def init(self,name): self.name=name

# 下面使用with语句, 对象的__enter__被触发, 返回值则赋值给as声明的变量，这里就是f
def __enter__(self):
    print('自定义上下文管理器')
    # return self
#with中代码块执行完毕时触发执行，用来释放资源，例如文件句柄，数据库链接等
def __exit__(self, exc_type, exc_val, exc_tb):
    print('程序运行结束，释放资源')
    print(exc_type)
    print(exc_val)
    print(exc_tb)
    # return True
def  get_values(self):
    dic = {'a':1,'b':2}
    print(dic['c']) # 取一个不存在的key
复制代码

p = Context('test.txt') with Context('test.txt') as f: print('主逻辑过程') Context.get_values(p) print('会不会执行咱们') #主逻辑

结果：

自定义上下文管理器 主逻辑过程 Traceback (most recent call last): 程序运行结束，释放资源 File "C:/Users/aryin/Desktop/mysite2/上下文管理器.py", line 24, in <class 'KeyError'> Context.get_values(p) File "C:/Users/aryin/Desktop/mysite2/上下文管理器.py", line 19, in get_values 'c' print(dic['c']) # 取一个不存在的key <traceback object at 0x000001E50A7C04C8> KeyError: 'c'

能够看到报出KeyError，这也是咱们预测到的，主逻辑也确实没有执行（print('会不会执行咱们') 没有执行），那咱们怎么利用__exit__中的三个参数捕获异常而且实现代码继续执行呢？

class Context: def init(self,name): self.name=name

# 下面使用with语句, 对象的__enter__被触发, 返回值则赋值给as声明的变量，这里就是f
def __enter__(self):
    print('自定义上下文管理器')
    # return self
#with中代码块执行完毕时触发执行，用来释放资源，例如文件句柄，数据库链接等
def __exit__(self, exc_type, exc_val, exc_tb):
    print('程序运行结束，释放资源')
    print(exc_type)
    print(exc_val)
    print(exc_tb)
    return True  #新添加这句
def  get_values(self):
    dic = {'a':1,'b':2}
    print(dic['c']) # 取一个不存在的key
复制代码

p = Context('test.txt') with Context('test.txt') as f: print('主逻辑过程') Context.get_values(p) print('会不会执行咱们') #主逻辑

结果： 自定义上下文管理器 主逻辑过程 程序运行结束，释放资源 <class 'KeyError'> 'c' <traceback object at 0x00000187D3EC0488> 会不会执行咱们

咱们能够看到程序没有奔溃，咱们执行在__exit__函数中增长了reture True，实现异常被捕获，而且主逻辑继续执行（print('会不会执行咱们')） ，也就是说若是__exit()返回值为True,那么异常会被清空，就好像啥都没发生同样，with后的语句正常执行。

咱们可使用with的上下文管理器更优雅的处理代码的中的异常捕获，而不用try..execpt..这种方法去捕获，而且能够实现，程序执行完毕以后，咱们想操做的一些资源释放操做，这样增长了代码的简洁程度和可读性。

下面咱们看看一个文件的写入的With案例

class Context: def init(self,filepath,mode='r',encoding='utf-8'): self.filepath=filepath self.mode=mode self.encoding=encoding

def __enter__(self):
    # print('enter')
    self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
    return self.f

def __exit__(self, exc_type, exc_val, exc_tb):
    # print('exit')
    print(exc_type)
    print(exc_val)
    print(exc_tb)
    self.f.close()
    return True
def __getattr__(self, item):
    return getattr(self.f,item)
复制代码

with Context('file_read.txt','w') as f: print(f) f.write('testfile') #正常写入 f.xxxxx #抛出异常，__exit__处理捕获异常，而且释放文件句柄

结果： <_io.TextIOWrapper name='file_read.txt' mode='w' encoding='utf-8'> <class 'AttributeError'> '_io.TextIOWrapper' object has no attribute 'wasdf' <traceback object at 0x0000019C630D0488>

下面介绍另一种实现上下文管理器的方式，上面咱们经过类的方式去实现，下面咱们经过方法加装饰器的方式实现，具体的原理上面说过了，这里就不说了，这种方法也许更加欢迎。

import contextlib

#装饰器 @contextlib.contextmanager def context(filepath,mode='r',encoding='utf-8'):

#这段相关于__enter__方法
print('这是__enter__')
f = open(filepath, mode=mode,encoding=encoding)

try:
    yield f
except Exception as e:  #捕获异常
    print(e)
finally:

    # 这段相关于__exit__方法
    print('这是__exit__')
    f.close()

    return True
复制代码

#下面用法相同 with context('file_read.txt','w') as f: print(f) f.write('testfile') #正常写入 f.xxxxx #抛出异常，__exit__处理捕获异常，而且释放文件句柄

最后咱们说说Python的优势吧

1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工做，无须手动干预 2.在须要管理一些资源好比文件，数据库链接和锁的编程环境中，能够在__exit__中定制自动释放资源的机制 3.提升代码的可读性，简洁性等等