介绍
contextlib模块包含的工具可以用于处理上下文管理器和with语句
上下文管理器API
'''
上下文管理器(context manager)负责管理一个代码块中的资源，会在进入代码块时创建资源，然后再退出代码后清理这个资源。
比如：文件就支持上下文管理器API，可以确保文件读写后关闭文件。
with open("xxx") as f:
f.read()
'''
# 那么这是如何实现的呢？我们可以手动模拟一下
class Open:
def __init__(self, filename, mode='r', encoding=None):
self.filename = filename
self.mode = mode
self.encoding = encoding
def __enter__(self):
print("__enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容")
return self
def read(self):
print(f"文件进行读操作,读取文件：{self.filename}, 模式：{self.mode}, 编码：{self.encoding}")
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件")
# 首先执行Open("1.xxx")，实例化一个对象，然后调用__enter__
# __enter__返回的内容会叫给f，然后执行with语句块里面的代码
# with语句块代码执行完毕之后，再执行__exit__
with Open("1.xxx") as f:
f.read()
'''
__enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容
文件进行读操作,读取文件：1.xxx, 模式：r, 编码：None
__exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件
'''因此需要注意的是，里面的f只是__enter__返回的值，并不是真正意义上的self，怎么理解呢？我们来看一个例子
class Open:
def __init__(self, filename, mode='r', encoding=None):
self.filename = filename
self.mode = mode
self.encoding = encoding
def __enter__(self):
print("__enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容")
return None
def __exit__(self, exc_type, exc_val, exc_tb):
print("__exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件")
with Open("1.xxx") as f:
print(f)
"""
__enter__,有了这个就可以使用with Open() as xx语句，这里的xx就是我return的内容
None
__exit__,我是用来清理资源的，当操作执行完毕之后就会执行我，比如：关闭文件
"""
# 我们看到此时__enter__返回的是None，那么对应的f也是None
# 当with语句执行完毕之后，并不是调用f.__exit__或者说Open.__exit__(f, ...)
# 而是说当执行with Open("1.xxx")的时候，已经创建了一个实例对象，只不过这个实例对象是什么我们不知道
# 但是as f，只是调用了这个实例对象的__enter__，然后将返回值赋值给了f
# 然后with语句结束，也是通过这个实例对象来调用__exit__，而不是f，这一点需要记清楚
# 所以要记住f是由__enter__的返回值决定的，只不过大多数情况下，__enter__里面返回的都是self本身，所以相应的f指向的也是该类的实例对象
# 因此这个例子我们也可以改写一下
class Girl:
def __init__(self, name, age):
self.name = name
self.age = age
def __enter__(self):
return "返回点什么吧"
def __exit__(self, exc_type, exc_val, exc_tb):
print(f"我会被调用吗")
with Girl("satori", 16) as f:
print("f", f)
"""
f 返回点什么吧
我会被调用吗
"""
# 显然此时f只是一个字符串，跟Girl的实例对象没有任何关系
# 再或者我们先把这个实例对象创建出来
g = Girl("hanser", 27)
# 此时__enter__、__exit__都是由g去调用，跟f没有关系
with g as f:
print("f", f)
"""
f 返回点什么吧
我会被调用吗
"""因此with语句的流程我们已经清晰了，就是三步
创建实例对象，执行__enter__，然后将其返回值交给as xx中的xx执行with语句的代码最后执行__exit__，显然__exit__是进行收尾工作的。
但是我们发现__exit__里面除了self之外，还有三个参数exc_type, exc_val, exc_tb，显然这三个参数分别是异常类型、异常值、异常的堆栈
class Open:
def __init__(self, filename, mode='r', encoding=None):
self.filename = filename
self.mode = mode
self.encoding = encoding
def __enter__(self):
return 123
def __exit__(self, exc_type, exc_val, exc_tb):
# 注意到这里有三个参数，使用pycharm的时候，会很智能地自动帮我们加上去
print(exc_type)
print(exc_val)
print(exc_tb)
return True
# 由于没有任何异常，所以exc_type, exc_val, exc_tb均为None
with Open("1.xx") as f:
print(f)
'''
123
None
None
None
'''
# with语句当中出现了异常
with Open("1.xx") as f:
print(f)
1 / 0
print(123)
print(456)
print(789)
print("你猜我会被执行吗？")
'''
123
<class 'ZeroDivisionError'>
division by zero
<traceback object at 0x0000000009EDD848>
你猜我会被执行吗？
'''
# 解释说明
'''
可以看到当我们程序没有出错的时候，打印的值全为None。一旦with语句里面出现了异常，那么会立即执行__exit__函数。
里面的参数就是：异常的类型，异常的值，异常的信息栈。
因此：当with语句结束之后会调用__exit__函数，如果with语句里面出现了错误则会立即调用__exit__函数。
但是__exit__函数返回了个True是什么意思呢？
当with语句里面出现了异常，理论上是会报错的，但是由于要执行__exit__函数，所以相当于暂时把异常塞进了嘴里。
如果__exit__函数最后返回了一个布尔类型为True的值，那么会把塞进嘴里的异常吞下去，程序不报错正常执行。如果返回布尔类型为False的值，会在执行完__exit__函数之后再把异常吐出来，引发程序崩溃。
这里我们返回了True，因此程序正常执行，最后一句话被打印了出来。
但是1/0这句代码后面的几个print却没有打印，为什么呢？
因为上下文管理执行是有顺序的，
with Open("1.xxx") as f:
code1
code2
先执行Open函数的__init__函数，再执行__enter__函数，把其返回值给交给f，然后执行with语句里面的代码，最后执行__exit__函数。
只要__exit__函数执行结束，那么这个with语句就算结束了。
而with语句里面如果有异常会立即进入__exit__函数，因此异常语句后面的代码是无论如何都不会被执行的。
'''上下文管理器作为函数修饰符
类ContextDecorator增加了对常规上下文管理器类的支持，因此不仅可以作为上下文管理器，也可以作为函数修饰符
import contextlib
class Context(contextlib.ContextDecorator):
def __init__(self, how_used):
self.how_used = how_used
print(f"__init__({self.how_used})")
def __enter__(self):
print(f"__enter__({self.how_used})")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(f"__exit__({self.how_used})")
# 此时我们定义一个函数就可以用Context这个类的实例对象去装饰
@Context("我要作为装饰器去装饰") # __init__(我要作为装饰器去装饰)
def foo(name):
print(name)
return f"我是汽车老司机，不不不，我是小司机"
# 现在的foo已经不再是原来的foo了，至于它现在到底是什么，我们后面说
# 然后此时如果再调用foo，那么会先执行Context的__enter__方法，然后执行原来的foo函数的逻辑，最后调用Context的__exit__方法
print(foo("hanser"))
"""
__enter__(我要作为装饰器去装饰)
hanser
__exit__(我要作为装饰器去装饰)
我是汽车老司机，不不不，我是小司机
"""
# 可能有人好奇，为什么返回值打印是在最后，因为这是print啊
# foo("hanser")虽然已经执行完毕了，但是外面的print肯定要等__exit__结束之后才行但是这是如何实现的呢？首先我们装饰foo的时候，显然是使用Context的实例对象去装饰的，相当于给这个实例对象加上了括号，并且把foo这个函数作为参数传进去了。既然实例对象加上了括号(调用)，这就意味着该实例对象对应的类一定有__call__方法，但是我们定义的没有，那么继承的父类肯定有。我们来看一下源码
class ContextDecorator(object):
def _recreate_cm(self):
return self
def __call__(self, func):
@wraps(func)
def inner(*args, **kwds):
with self._recreate_cm():
return func(*args, **kwds)
return inner
# 类的源码很少，当我们使用实例对象去装饰foo函数的时候，就相当于给实例对象加上了括号，那么肯定要走这里的__call__方法
# 但是这个self可不是ContextDecorator的self，而是我们之前定义的Context类里面的self，也就是Context的实例对象
# 如果面向对象基础不好的话，建议去复习一下，这里简单说一下。
# 调用Context类实例对象的时候，肯定走Context里面的__call__方法，但是没有，那么会调用父类的，但是调用时对应的self还是Context的self
# 因此之前的@Context("我要作为装饰器去装饰"),就等价于
"""
context = Context("我要作为装饰器去装饰")
@context
"""
# 然后再装饰foo的时候，相当于foo = context(foo),那么会调用这里的__call__方法，然后foo会被传递给这里的func，这里返回inner
# 所以foo在被装饰完之后，就相当于这里的inner，只不过有@wraps(func)这个装饰器在，所以装饰之后的函数名、__doc__等元信息没有改变
# 那么当我再调用foo("hanser")的时候，就等价于调用这里的inner("hanser")
# 而self._recreate_cm()返回的就是self，这个self就是我们的context，或者Context的实例对象
# 所以with self._recreate_cm():就是with self:
# 现在就很清晰了，所以要先走Context里面的__enter__，然后return func(*args, **kwds)，这里的func显然就是原来真正的foo
# 执行完毕之后，拿到返回值,然后执行__exit__，最后最外层的print再将拿到的返回值打印希望能仔细理清一遍这里的流程
从生成器到上下文管理器
采用传统方式创建上下文管理器并不难，只需要包含一个__enter__方法和一个__exit__方法的类即可。 不过某些时候，如果只有很少的上下文需要管理，那么完整地写出所以代码便会成为额外的负担。 在这些情况下，可以使用contextmanager修饰符将一个生成器函数转换为上下文管理器。
import contextlib
"""
代码结果
@contextlib.contextmanager
def foo():
print(123)
yield 456
print(789)
with foo() as f:
print(f)
123
456
789
只要给函数加上这个装饰器，那么便可以使用with as 语句。
当中的yield相当于将代码块分隔为两个战场：
yield上面的代码相当于__enter__会先执行，然后将yield的值交给f，然后执行with语句，最后执行yield下面的代码块，相当于__exit__
"""
@contextlib.contextmanager
def bar(name, age):
print(f"name is {name}, age is {age}")
yield list
print("我是一匹狼，却变成了狗")
with bar("mashiro", 16) as b:
print(b("abcde"))
'''
name is mashiro, age is 16
['a', 'b', 'c', 'd', 'e']
我是一匹狼，却变成了狗
'''
# 先执行yield上面的内容，然后yield list，那么b = list，最后执行yield下面的内容contextmanager返回的上下文管理器派生自ContextDecorator,所以也可以被用作函数修饰符
import contextlib
@contextlib.contextmanager
def bar(name, age):
print(f"name is {name}, age is {age}")
yield
print("我是一匹狼，却变成了狗")
@bar("satori", 16)
def foo():
print("猜猜我会在什么地方输出")
foo()
'''
name is satori, age is 16
猜猜我会在什么地方输出
我是一匹狼，却变成了狗
'''
# bar中含有yield，肯定是一个生成器，所以直接@bar("satori", 16)是不会输出的。当我执行foo的时候，还会先执行bar里面yield上面的内容，
# 然后执行foo代码的内容，最后执行yield下面的内容，并且此时yield后面的内容是什么也已经无关紧要了，因为根本用不到了关闭打开的句柄
诸如打开文件之类的io操作，都会有一个close操作。因此为了确保关闭，可以使用contextlib中的一个叫做closing的类
import contextlib
class Door:
def __init__(self):
print("__init__()")
self.status = "open"
def close(self):
print("close()")
self.status = "closed"
with contextlib.closing(Door()) as door:
print("此时门的状态：", door.status)
"""
__init__()
此时门的状态： open
close()
"""
print("最后门的状态：", door.status) # 最后门的状态： closed
"""
contextlib.closing接收类的实例对象，其实主要就帮我们做了两件事
一个是可以通过with语句的方式来执行，另一个是执行完毕之后自动帮我们调用close方法
"""我们还是看看源码如何实现的
class closing(AbstractContextManager):
def __init__(self, thing):
# 这里的thing显然是我们之前传入的Door的实例对象door
self.thing = thing
def __enter__(self):
# 先调用__enter__返回之前的实例
return self.thing
def __exit__(self, *exc_info):
# 最后调用我们实例的close方法
# 而且我们发现__enter__返回的是我们定义的类的实例
# 这也再次证明了调用__exit__跟__enter__返回的是什么没有任何关系
# 这里是由closing实例对象调用的
self.thing.close()import contextlib
class Door:
def __init__(self):
print("__init__()")
self.status = "open"
def close(self):
print("close()")
self.status = "closed"
# 如果出现了异常怎么办呢？不用怕，依旧会执行close语句.
# 由于contextlib.closing的__exit__函数并没有返回布尔类型为True的值，所以最后还是会抛出异常，我们手动捕获一下
try:
with contextlib.closing(Door()) as boy_next_door:
print(123)
1 / 0
print(456)
except Exception:
pass
print(boy_next_door.status)
'''
__init__()
123
close()
closed
'''
# 最后还是打印了"closed"，所以还是执行了close()方法忽略异常
很多情况下，忽略库产生的异常很有用，因为这个错误可能会显示期望的状态已经被实现，否则该错误就可以被忽略。 要忽略异常，最常用的办法就是利用一个try except语句。但是在我们此刻的主题中，try except也可以被替换成contextlib.suppress()，以更显示地抑制with块中产生的异常
import contextlib
def foo():
print(123)
1 / 0
print(456)
with contextlib.suppress(ZeroDivisionError):
foo()
print(789)
'''
123
'''
# 最终只输出了123，可以看到不仅1/0下面的456没有被打印，连foo()下面的789也没有被打印
# 可以传入多个异常
with contextlib.suppress(ZeroDivisionError, BaseException, Exception):
foo()
'''
123
'''
# 出现异常之后，会将异常全部丢弃
# 如果出现的异常没有在suppress里面指定，那么是要报错的重定向到输出流
import contextlib
import io
import sys
'''
我们可以用redirect_stdout和redirect_stderr上下文管理器从这些函数中捕获输出
'''
def func(a):
sys.stdout.write(f"stdout :{a}") # 等价于print(f"stdout :{a}")，不指定file默认是往sys.stdout也就是控制台输出的
sys.stderr.write(f"stderr :{a}") # 等价于print(f"stdout :{a}", file=sys.stderr)
capture = io.StringIO()
'''
我们执行func本来是要往sys.stdout和sys.stderr里面写的
但这是在with语句contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture)下面，
因此可以理解往sys.stdout和sys.stderr里面写的内容就被捕获到了，然后会将捕获到的内容输入到capture里面，因为我们指定了capture
'''
with contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture):
func("蛤蛤蛤蛤")
print(capture.getvalue()) # stdout :蛤蛤蛤蛤stderr :蛤蛤蛤蛤
'''
redirect_stdout和redirect_stderr会修改全局状态，替换sys模块中的对象，可以想象gevent里面的patch_all会将Python里面socket，ssl等都换掉。
因此要使用这两个函数，必须要注意。这些函数并不保证线程安全，所以在多线程应用中调用这些函数可能会有不确定的结果。
如果有其他希望标准输出流关联到终端设备，那么redirect_stdout和redirect_stderr将会干扰和影响那些操作。
'''当然这个例子让我想起了golang里面的接口，我们发现上面的capture，指定了是io.StringIO，那么除了io.StringIO还可以指定别的吗？当然可以，只要实现了write方法的对象都可以。
import contextlib
import sys
def func(a):
sys.stdout.write(f"stdout :{a}")
sys.stderr.write(f"stderr :{a}")
with open("1.txt", "w", encoding="utf-8") as f:
with contextlib.redirect_stdout(f), contextlib.redirect_stderr(f):
func("蛤蛤蛤蛤")显然文件句柄是支持write方法的
动态上下文管理器栈
import contextlib
'''
大多数上下文管理器都一次处理一个对象，如单个文件或数据库句柄。
在这些情况下，对象是提前已知的，并且使用上下文管理器的代码可以建立这一对象上。
另外一些情况下，程序可能需要在一个上下文中创建未知数目的对象，控制流退出这个上下文时所有这些对象都要清理，ExitStack就是用来处理这些更动态的情况。
ExitStack实例会维护清理回调的一个栈数据结构，这些回调显示地填充在上下文中，在控制流退出上下文时会以逆序调用所有注册的回调。
结果类似于有多个嵌套的with语句，只不过它们是动态建立的。
'''
# 可以使用多种方法填充ExitStack，比如
@contextlib.contextmanager
def make_context(i):
print(f"{i}: entering")
yield {i}
print(f"{i}: exiting")
def variable_stack(n, msg):
with contextlib.ExitStack() as stack:
for i in range(n):
d = stack.enter_context(make_context(i))
print(d)
print(msg)
variable_stack(2, "inside stack")
# 输出结果
''''
0: entering
{0}
1: entering
{1}
inside stack
1: exiting
0: exiting
'''
'''
contextlib.ExitStack()相当于创建了上下文管理器栈
stack.enter_context将上下文管理器放入到栈中，注意此时已经执行了
等于是把yield之后的结果压入栈中，stack.enter_context的返回值就是yield后面的值
会先输出：
0: entering
{0}
1: entering
{1}
然后执行下面的代码，所以会打印出msg
当里面的代码执行完毕之后，会继续执行栈里面的数据，但是栈是后入先出的。i=1后入栈，所以先执行
所以最后输出：
1: exiting
0: exiting
'''