Python With-As

深入理解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语句的理解到此结束。希望本文对你有用,如有用请推荐。

参考文献

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏向治洪

java虚拟机构造原理

 Java虚拟机的生命周期 一个运行中的Java虚拟机有着一个清晰的任务:执行Java程序。程序开始执行时他才运行,程序结束时他就停止。你在同一台机器上运行三...

2116
来自专栏爱撒谎的男孩

多线程的使用

1745
来自专栏奔跑的蛙牛技术博客

什么是字节码?

字节码(Byte-code)是一种包含执行程序,由一序列 op 代码/数据对组成的二进制文件,是一种中间码。字节是电脑里的数据量单位。

4813
来自专栏IT可乐

Spring详解(三)------DI依赖注入

  上一篇博客我们主要讲解了IOC控制反转,也就是说IOC 让程序员不在关注怎么去创建对象,而是关注与对象创建之后的操作,把对象的创建、初始化、销毁等工作交给s...

2105
来自专栏Ryan Miao

java并发编程读书笔记(1)-- 对象的共享

1. 一些原则 RIM(Remote Method Invocation):远程方法调用 Race Condition:竞态条件 Servlet要满足多个线程的...

3628
来自专栏博岩Java大讲堂

多线程--同步与锁

2463
来自专栏java一日一条

Java反射在JVM的实现

反射使程序代码能够接入装载到JVM中的类的内部信息,允许在编写与执行时,而不是源代码中选定的类协作的代码,是以开发效率换运行效率的一种手段。这使反射成为构建灵活...

2243
来自专栏青玉伏案

iOS开发之Runtime常用示例总结

经常有小伙伴私下在Q上问一些关于Runtime的东西,问我有没有Runtime的相关博客,之前还真没正儿八经的总结过。之前只是在解析第三方框架源码时,聊过一些用...

2059
来自专栏C/C++基础

段错误之memset对类对象的误用

使用new定义一个DICCUOriginalTask的对象指针之后,使用memset将对象实体置为0之后,在使用delete析构该对象,就会出现莫名其妙的段错误...

1131
来自专栏大闲人柴毛毛

深入JVM——OOM异常解析

JVM对象访问解析 对象访问过程的内存情况 public void function(){ Object obj = new Object(); } f...

41511

扫码关注云+社区

领取腾讯云代金券