Python——with语句、context manager类型和contextlib库

目录

  一、with语句

  二、上下文管理器

  三、contextlib模块

 

基本概念

上下文管理协议(Context Management Protocol)

  包含方法 __enter__() 和 __exit__(),支持该协议的对象要实现这两个方法。

上下文管理器(Context Manager)

  支持上下文管理协议的对象,这种对象实现了__enter__() 和 __exit__() 方法。上下文管理器定义执行 with 语句时要建立的运行时上下文,负责执行 with 语句块上下文中的进入与退出操作。通常使用 with 语句调用上下文管理器,也可以通过直接调用其方法来使用。

运行时上下文(runtime context)

  由上下文管理器创建,通过上下文管理器的 __enter__() 和__exit__() 方法实现,__enter__() 方法在语句体执行之前进入运行时上下文,__exit__() 在语句体执行完后从运行时上下文退出。with 语句支持运行时上下文这一概念。

上下文表达式(Context Expression)

  with 语句中跟在关键字 with 之后的表达式,该表达式要返回一个上下文管理器对象。

语句体(with-body)

  with 语句包裹起来的代码块,在执行语句体前会调用上下文管理器的 __enter__() 方法,执行完语句体之后会执行 __exit__() 方法。

 

一、with语句

  关于 Python 中 with 语句的详细说明:PEP 343

  with 语句用上下文管理器定义的方法包裹一段代码的执行,等价于简单版的try...except...finally语句。with语句的主要针对的情境:不论一个代码块的执行过程是否出现异常,都要在结束的时候执行一些操作(比如清理)。

  with语句语法:

with_stmt ::=  "with" with_item ("," with_item)* ":" suite
with_item ::=  expression ["as" target]

  或:

with expression [as variable]:
    with-block

  expression应该返回一个支持“上下文管理协议”的对象,如果 as 分句存在的话,这个对象的返回值会被赋给 as 后面的变量名。

 

第一种语法表示中with语句的执行流程:

  1. 计算上下文表达式 (with_item 中给出的表达式) ,获得一个上下文管理器,该上下文管理器包括__enter__() 和 __exit__()方法;
  2. 加载该上下文管理器的 __exit__() 方法留待以后使用;
  3. 调用上下文管理器的 __enter__() 方法;
  4. 如果 with 语句中的 with_item 指定了目标别名(as 分句后面的变量名),__enter__() 的返回值被赋给这个目标别名;

  *注

  with 语句确保只要 __enter__() 正常返回,那么 __exit__()一定会被调用。因此如果在将值赋给目标别名时发生错误,该错误将被当做发生在suite中。可以看下面的第6步。

  5. with语句中嵌套的 suite 部分被执行(第二种表示中的 with-block 部分);

  6. 上下文管理器的 __exit__() 方法被调用,如果是异常造成 suite(with-block) 部分退出,异常的类型、值和回溯都被当做参数传给 __exit__(type, value, traceback) 方法,这三个值和sys.exc_info的返回值相同。如果suite(with-block) 部分没有抛出异常,__exit__()的三个参数都是 None

  如果 suite 部分是由于异常导致的退出,且__exit__()方法的返回值是false,异常将被重举;如果返回值是真,异常将被终止,with 语句后的代码继续执行。

  如果 suite 部分是由于不是异常的其他原因导致的退出,__exit__()方法的返回值被忽视,执行在退出发生的地方继续

  单个上下文管理器示例:

with open(r'C:\misc\data') as myfile:
    for line in myfile:
        print(line)
        #...more code...

  Python中的文件对象包含会在with代码段后自动关闭文件对象的上下文管理器,所以即便 for 循环中抛出处理文件对象时的异常,也能保证 myfile 引用的对象被正常关闭。

  如果这段代码使用 try...finally...语句改写:

myfile = open(r'C:\misc\data')
try:
    for line in myfile:
        print(line)
        #...more code...
finally:
    myfile.close()

  可见使用 with 语句能够简化代码。

 

  多个上下文管理器被处理的方式就像多个 with 语句嵌套执行一样:

with A() as a, B() as b:
    suite

  等价于:

with A() as a:
    with B() as b:
        suite

  多个上下文管理器示例:

