Python 上下文管理器和else块

Posted 2020-10-04

　　最终，上下文管理器可能几乎与子程序（subroutine）本身一样重要。目前，我们只了解了上下文管理器的皮毛……Basic 语言有with 语句，而且很多语言都有。但是，在各种语言中 with 语句的作用不同，而且做的都是简单的事，虽然可以避免不断使用点号查找属性，但是不会做事前准备和事后清理。不要觉得名字一样，就意味着作用也一样。with 语句是非常了不起的特性。 

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  ——Raymond Hettinger

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　雄辩的 Python 布道者

先做这个，再做那个：if语句之外的else块 

　　这个语言特性不是什么秘密，但却没有得到重视：else 子句不仅能在if 语句中使用，还能在 for、while 和 try 语句中使用。for/else、while/else 和 try/else 的语义关系紧密，不过与if/else 差别很大。起初，else 这个单词的意思阻碍了我对这些特性的理解，但是最终我习惯了。

else 子句的行为如下:

for

　　仅当 for 循环运行完毕时（即 for 循环没有被 break 语句中止）才运行 else 块。

while

　　仅当 while 循环因为条件为假值而退出时（即 while 循环没有被break 语句中止）才运行 else 块。

try

　　仅当 try 块中没有异常抛出时才运行 else 块。官方文档（https://docs.python.org/3/reference/compound_stmts.html）还指出：“else 子句抛出的异常不会由前面的 except 子句处理。”

注意：

　　在所有情况下，如果异常或者 return、break 或 continue 语句导致控制权跳到了复合语句的主块之外，else 子句也会被跳过。

 

　　在这些语句中使用 else 子句通常能让代码更易于阅读，而且能省去一些麻烦，不用设置控制标志或者添加额外的 if 语句。

在循环中使用 else 子句的方式如下述代码片段所示：

1 for item in my_list:
2     if item.flavor == ‘banana‘:
3         break
4     else:
5         raise ValueError(‘No banana flavor found!‘)

一开始，你可能觉得没必要在 try/except 块中使用 else 子句。毕竟，在下述代码片段中，只有 dangerous_call() 不抛出异常，after_call() 才会执行，对吧？

1 try:
2     dangerous_call()
3     after_call()
4 except OSError:
5     log(‘OSError...‘)

然而，after_call() 不应该放在 try 块中。为了清晰和准确，try 块中应该只抛出预期异常的语句。因此，像下面这样写更好：

1 try:
2     dangerous_call()
3 except OSError:
4     log(‘OSError...‘)
5 else:
6     after_call()

现在很明确，try 块防守的是 dangerous_call() 可能出现的错误，而不是 after_call()。而且很明显，只有 try 块不抛出异常，才会执行after_call()。

 

上下文管理器和with块

　　上下文管理器对象存在的目的是管理 with 语句，就像迭代器的存在是为了管理 for 语句一样。

　　with 语句的目的是简化 try/finally 模式。这种模式用于保证一段代码运行完毕后执行某项操作，即便那段代码由于异常、return 语句或sys.exit() 调用而中止，也会执行指定的操作。finally 子句中的代码通常用于释放重要的资源，或者还原临时变更的状态。

　　上下文管理器协议包含 __enter__ 和 __exit__ 两个方法。with 语句开始运行时，会在上下文管理器对象上调用 __enter__ 方法。with 语句运行结束后，会在上下文管理器对象上调用 __exit__ 方法，以此扮演 finally 子句的角色。

 

?? 演示把文件对象当成上下文管理器使用

>>> with open(‘mirror.py‘) as fp: # fp绑定到打开的文件上，因为文件的__enter__方法返回self
...           src = fp.read(60) # 从fp中读取一些数据
...
>>> len(src)
60
>>> fp # fp变量依然可以使用
<_io.TextIOWrapper name=‘mirror.py‘ mode=‘r‘ encoding=‘UTF-8‘>
>>> fp.closed, fp.encoding # 可以读取fp对象的属性
(True, ‘UTF-8‘)
>>> fp.read(60) # 但是不能在fp上执行I/O操作，因为在with块的结尾，调用了TextIOWrappper.__exit__方法把文件关闭了
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.     

