概述

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

With-as 用法

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

1
2
3
4
5
6
7
try:
    f = file.open('test.txt','rw')
    To Do
except:
    To Do
finally:
    f.close()

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
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的用法:

1
2
3
4
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语句的。例如:

1
2
3
4
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 语句调用上下文管理器,也可以通过直接调用其方法来使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
    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() 失败来捕获和处理异常。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#-*- 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......")

代码运行效果如下:

1
2
3
4
5
6
Go into __enter__()  
insert into......  
delete from......  
Go into __exit__()  
Exited Without Exception  
Commits current transaction  

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#!/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包裹的代码块中造成一个异常。我们来看一下效果:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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也能捕捉到。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/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()

运行效果如下:

1
2
3
4
5
6
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后面的变量。看一下例子:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#!/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()

运行结果如下:

1
2
3
4
5
6
7
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也获得了一个线程锁,让当前操作不被其他线程干扰。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/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() 来执行所需要的资源“清理”工作。当然上述的这些操作你完全可以按照自己的逻辑去执行。请看如下代码:

1
2
3
4
5
6
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语句的理解到此结束。希望本文对你有用,如有用请打赏一下。

参考文献