目录
什么是with语句？
with 语句是从 Python 2.6 开始引入的一种与异常处理相关的功能。with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。
with语句是一个新的控制流结构，其基本结构为：
with expression [as variable]:
with-block
一个很好的例子是文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。如果不用with语句，代码如下：
file = open("foo.txt")
data = file.read()
file.close()
这里有两个问题：
- 可能忘记关闭文件句柄
- 文件读取数据发生异常，没有进行任何处理
下面是处添加了异常处理的代码：
file = open("foo.txt")
try:
data = file.read()
finally:
file.close()
虽然这段代码运行良好，但是太冗长了。这时候就是with一展身手的时候了。除了有更优雅的语法，with还可以很好的处理上下文环境产生的异常。下面是with版本的代码：
with open("foo.txt") as file:
data = file.read()
with语句是如何工作的？
Python对with的处理还聪明。基本思想是with所求值的对象必须有一个enter()方法，一个exit()方法。紧跟with后面的语句被求值后，返回对象的enter()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的exit()方法。
下面例子可以具体说明with如何工作：
class Sample:
def __enter__(self):
print("In __enter__()")
return "Foo"
def __exit__(self, type, value, trace):
print("In __exit__()")
def get_sample():
return Sample()
with get_sample() as sample:
print("sample:", sample)
执行后的输出内容为：
In __enter__() sample: Foo In __exit__()
具体流程：
- enter()方法被执行
- enter()方法返回的值 – 这个例子中是”Foo”，赋值给变量’sample’
- 执行代码块，打印变量”sample”的值为 “Foo”
- exit()方法被调用
with真正强大之处是它可以处理异常。可能你已经注意到Sample类的exit方法有三个参数：val, type 和 trace。 这些参数在异常处理中相当有用。我们来改一下代码，看看具体如何工作的。
class Sample:
def __enter__(self):
return self
def __exit__(self, type, value, trace):
print("type:", type)
print("value:", value)
print("trace:", trace)
def do_something(self):
bar = 1 / 0
return bar
with Sample() as sample:
sample.do_something()
输出结果为：
Traceback (most recent call last):
File "test.py", line 16, in <module>
sample.do_something()
File "test.py", line 11, in do_something
bar = 1 / 0
ZeroDivisionError: division by zero
type: <class 'ZeroDivisionError'>
value: division by zero
trace: <traceback object at 0x0000029739A7F508>
这个例子中，with后面的get_sample()变成了Sample()。这没有任何关系，只要紧跟with后面的语句所返回的对象有enter()和exit()方法即可。此例中，Sample()的enter()方法返回新创建的Sample对象，并赋值给变量sample。
实际上，在with后面的代码块抛出任何异常时，exit()方法被执行。正如例子所示，异常抛出时，与之关联的type，value和stack trace传给exit()方法，因此抛出的ZeroDivisionError异常被打印出来了。开发库时，清理资源，关闭文件等等操作，都可以放在exit方法当中。
因此，Python的with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，清理工作更简单。
上下文管理器
在任何一门编程语言中，文件的输入输出、数据库的连接断开等，都是很常见的资源管理操作。但资源都是有限的，在写程序时，我们必须保证这些资源在使用过后得到释放，不然就容易造成资源泄露，轻者使得系统处理缓慢，重则会使系统崩溃。
为了解决这个问题，不同的编程语言都引入了不同的机制。而在 Python 中，对应的解决方式便是上下文管理器（context manager）。上下文管理器，能够帮助你自动分配并且释放资源，其中最典型的应用便是 with 语句。
另外一个典型的例子，是 Python 中的 threading.lock 类。举个例子，比如我想要获取一个锁，执行相应的操作，完成后再释放，那么代码就可以写成下面这样：
some_lock = threading.Lock()
some_lock.acquire()
try:
...
finally:
some_lock.release()
而对应的 with 语句，同样非常简洁：
some_lock = threading.Lock()
with somelock:
...
我们可以从这两个例子中看到，with 语句的使用，可以简化了代码，有效避免资源泄露的发生。
基于类的上下文管理器
这里，我自定义了一个上下文管理类 FileManager，模拟 Python 的打开、关闭文件操作：
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
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')
当我们用类来创建上下文管理器时，必须保证这个类包括方法”__enter__()”和方法“__exit__()”。其中，方法“__enter__()”返回需要被管理的资源，方法“__exit__()”里通常会存在一些释放、清理资源的操作，比如这个例子中的关闭文件等等。而当我们用 with 语句，执行这个上下文管理器时：
with FileManager('test.txt', 'w') as f:
f.write('hello world')
下面这四步操作会依次发生：
- 方法“__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__()”。
基于contextlib模块装饰器和生成器实现
Python 在 contextlib 模块中还提供了一个 contextmanager 的装饰器，更进一步简化了上下文管理器的实现方式。通过 yield 将函数分割成两部分，yield 之前的语句在 __enter__ 方法中执行，yield 之后的语句在 __exit__ 方法中执行。紧跟在 yield 后面的值是函数的返回值。
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，这一点新手很容易疏忽。
参考链接：
