一般我们操作文件的时候，大家都会知道我们使用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 <module>
<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.提高代码的可读性，简洁性等等
