13.上下文管理
六、上下文管理
上下文管理可以包装任意格式的代码块
上下文管理的语法
上下文管理器是一个包装任意代码块的对象。上下文管理器保证进入上下文管理器时，每次代码执行的一致性；当退出上下文管理器时，
相关的资源会被正确回收。
值得注意的是，上下文管理器一定能够保证退出步骤的执行。如果进入上下文管理器，根据定义，一定会有退出步骤。即使内部代码抛出了异常，这点也成立。事实上，如果退出步骤处理异常合适，那么上下文管理器的退出代码为处理这类异常提供了一个机会(虽然不强制要求)。
因此上下文管理器的功能类似于执行try、except和finally关键字。通常，这也是一种封装需要被重复使用的try-except-finally结构的有效机制。
上下文管理器的任务是：代码块执行前准备，代码块执行后收拾
with子句
1、当 with 语句执行时,便执行上下文符号(译者注:就是 with 与 as 间内容)来获得一个上下文管理器.
2、上下文管理器的职责是提供一个上下文对象.这是通过调用__context__()方法来实现的 。该方法返回一个上下文对象,用于在 with 语句块中处理细节
3、需要注意的是上下文对象本身就可以是上下文管理器.所以 context_expr 既可以为一个真正的上下文管理器,也可以是一个可以自我管理的上下文对象
4、一旦我们获得了上下文对象,就会调用它的__enter()__方法
5、在将打开文件的操作放在with语句中，代码块结束后，文件将自动关闭
6、上下文管理器比文件自身多了一个异常处理功能，它允许我们把文件处理代码包装到一个逻辑层中，以确保在退出后可以自动关闭文件，
而不是依赖于垃圾收集上的自动关闭
7、with 语法的基本用法看上去如下:
with context_expr [as var]:
with_suite
例子：
>>> with open('foo.py') as f:
... data = f.readlines()
...
>>> f.closed
True
8、它仅能工作于支持上下文管理协议(context management protocol)的对象.这显然意味着只有内建了"上下文管理"的对象可以和 with 一起工作
如何使用上下文管理器：
如何打开一个文件，并写入"hello world"
filename="my.txt"
mode="w"
f=open(filename,mode)
f.write("hello world")
f.close()
当发生异常时（如磁盘写满），就没有机会执行第5行。当然，我们可以采用try-finally语句块进行包装：
writer=open(filename,mode)
try:
writer.write("hello world")
finally:
writer.close()
当我们进行复杂的操作时，try-finally语句就会变得丑陋，采用with语句重写：
with open(filename,mode) as writer:
writer.write("hello world")
as指代了从open()函数返回的内容，并把它赋给了新值。with完成了try-finally的任务。
自定义上下文管理器
with语句的作用类似于try-finally，提供一种上下文机制。要应用with语句的类，其内部必须提供两个内置函数__enter__和__exit__。前者在主体代码执行前执行，后者在主体代码执行后执行。as后面的变量，是在__enter__函数中返回的。
#!/usr/bin/env python #coding:utf8 class echo(): def output(self): print "hello world" def __enter__(self): print "enter" return self #可以返回任何希望返回的东西 def __exit__(self,exception_type,value,trackback): print "exit" if exception_type==ValueError: return True else: return False echo = echo() with echo as e: e.output()
执行结果：
enter
hello world
exit
enter和exit方法
1.with语句的表达式的作用是返回一个遵循特定协议的对象。具体来说，该对象必须定义一个__enter__方法和一个__exit__方法，且后者必须接受特定参数
2.除了传统的self参数，__enter__方法不接受任何其他参数。当对象返回时该方法立即执行，然后如果有as变量(as子句是可选项)，返回值将被赋给as后面使用的变量。
3.一般来说，__enter__方法负责执行一些配置。另外一方面，__exit__方法带有3个位置参数(不包括传统的self参数)：一个异常类型、一个异常实例和一个回溯。如果没有异常，这3个参数全被设置为None，但如果在代码块内有异常发生，则参数被填充。
#!/usr/bin/env python
#coding:utf-8
class ContextManager(object):
def __init__(self):
self.entered = False
def __enter__(self):
self.entered = True
return self
def __exit__(self, exc_type, exc_instance,traceback):
self.entered = False
cm = ContextManager()
print cm.entered
执行结果：
False
该上下文管理器只是返回自身和设置其entered变量，在进入时设置为True，退出时设置为False。
如果相同的ContextManager实例作为上下文管理器，观察它的entered属性会先变成True，然后在退出时再次变成False
#!/usr/bin/env python
#coding:utf-8
class ContextManager(object):
def __init__(self):
self.entered = False
def __enter__(self):
self.entered = True
return self
def __exit__(self, exc_type, exc_instance,traceback):
self.entered = False
cm = ContextManager()
with cm:
print cm.entered
print cm.entered
执行结果：
True
False
如果在其他地方不需要ContextManager实例，可以用with语句将其实例化。该方法可行的原因在于它的__enter__方法只返回了它本身。
#!/usr/bin/env python
#coding:utf-8
class ContextManager(object):
def __init__(self):
self.entered = False
def __enter__(self):
self.entered = True
return self
def __exit__(self, exc_type, exc_instance,traceback):
self.entered = False
# cm = ContextManager()
with ContextManager() as cm:
print cm.entered
# print cm.entered
执行结果：
True
异常处理
1.上下文管理器必须定义__exit__方法，该方法可以选择性地处理包装代码快中出现的异常，或处理其他需要关闭上下文管理状态的事情。
2.__exit__方法必须定义3个位置参数：异常类型、异常实例以及回溯选择。如果上下文管理器中的代码没有发生异常，则所有3个参数的值为None。
3.如果__exit__方法接收一个异常，就有处理这个异常的义务。从根本上讲，这个方法有3个可选项：
可以传播异常(因为会在__exit__完成后再次抛出异常)
可以终止异常
可以抛出不同的异常
4.可以通过让一个__exit__方法返回False实现异常的传播，或者通过让__exit__返回True终止异常。另外，如果__exit__抛出不同的异常，它将代替异常被发送出去。
何时编写上下文管理器
涉及确保某种资源以一种期望的方法被初始化或反初始化，或尽力去避免重复时可以使用上下文管理器
避免重复
当提到避免重复时，异常处理是最为常见的。上下文管理器能够传播和终止异常，这使得最适合将它与except子句放在同一个地方定义。
1.传播异常
__exit__方法只是向流程链上传播异常，这是通过返回False实现的，根本不需要与异常实例交互
例子1：
#!/usr/bin/env python
#coding:utf-8
class BubbleExceptions(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_val:
print "Bubbling up exception: %s." % exc_val
return False
with BubbleExceptions():
print 5 + 5
执行结果：
10
在上下文管理器中运行普通代码块(不抛出异常)将不会做什么特殊的事情
例子2:
#!/usr/bin/env python
#coding:utf-8
class BubbleExceptions(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_val:
print "Bubbling up exception: %s." % exc_val
return False
with BubbleExceptions():
print 5 / 0
执行结果：
Bubbling up exception: integer division or modulo by zero.
Traceback (most recent call last):
File "G:/PycharmProject/fullstack2/week1/test6.py", line 15, in <module>
print 5 / 0
ZeroDivisionError: integer division or modulo by zero
这里有2件需要注意的事情：
1.第一行(Bubbling up exception: integer division or modulo by zero.)由__exit__方法自身产生。它对应于__exit__方法中的print语句。
这意味着__exit__方法的确运行了且已完成。
2.因为该方法返回了False，所以被首先发送给__exit__的异常只是被重新抛出了。
2.终止异常
__exit__方法拥有的另一个选项就是终止它所接收的异常。下面的上下文管理终止所有可能发送给__exit__方法的异常(但是永远不要这样做)：
例子1：
#!/usr/bin/env python
#coding:utf-8
class SuppressExceptions(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_val:
print "SuppressException: %s." % exc_val
return True
with SuppressExceptions():
print 5+5
执行结果：
10
例子2：
#!/usr/bin/env python
#coding:utf-8
class SuppressExceptions(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_val:
print "SuppressException: %s." % exc_val
return True
with SuppressExceptions():
print 5 / 0
执行结果：
SuppressException: integer division or modulo by zero.
注意：
1.首先且最明显的是回溯消失了。由于异常被__exit__方法处理了(终止)，因此程序没有引发异常，继续执行。
2.第二个要注意的是没有任何返回值。当进入解释器时，尽管表达式 5 + 5返回了10，但引发异常的表达式 5/0根本不会显示值。异常在计算该值的过程中
引发，从而触发__exit__的运行。实际上永远不会返回任何值。另外，值得注意的是任何出现在5/0后面的代码都不会再执行。
3.处理特定异常类
一个简单的异常处理函数__exit__可以仅检查异常是否是特定异常类的实例，执行任何必要的异常处理，并根据是否获得其他类型的异常类返回True（或返回False）。
例子1：
#!/usr/bin/env python
#coding:utf-8
class HandleValueError(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if not exc_type:
return True
if issubclass(exc_type,ValueError):
print "Handling ValueError: %s" % exc_val
return True
return False
with HandleValueError(): #使用该上下文管理器并且在代码块内引发ValueError，则会看到想要的输出，之后异常终止
raise ValueError("Wrong value.")
执行结果：
Handling ValueError: Wrong value.
例子2：
#!/usr/bin/env python
#coding:utf-8
class HandleValueError(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if not exc_type:
return True
if issubclass(exc_type,ValueError):
print "Handling ValueError: %s" % exc_val
return True
return False
with HandleValueError(): #使用上下文管理器但引发不同类的异常，那么抛出该异常并输出回溯
raise TypeError("Wrong type.")
执行结果：
Traceback (most recent call last):
File "G:/PycharmProject/fullstack2/week1/test6.py", line 21, in <module>
raise TypeError("Wrong type.")
TypeError: Wrong type.
4.不包括的子类
如何完成类或实例的检查也可以更加灵活。假如想要捕获一个给定的异常类，但不希望显式地捕获它的子类。在传统的except代码块中不能这样做，也不该这样做。但是上下文管理器就能处理这样的极端情况。
例子1：
#!/usr/bin/env python
#coding:utf-8
class ValueErrorSubclass(ValueError):
pass
class HandleValueError(object):
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if not exc_type:
return True
if exc_type == ValueError:#通过使用==来检查其类型，这意味着对ValueError的处理与之前一样，只是管理器不再处理ValueError的子类
print "Handling ValueError: %s " % exc_val
return True
return False
with HandleValueError():
raise ValueErrorSubclass("foo bar baz")
执行结果：
Traceback (most recent call last):
File "G:/PycharmProject/fullstack2/week1/test6.py", line 25, in <module>
raise ValueErrorSubclass("foo bar baz")
__main__.ValueErrorSubclass: foo bar baz
5.基于属性的异常处理
上下文管理器可以根据异常的类型来决定是否处理异常，与此类似，它还可以根据异常的属性来决定是否处理异常
更简单的语法：contextlib模块
contextlib模块的作用是提供更易用的上下文管理器，它是通过Generator实现的。contextlib中的contextmanager作为装饰器来提供一种针对函数级别的上下文管理机制，常用框架如下：
from contextlib import contextmanager @contextmanager def make_context(): print 'enter' try: yield "ok" except RuntimeError, err: print 'error', err finally: print 'exit' with make_context() as value: print value
输出为：
enter
ok
exit
其中，yield写入try-finally中是为了保证异常安全（能处理异常）as后的变量的值是由yield返回。yield前面的语句可看作代码块执行前操作，yield之后的操作可以看作在__exit__函数中的操作。
以线程锁为例：
from contextlib import contextmanager import threading lock = threading.Lock() @contextmanager def loudLock(): print('Locking') lock.acquire() yield print('Releasing') lock.release() with loudLock(): print('Lock is locked: %s' % lock.locked()) print('Doing something that needs locking')
执行结果：
Locking Lock is locked: True Doing something that needs locking Releasing
contextlib.nested:减少嵌套
对于：
with open(filename,mode) as reader:
with open(filename1,mode1) as writer:
writer.write(reader.read())
可以通过contextlib.nested进行简化：
with contextlib.nested(open(filename,mode),open(filename1,mode1)) as (reader,writer):
writer.write(reader.read())
在python 2.7及以后，被一种新的语法取代：
with open(filename,mode) as reader,open(filename1,mode1) as writer:
writer.write(reader.read())
contextlib.closing()
file类直接支持上下文管理器API，但有些表示打开句柄的对象并不支持，如urllib.urlopen()返回的对象。还有些遗留类，使用close()方法而不支持上下文管理器API。为了确保关闭句柄，需要使用closing()为它创建一个上下文管理器（调用类的close方法）。
#!/usr/bin/env python #coding:utf8 import contextlib class myclass(): def __init__(self): print '__init__' def close(self): print 'close()' with contextlib.closing(myclass()): print 'ok'
输出：
__init__
ok
close()