测试 LookingGlass 上下文管理器类

>>> from mirror import LookingGlass
>>> with LookingGlass() as what: # 上下文管理器是LookingGlass类的实例；Python在上下文管理器上调用__enter__方法，把返回结果绑定在what上
...     print(‘Alice, Kitty and Snowdrop‘) # 打印一个字符串，然后打印what变量的值
...     print(what)
...
pordwonS dna yttiK ,ecilA # 打印出的内容是反向的
YKCOWREBBAJ
>>> what # 现在，with块已经执行完毕，可以看出，__enter__方法返回的值，即存储在what变量中的值是字符串‘JABBERWOCKY‘
‘JABBERWOCKY‘
>>> print(‘Back to normal.‘) # 输出不在是反向的了
Back to normal.

mirror.py：LookingGlass 上下文管理器类的代码

 1 class LookingGlass:
 2 
 3     def __enter__(self):                        # 除了 self 之外，Python调用__enter__方法时不窜入其他参数
 4         import sys
 5         self.original_write = sys.stdout.write  # 把原来的 sys.stdout.write 方法保存在一个实例属性中，供后面使用
 6         sys.stdout.write = self.reverse_write   # 为 sys.stdout.write 打猴子补丁，替换成自己编写的方法
 7         return ‘JABBERWOCKY‘                    # 返回 ‘JABBERWOCKY‘ 字符串，这样才有内容存入目标变量 what
 8 
 9     def reverse_write(self, text):             # 这是用于取代 sys.stdout.write 的方法，把 text 参数的内容反转，然后调用原来的方法实现
10         return self.original_write(text[::-1])
11 
12 
13     def __exit__(self, exc_type, exc_val, traceback):   # 如果一切正常，Python会调用__exit__方法传入的参数是三个None，如果抛出异常，则三个参数是异常的数据
14         import sys
15         sys.stdout.write = self.original_write  # 还原成原来的sys.studout.write方法
16         if exc_type is ZeroDivisionError:       # 如果有异常，而且是 ZeroDivisionError 类型，打印一个消息
17             print(‘Please DO NOT divide by zero!‘)  
18             return True                         # 然后返回 True，告诉解释器，异常已经处理

解释器调用 __enter__ 方法时，除了隐式的 self 之外，不会传入任何参数。传给 __exit__ 方法的三个参数列举如下。

exc_type

　　异常类（例如 ZeroDivisionError）

exc_value

　　异常实例。有时会有参数传给异常构造方法，例如错误消息，这些参数可以使用 exc_value.args 获取

traceback

　　traceback 对象

 

在 with 块之外使用 LookingGlass 类

>>> from mirror import LookingGlass
>>> manager = LookingGlass() # 实例化并审查manager实例，等同于 with LookingGlass() as manager
>>> manager
<mirror.LookingGlass object at 0x2a578ac>
>>> monster = manager.__enter__() # 在上下文管理器中调用__enter__()方法，把结果存储在monster中
>>> monster == ‘JABBERWOCKY‘ # monster的值是字符串‘JABBERWOCKY‘，打印出来的True标识符是反向，因为用了猴子补丁
eurT
>>> monster
‘YKCOWREBBAJ‘
>>> manager
>ca875a2x0 ta tcejbo ssalGgnikooL.rorrim<
>>> manager.__exit__(None, None, None) # 调用manager.__exit__，还原成之前的stdout.write
>>> monster
‘JABBERWOCKY‘

 

contextlib模块中的实用工具

closing

　　如果对象提供了 close() 方法，但没有实现__enter__/__exit__ 协议，那么可以使用这个函数构建上下文管理器。

suppress

　　构建临时忽略指定异常的上下文管理器。

@contextmanager

　　这个装饰器把简单的生成器函数变成上下文管理器，这样就不用创建类去实现管理器协议了。

ContextDecorator 

　　这是个基类，用于定义基于类的上下文管理器。这种上下文管理器也能用于装饰函数，在受管理的上下文中运行整个函数。

ExitStack

　　这个上下文管理器能进入多个上下文管理器。with 块结束时，ExitStack 按照后进先出的顺序调用栈中各个上下文管理器的__exit__ 方法。如果事先不知道 with 块要进入多少个上下文管理器，可以使用这个类。例如，同时打开任意一个文件列表中的所有文件。

 