with open('data') as fin, open(''res', 'w') as fout:
    for line in fin:
        if 'some key' in line:
            fout.write(line)

  

二、上下文管理器类型
  context manager 是Python中 with 语句执行时用来定义运行时上下文的对象,上下文管理器控制着 进 / 出 运行时上下文的功能,上下文管理器通常由 with 语句触发,也可以直接通过调用他们的方法来使用他们。上下文管理器的通常用于保存和恢复各式各样的全局状态、加解锁资源和关闭打开的文件等等。  

  Python的 with 语句支持由上下文管理器定义的运行时上下文,由两个方法来实现,这两个方法允许用户在自定义的类中定义运行时上下文,执行流程在 with 语句开始前进入上下文,当 with 语句结束后退出。

上下文管理器必须提供一对方法:

  

 contextmanager.__enter__() 

  进入运行时上下文,要么返回该对象,要么返回一个与运行时上下文相关的对象,如果有 as 分句的话,with 语句将会把该方法的返回值和 as 分句指定的目标(别名)进行绑定。

  比如文件对象在__enter__()里返回自己,这样 open() 函数可以被当做环境表达式在一个 with 语句中使用。

  另一种情形中,decimal.localcontext()返回一个相关的对象。上下文管理器将活跃的小数上下文设置为初始小数上下文的拷贝,然后返回拷贝后的引用。这样可以在 with 语句中修改当前的小数上下文而不影响with 语句外的代码。
  
 contextmanager.__exit__(exc_type, exc_val, exc_tb) 
  
  退出运行时上下文,参数是 with 代码块中抛出的异常的详细信息,返回一个Bool型的标识符,该标识符说明上下文管理器能否处理异常:如果上下文管理器可以处理这个异常,__exit__() 应当返回一个true值来指示不需要传播这个异常;如果返回false,就会导致__exit__() 返回后重新抛出这个异常,如果上下文不是因为异常而退出,则三个参数都是 None
  该方法如果返回True ,说明上下文管理器可以处理异常,使得 with 语句终止异常传播,然后直接执行 with 语句后的语句;否则异常会在该方法调用结束后正常传播,该方法执行时发生的异常会替代所有其他在执行 with 代码块时出现的异常。
  在__exit__()中不需要显式重举传入的异常,只需要返回 false 表明 __exit__() 正常执行且传入的异常需要重举即可,重举传入__exit__()方法的异常是调用__exit__()的函数的工作。这种机制便于上下文管理器检测 __exit__() 方法是否真的执行失败。
  Python定义了若干上下文管理器,Python的 generator 类型和装饰器 contextlib.contextmanager 提供了实现上下文管理器协议的手段,如果一个生成器函数被装饰器 contextlib.contextmanager 所装饰,它将会返回一个实现了必要的 __enter__() 和 __exit__() 方法的上下文管理器,而不是普通的迭代器!

  Note that there is no specific slot for any of these methods in the type structure for Python objects in the Python/C API. Extension types wanting to define these methods must provide them as a normal Python accessible method. Compared to the overhead of setting up the runtime context, the overhead of a single class dictionary lookup is negligible.

   自定义上下文管理器示例:

class TraceBlock(object):

    def message(self, arg):
        print('running' + arg)

    def __enter__(self):
        print('starting with block')
        return self

    def __exit__(self, exc_type, exc_value, exc_tb):
        if exc_type is None:
            print('exited normally\n')
        else:
            print('raise an exception! ' + str(exc_type))
            return False #Propagate

if __name__ == '__main__':
    with TraceBlock() as action:
        action.message('test1')
        print('reached')

     with TraceBlock() as action:
        action.message('test2')
        raise TypeError
        print ('not reached')

  

三、contextlib模块

  采用“二、上下文管理器类型”中说明的传统方法即编写一个包含__enter__()和__exit__()方法的类来创建上下文管理器并不难。不过有些时候,对于很少的上下文来说,完全编写所有代码会是额外的负担。在这些情况下,可以使用装饰器 contextlib.contextmanager() 将一个生成器函数转换为上下文管理器。

  contextlib模块提供对 with 语句的支持:

 contextlib.contextmanager(func) 

  装饰器,用来装饰一个生成器函数,使其成为一个上下文管理器。通过该装饰器可以方便地定义上下文管理器,不必创建一个类或单独指定__enter__() 和 __exit__() 方法。

  示例

  (该例子不应该用于实际生成HTML!):

from contextlib import contextmanager

@contextmanager
def tag(name):
    print "<%s>" % name
    yield
    print "</%s>" % name

>>> with tag("h1"):
...    print "foo"
...
<h1>
foo
</h1>

  上下文管理器的 __enter__() 和 __exit__() 方法由 @contextmanager 负责提供,不再是之前的迭代子。被装饰的生成器函数只能产生一个值,否则会导致异常 RuntimeError;如果使用了 as 子句的话,产生的值会赋值给 as 子句中的 target。

  生成器函数中 yield 之前的语句在 __enter__() 方法中执行;yield 之后的语句在 __exit__() 中执行;yield 产生的值赋给 as 子句中的 variable 变量。

  生成器 yield 的地方,切换到执行 with 语句中的代码块(with-block),生成器在代码块退出后继续执行。

  如果 with 代码块中有未被处理的异常,它会被重举到生成器函数中的 yield 处,因此可以在生成器函数中使用 try...except...finally 语句来处理被重举的异常

  如果捕获异常的目标是记录日志或执行一些操作(而不是抑制它),生成器必须重举异常。否则生成器上下文管理器将会告知 with 语句说异常已经被处理了,但是一旦执行到 with 语句后的代码,异常会立即继续。

  需要注意的是,@contextmanager 只是省略了 __enter__() / __exit__() 的编写,实际意义是减少了代码量。

  但装饰器@contextmanager并不负责资源的“获取”和“清理”工作(需要开发者自己实现)。“获取”操作需要定义在 yield 语句之前,“清理”操作需要定义 yield 语句之后,这样 with 语句在执行 __enter__() / __exit__() 方法时会执行这些语句以获取/释放资源,即生成器函数中需要实现必要的逻辑控制,包括资源访问出现错误时抛出适当的异常。

   示例:

from contextlib import contextmanager
  
@contextmanager
def make_context() :
    print 'enter'
    try :
        yield {}
    except RuntimeError, err :
        print 'error' , err
    finally :
        print 'exit'
  
with make_context() as value :
    print value

  with-block中抛出的异常将被重举到生成器的 yield 处,在生成器中可以捕获该异常。

  

 

 

 contextlib.closing(thing) 

  返回一个上下文管理器,在完成代码块的执行时关闭参数 thing。等价于:

from contextlib import contextmanager

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()

  可以这么使用:

from contextlib import closing
import urllib

with closing(urllib.urlopen('http://www.python.org')) as page:
    for line in page:
        print line

  该例中,不用显式地关闭 page。即使发生错误,也会在 with 代码块退出时执行 page.close() 

posted @ 2015-01-01 10:47  王智愚  阅读(8814)  评论(0编辑  收藏  举报