深入理解Python的With-as语句

学习Python有一段时间了，最近做一个项目会涉及到文件的读取和关闭。比如：我想把一些对象序列化到文件里面，然后当我再次使用的时候，在从文件里面读取反序列化成对象。像这种操作一般都是用try…except…finally。但是经过自己对Python的研究发现会有更出色的方法，比如：with-as语句也有的人称为context manager。

With-as 用法

我们先看一下例子，当我们需要打开一个文件的时，比如：txt等，一般经常会这么操作：

try:
    f = file.open('test.txt','rw')
    To Do
except:
    To Do
finally:
    f.close()

这是错误，因为file.open是否打开文件是不确定，而在出现异常的时候你却关闭了已经打开的文件。文件没有打开怎么能直接关闭呢？你可以按照下面的解决方法来解决上述出现的问题。

try:  
    f = file.open('test.txt','rw')
    To Do
except:  
    To Do
    //出现异常直接返回或者退出，这说明file并没有打开。
    return/exit(-1) 

//已经成功打开file文件，所以你需要在finally中关闭打开的文件。
try:  
    To Do
except:  
    To Do
finally:  
    f.close()

你会发现这么做会非常麻烦，并且try……except…..finally嵌套也比较啰嗦。那有没有好的解决办法能解决上述问题，并且还能减少代码量呢？(类似于C#中的using关键字)答案是肯定的，那就是with……as语句。With语句适用于对I/O、文件流、数据流等资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源.比如文件使用后自动关闭、线程中锁的自动获取和释放等等。 我们来看一下with-as的用法：

with open('/etc/passwd', 'r') as f:  
    for line in f:
        print line
        ... more processing code ...

这个语句执行完成之后，不管在处理文件过程中是否发生异常，都能保证 with 语句执行完毕后已经关闭了打开的文件句柄,确实比try……except……finally好多了。在这个例子中f就是上下文管理器enter()的返回值，返回的是当前文件自身的引用。Python内建对象都加入了对上下文管理器的支持，可以用在with语句中。比如:file、 threading、decimal等等，在多线程模块中，lock和条件变量也是支持with语句的。例如：

lock = threading.Lock()  
with lock:  
    # Critical section of code
    ...

在代码执行之前lock总是先获得，只要block代码完成lock就会被释放。要想彻底了解Python的With-As语句，请继续往下看。

Python术语

Context Management Protocol(上下文管理协议):包含方法__enter()__和__exit()__，支持该协议的对象要实现这两个方法。上下文管理器（Context Manager）：支持上下文管理协议的对象，这种对象实现了__enter()__ 和__exit()__ 方法。上下文管理器定义执行 with 语句时要建立的运行时上下文，负责执行 with 语句块上下文中的进入与退出操作。通常使用 with 语句调用上下文管理器，也可以通过直接调用其方法来使用。

context_manager = context_expression  
exit = type(context_manager).__exit__  
value = type(context_manager).__enter__(context_manager)
# True 表示正常执行，即便有异常也忽略；False 表示重新抛出异常，需要对异常进行处理.
exc = True  

try:
    target = value  # 如果使用了 as 子句
    with-body     # 执行 with-body
except:
    # 执行过程中有异常发生
    exc = False
    # 如果 __exit__ 返回 True，则异常被忽略；如果返回 False，则重新抛出异常
    # 由外层代码对异常进行处理
    if not exit(context_manager, *sys.exc_info()):
        raise
finally:
    # 正常退出，或者通过 statement-body 中的 break/continue/return 语句退出
    # 或者忽略异常退出
    if exc:
        exit(context_manager, None, None, None) 
    # 缺省返回 None，None 在布尔上下文中看做是 False

上下文管理协议

with表达式执行生成一个叫做上下文管理器的对象，上下文管理器必须包含enter()和exit()方法，并且要实现该两个方法。 上下文管理器的enter()方法被调用，返回值将赋值给var，如果没有as var，则返回值被丢弃。 执行With-Body语句体。 不管是否执行过程中是否发生了异常，执行上下文管理器的 exit() 方法，exit() 方法负责执行“clean-up”工作，如释放资源等。如果执行过程中没有出现异常，或者语句体中执行了语句( break/continue/return)，则以 None 作为参数调用 exit(None, None, None) ；如果执行过程中出现异常，则使用 sys.excinfo 得到的异常信息为参数调用 exit(exctype, excvalue, exctraceback),通常返回值是一个tuple, (type, value/message, traceback)。 出现异常时，如果 exit(type, value, traceback) 返回 False，则会重新抛出异常，让with 之外的语句逻辑来处理异常，这也是通用做法；如果返回 True，则忽略异常，不再对异常进行处理。 运行时上下文（runtime context）：通过上下文管理器创建，并由上下文管理器的 enter() 和exit() 方法实现，enter() 方法在语句体执行之前进入运行时上下文，exit() 在语句体执行完后从运行时上下文退出。返回一个布尔值表示是否对发生的异常进行处理。如果退出时没有发生异常，则3个参数都为(None,None,None)。如果发生异常，返回True :不处理异常，否则会在退出该方法后重新抛出异常以由 with 语句之外的代码进行处理。如果该方法内部产生异常,不能重新抛出通过参数传递进来的异常，只需要return False 就可以。之后，上下文管理代码会检测是否 exit() 失败来捕获和处理异常。

#-*- coding: utf-8 -*-

class Cursor(object):  
    def execute(self,msg):
        print msg

class DatabaseConnection(object):  
    def commit(self):
        print "Commits current transaction"
    def rollback(self):
        print "Rolls back current transaction"
    def __enter__(self):
        print "Go into __enter__()"
        cursor = Cursor()
        return cursor
    def __exit__(self,exc_type,exc_value,exc_tb):
        print "Go into __exit__()"
        #raise Exception("__exit__......Exception")
        if exc_tb is None:
            #如果没有异常，则提交事务
            print "Exited Without Exception"
            self.commit()
        else:
            #如果有异常，则回滚
            print "Exited with exception raised"
            print "type:[",exc_type,"],value:[",exc_value,"],exc_tb:[",exc_tb,"]"
            self.rollback()

if __name__=="__main__":  
    db_connection = DatabaseConnection()
    with db_connection as cursor:
        cursor.execute("insert into......")
        cursor.execute("delete from......")

代码运行效果如下：

Go into __enter__()  
insert into......  
delete from......  
Go into __exit__()  
Exited Without Exception  
Commits current transaction

上述代码正好验证了我们之前的分析，当运行with dbconnection运行时，进入我们自定义的__enter()__方法，当执行完with包裹的代码块时，就会进入__exit()__方法，如果没有异常(通过exctb是否为None来判断，当然也可以用其他两个参数判断。)则执行相应的代码逻辑。

#!/usr/bin/env python
#-*- coding: utf-8 -*-

class Cursor(object):  
    def execute(self,msg):
        print msg

class DatabaseConnection(object):  
    def commit(self):
        print "Commits current transaction"
    def rollback(self):
        print "Rolls back current transaction"
    def __enter__(self):
        print "Go into __enter__()"
        cursor = Cursor()
        return cursor
    def __exit__(self,exc_type,exc_value,exc_tb):
        print "Go into __exit__()"
        #raise Exception("__exit__......Exception")
        if exc_tb is None:
            #如果没有异常，则提交事务
            print "Exited Without Exception"
            self.commit()
        else:
            #如果有异常，则回滚
            print "Exited With Exception raised"
            print "type:[",exc_type,"],value:[",exc_value,"],exc_tb:[",exc_tb,"]"
            self.rollback()

if __name__=="__main__":  
    db_connection = DatabaseConnection()
    with db_connection as cursor:
        cursor.execute("insert into......")
        raise Exception("raise exception")
        cursor.execute("delete from......")

该代码示例中，我在with包裹的代码块中造成一个异常。我们来看一下效果：

Go into __enter__()  
insert into......  
Go into __exit__()  
Exited With Exception raised  
type:[ <type 'exceptions.Exception'> ],value:[ raise exception ],exc_tb:[ <traceback object at 0x0252A878> ]  
Rolls back current transaction  
Traceback (most recent call last):  
  File "D:\Test\DatabaseConnection.py", line 34, in <module>
    raise Exception("raise exception")
Exception: raise exception

当with包裹的代码块一旦出现异常，则进入exit()方法内，并根据该方法的参数全不为None。如果你在exit方法内你不手动返回一个值的话，则默认返回False。如果你返回True,则不会捕捉该异常，即使你在with代码块最外面包裹一个try……except…finally也不会捕捉到该异常，如果返回False则with之外的try–except也能捕捉到。

#!/usr/bin/env python
#-*- coding: utf-8 -*-

import sys

class Cursor(object):  
    def execute(self,msg):
        print msg

class DatabaseConnection(object):  
    def commit(self):
        print "Commits current transaction"
    def rollback(self):
        print "Rolls back current transaction"
    def __enter__(self):
        print "Go into __enter__()"
        cursor = Cursor()
        return cursor
    def __exit__(self,exc_type,exc_value,exc_tb):
        print "Go into __exit__()"
        #raise Exception("__exit__......Exception")
        if exc_tb is None:
            #如果没有异常，则提交事务
            print "Exited Without Exception"
            self.commit()
        else:
            #如果有异常，则回滚
            print "Exited With Exception raised"
            print "type:[",exc_type,"],value:[",exc_value,"],exc_tb:[",exc_tb,"]"
            self.rollback()
        return True

if __name__=="__main__":  
    db_connection = DatabaseConnection()
    try:
        with db_connection as cursor:
            cursor.execute("insert into......")
            raise Exception("raise exception")
            cursor.execute("delete from......")
    except:
        print"包裹with语句的try ",sys.exc_info()

运行效果如下：

Go into __enter__()  
insert into......  
Go into __exit__()  
Exited With Exception raised  
type:[ <type 'exceptions.Exception'> ],value:[ raise exception ],exc_tb:[ <traceback object at 0x0252A878> ]  
Rolls back current transaction

基本上Python的常用的用法我就了解这么多，至于代码希望你动手试一下你也能了解Python with语句的原理.

The contextlib module

contextlib模块支持一些函数和装饰器，比如：装饰器 contextmanager、函数 nested 和上下文管理器closing。使用这些对象，可以对已有的生成器(yield)函数或者对象进行包装，加入对上下文管理协议的支持，这样可以避免专门编写上下文管理器来支持 with 语句。

contextmanager

contextmanager 用于对生成器(yield)函数进行装饰，生成器(yield)函数被装饰以后，返回的是一个ContextManager(上下文管理器)，其 __enter()__ 和 __exit()__ 方法由 contextmanager 负责提供，而不是之前通过一个上下文管理器重写这两个方法了。被装饰的函数只能产生一个值，否则会导致异常 RuntimeError；并且会把yield的值赋值给as后面的变量。看一下例子：

#!/usr/bin/env python
#-*- coding: utf-8 -*-

import sys  
from contextlib import contextmanager

class Cursor(object):  
    def execute(self,msg):
        print msg

class DatabaseConnection(object):  
    def cursor(self):
        print "Create a instance of Cursor"
        return Cursor()
    def commit(self):
        print "Commits current transaction"
    def rollback(self):
        print "Rolls back current transaction"


@contextmanager
def db_transaction(connection):  
    cursor = connection.cursor()
    try:
        print "yeild 执行之前......"
        yield cursor
        print "yeild 执行之后......"
    except:
        print "db_transaction raise exception"
        connection.rollback()
    else:
        print"Existed without exception"
        connection.commit()

if __name__=="__main__":  
    db_connection = DatabaseConnection()
    try:
        with db_transaction(db_connection) as cursor:
            cursor.execute("insert into......")
            #raise Exception("raise exception")
            cursor.execute("delete from......")
    except:
        print sys.exc_info()

运行结果如下：

Create a instance of Cursor  
yeild 执行之前......  
insert into......  
delete from......  
yeild 执行之后......  
Existed without exception  
Commits current transaction

通过上述运行结果，可以看出，生成器函数中 yield 之前的语句在 enter() 方法中执行，yield 之后的语句在__exit()__ 中执行，而 yield 产生的值赋给了 as 后面的 变量。这个contextmanager修饰器 只是省略了 __enter()__ / __exit()__ 的编写，但并不负责实现“获取资源”和“清理资源”工作；“获取资源”操作需要定义在 yield 语句之前，“清理资源”操作需要定义 yield 语句之后，这样 with 语句在执行__enter()__ / __exit()__ 方法时会执行这些语句以获取/释放资源，即生成器函数中需要实现必要的逻辑控制，包括资源访问出现错误时抛出适当的异常。 nested(mgr1, mgr2, …)() contextlib模块也有个nested(mgr1, mgr2, …)()函数，这个函数可以作用在多个上下文管理器。例如下面的例子with 语句不仅开启一个transaction也获得了一个线程锁，让当前操作不被其他线程干扰。

#!/usr/bin/env python
#-*- coding: utf-8 -*-

import sys  
from contextlib import contextmanager,nested,closing  
import threading

class Cursor(object):  
    def execute(self,msg):
        print msg

class DatabaseConnection(object):  
    def cursor(self):
        print "Create a instance of Cursor"
        return Cursor()
    def commit(self):
        print "Commits current transaction"
    def rollback(self):
        print "Rolls back current transaction"


@contextmanager
def db_transaction(connection):  
    cursor = connection.cursor()
    try:
        print "yeild 执行之前......"
        yield cursor
        print "yeild 执行之后......"
    except:
        print "db_transaction raise exception"
        connection.rollback()
    else:
        print"Existed without exception"
        connection.commit()

if __name__=="__main__":  
    db_connection = DatabaseConnection()
    lock = threading.Lock()
    with nested(db_transaction(db_connection),lock) as (cursor,locked):
        cursor.execute("insert into......")
        cursor.execute("delete from......")
运行结果如下：

Create a instance of Cursor  
yeild 执行之前......  
insert into......  
delete from......  
yeild 执行之后......  
Existed without exception  
Commits current transaction

closing(object)()方法返回一个对象可以绑定到as后面的变量，保证了打开的对象在 with-body(with包裹的代码) 执行完后会关闭掉。closing 上下文管理器包装起来的对象必须提供 close() 方法的定义，否则执行时会报错误。closing 适用于提供了 close() 实现的对象，比如：网络连接、数据库连接有非常的用武之地，也可以在自定义类时通过接口 close() 来执行所需要的资源“清理”工作。当然上述的这些操作你完全可以按照自己的逻辑去执行。请看如下代码：

import urllib, sys  
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:  
    for line in f:
        sys.stdout.write(line)

基本上python的With语句的理解到此结束。希望本文对你有用，如有用请推荐。

参考文献

 

• 浅谈 Python 的 with 语句 这篇文章写得不错，里面的术语解释的很到位，本文中用到的术语多来源于这篇文章。
• Python 2.6 官方介绍言简意赅突出主题，文中的例子来源于这篇文章。自己把它实现了啊。
• 理解Python中的with…as…语法可以参考一下，这篇文章作者介绍的还可以，但是没有给出更全面的介绍没有第一个文章中术语介绍的详细。
• 理解Python的with语句只是一般介绍没有深入。

原文来源：https://cloud.tencent.com/developer/article/1083148