使用@contextmanager

　　@contextmanager 装饰器能减少创建上下文管理器的样板代码量，因为不用编写一个完整的类，定义 __enter__ 和 __exit__ 方法，而只需实现有一个 yield 语句的生成器，生成想让 __enter__ 方法返回的值。

　　在使用 @contextmanager 装饰的生成器中，yield 语句的作用是把函数的定义体分成两部分：yield 语句前面的所有代码在 with 块开始时（即解释器调用 __enter__ 方法时）执行， yield 语句后面的代码在with 块结束时（即调用 __exit__ 方法时）执行。

mirror_gen.py：使用生成器实现的上下文管理器

 1 import contextlib
 2 
 3 
 4 @contextlib.contextmanager              # 应用 contextmanager 装饰器
 5 def looking_glass():
 6     import sys
 7     original_write = sys.stdout.write   # 贮存原来的 sys.stdout.write 方法
 8 
 9     def reverse_write(text):            # 定义自定义的 reverse_write 函数；在闭包中可以访问 original_write
10         original_write(text[::-1])
11 
12     sys.stdout.write = reverse_write    # 把 sys.stdout.write 替换成 reverse_write
13     yield ‘JABBERWOCKY‘                 # 产出一个值，这个值会绑定到 with 语句中 as 子句的目标变量上
14     sys.stdout.write = original_write   # 控制权一旦跳出 with 块，继续执行 yield 语句之后的代码；这里是恢复成原来的 sys. stdout.write 方法
15 
16 with looking_glass() as what:           # 直接通过上下文管理器实现with的功能
17     print(‘Alice, Kitty and Snowdrop‘)
18     print(what)
19 
20 print(what)

以上代码执行的结果为：

pordwonS dna yttiK ,ecilA
YKCOWREBBAJ
JABBERWOCKY

其实，contextlib.contextmanager 装饰器会把函数包装成实现__enter__ 和 __exit__ 方法的类

这个类的 __enter__ 方法有如下作用:

　　(1) 调用生成器函数，保存生成器对象（这里把它称为 gen）。

　　(2) 调用 next(gen)，执行到 yield 关键字所在的位置。

　　(3) 返回 next(gen) 产出的值，以便把产出的值绑定到 with/as 语句中的目标变量上。

with 块终止时，__exit__ 方法会做以下几件事:

　　(1) 检查有没有把异常传给 exc_type；如果有，调用gen.throw(exception)，在生成器函数定义体中包含 yield 关键字的那一行抛出异常。

　　(2) 否则，调用 next(gen)，继续执行生成器函数定义体中 yield 语句之后的代码。

注意：　　

　　上面的 ?? 有一个严重的错误：如果在 with 块中抛出了异常，Python 解释器会将其捕获，然后在 looking_glass 函数的 yield 表达式里再次抛出。但是，那里没有处理错误的代码，因此 looking_glass 函数会中止，永远无法恢复成原来的 sys.stdout.write 方法，导致系统处于无效状态。

mirror_gen_exc.py：基于生成器的上下文管理器，而且实现了异常处理

 1 import contextlib
 2 
 3 
 4 @contextlib.contextmanager
 5 def looking_glass():
 6     import sys
 7     original_write = sys.stdout.write
 8 
 9     def reverse_write(text):
10         original_write(text[::-1])
11 
12     sys.stdout.write = reverse_write
13     msg = ‘‘                                #创建一个变量，用于保存可能出现的错误消息；
14     try:
15         yield ‘JABBERWOCKY‘
16     except ZeroDivisionError:               #处理 ZeroDivisionError 异常，设置一个错误消息
17         msg = ‘Please DO NOT divide by zero!‘
18     finally:
19         sys.stdout.write = original_write   # 撤销对 sys.stdout.write 方法所做的猴子补丁
20         if msg:
21             print(msg)                      # 如果设置了错误消息，把它打印出来

注意：

　　使用 @contextmanager 装饰器时，要把 yield 语句放在try/finally 语句中（或者放在 with 语句中），这是无法避免的，因为我们永远不知道上下文管理器的用户会在 with 块中做什么。