什么是上下文管理器？
在写程序时，因为资源是有限的，所以我们必须保证资源在使用后得到释放，不然就很容易造成资源泄露，轻则使得系统处理缓慢，重则会使系统崩溃。
如下我们打开10000000个文件但是用完后没有关闭，占据太多资源，导致系统崩溃报错。：
for x in range(10000000):
# open函数返回是一个文件对象，这个对象包含__enter__()和方法__exit__()
f = open('test.txt', 'w')
f.write('hello')
为了解决这个问题，Python中引用了上下文管理器（context manager）：它能够帮助你自动分配并且释放资源。其中最典型的就是with语句：
for x in range(10000000):
with open('test.txt', 'w') as f:
f.write('hello')
当然，with的代码，也可以用下面的形式表示：
f = open('test.txt', 'w')
try:
f.write('hello')
finally:
f.close()
最后的finally block尤其重要，哪怕在写入文件时发生错误，它也可以保证该文件最终被关闭。
另外一个典型的例子是Python中的threading.lock类。比如我想要获取一个锁，执行相应的操作，完成后再释放：
some_lock = threading.Lock()
some_lock.acquire()
try:
...
finally:
some_lock.release()
# 或者直接用with语句，可简化代码
some_lock = threading.Lock()
with somelock:
...
上下文管理器的实现
基于类的上下文管理器
当用于类来创建上下文管理器时，必须保证这个类包括方法__enter__()和方法__exit__()。其中__enter__()返回需要被管理的资源，exit()通常会存在一些释放、清理资源的操作。
class FileManager:
def __init__(self, name, mode):
print('calling __init__ method')
self.name = name
self.mode = mode
self.file = None
# 返回需要被管理的资源
def __enter__(self):
print('calling __enter__ method')
self.file = open(self.name, self.mode)
return self.file
# 释放、清理资源。exc_type, exc_val, exc_tb分别表示exception_type、exception_value 和 traceback。如果有异常抛出，异常的信息就会包含这三个变量中传入方法__exit__
def __exit__(self, exc_type, exc_val, exc_tb):
print('calling __exit__ method')
if self.file:
self.file.close()
with FileManager('test.txt', 'w') as f:
print('ready to write to file')
f.write('hello world')
而当我们with语句，执行这个上下文管理器时：
- 方法__init__()被调用，程序初始化对象FileManager，使得文件名(name)是'test.txt'，文件模式(mode)是'w'；
- 方法__enter__()被调用，文件'test.txt'以写入模式被打开，并且返回FileManager对象赋予变量f；
- 字符串“hello world”被写入文件“test.txt”；
- 方法__exit__()被调用，负责关闭之前打开的文件流。 因此，这个程序的输出：
calling __init__ method
calling __enter__ method
ready to write to file
calling __exit__ method
另外，因为__exit__()中的参数exc_type, exc_val, exc_tb分别表示exception_type、exception_value 和 traceback。当我们执行含有上下文管理器的with语句时，如果有异常抛出，异常的信息就会包含这三个变量中传入方法__exit__()。
所以，如果需要处理可能发生的异常，可以在__exit__()添加相应的代码。
class Foo:
def __init__(self):
print('__init__ called')
def __enter__(self):
print('__enter__ called')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('__exit__ called')
if exc_type:
print(f'exc_type: {exc_type}')
print(f'exc_value: {exc_val}')
print(f'exc_traceback: {exc_tb}')
print('exception handled')
# 如果没有返回True，异常仍然会被抛出；所以如果确定异常被处理，需要返回True
return True
with Foo() as obj:
raise Exception('exception raised').with_traceback(None)
__init__ called
__enter__ called
__exit__ called
exc_type: <class 'Exception'>
exc_value: exception raised
exc_traceback: <traceback object at 0x108f64ac0>
exception handled
数据库的连接操作，也常常用上下文管理器来表示
class DBConnectionManager:
# 对数据库进行初始化，也就是将主机名和端口号分别赋予变量hostname和port
def __init__(self, hostname, port):
self.hostname = hostname
self.port = port
self.connection = None
# 连接数据库，并且返回对象DBConnectionManager
def __enter__(self):
self.connection = DBClient(self.hostname, self.port)
return self
# 负责关闭数据库的连接
def __exit__(self, exc_type, exc_val, exc_tb):
self.connection.close()
with DBConnectionManager('localhost', '8000') as db_client:
...
这样一来，只要你写完了 DBconnectionManager 这个类，那么在程序每次连接数据库时，我们都只需要简单地调用 with 语句即可，并不需要关心数据库的关闭、异常等等，显然大大提高了开发的效率。
基于生成器的上下文管理器
除了基于类，生成器还可以基于生成器实现：使用装饰器contextlib.contextmanager来定义自己所需的基于生成器的上下文管理器，用以支持with语句。 如上面的文件管理器，也可以这么写：
from contextlib import contextmanager
@contextmanager
def file_manager(name, mode):
try:
f = open(name, mode)
yield f
finally:
f.close()
with file_manager('test.txt', 'w') as f:
f.write('hello world')
函数file_manager()是一个生成器，当我们执行with语句时，便会打开文件，并返回文件对象f；当with语句执行完成后，finally block中的关闭文件操作便会执行。
基于生成器的上下文管理器，不再用定义“enter()”和“exit()”方法，但请务必加上装饰器 @contextmanager！
基于类和基于生成器的上下文管理器，这两者在功能上是一致的。但：
- 基于类的上下文管理器更加flexible，适用于大型的系统开发。
- 基于生成器的上下文管理器更加方便、简洁，适用于中小型程序。 无论使用哪一种都要记住释放资源！
