Python中with...as用法

使用语言的好特性,而不是那些糟糕的特性————不知道谁说的

好久不学习python的语法了,上次去面试,和面试官聊到了python中的with-as statement(也称context manager),挺感兴趣的,这两天学习了一番,收获颇丰在此分享。

先说明一个常见问题,文件打开:

[python] view plain copy
  1. try:  
  2.     f = open('xxx')  
  3.     do something  
  4. except:  
  5.     do something  
  6. finally:  
  7.     f.close()  

其实我个人不止一次在网上看到有这么写的了,这个是错的。
首先正确的如下:

[python] view plain copy
  1. try:  
  2.     f = open('xxx')  
  3. except:  
  4.     print 'fail to open'  
  5.     exit(-1)  
  6. try:  
  7.     do something  
  8. except:  
  9.     do something  
  10. finally:  
  11.     f.close()  

很麻烦不是么,但正确的方法就是这么写。
我们为什么要写finally,是因为防止程序抛出异常最后不能关闭文件,但是需要关闭文件有一个前提就是文件已经打开了。
在第一段错误代码中,如果异常发生在f=open(‘xxx’)的时候,比如文件不存在,立马就可以知道执行f.close()是没有意义的,具体示例如下:

[python] view plain copy
  1. try:  
  2.     f=open(r'C:\Users\91135\Desktop\wahaha.txt','r')#假设文件wahaha.txt不存在  
  3.     print f.readlines()  
  4. except IOError,error:  
  5.     print error  
  6. finally:  
  7.     f.close()  
执行上述代码,结果如下:

Traceback (most recent call last):
  File "E:\workspace\python day03\main\test.py", line 10, in <module>
    f.close()
NameError: name 'f' is not defined
[Errno 2] No such file or directory: 'C:\\Users\\91135\\Desktop\\wahaha.txt'

改正后的解决方案就是第二段代码,具体示例如下:

[python] view plain copy
  1. try:  
  2.     f=open(r'C:\Users\91135\Desktop\wahaha.txt','r')#假设文件wahaha.txt不存在  
  3. except:  
  4.     print 'fail to open the file!'  
  5.     exit()#当文件打开失败时,退出程序!  
  6. try:  
  7.     print f.readlines()  
  8. except:  
  9.     print 'fail to read the file!'  
  10. finally:  
  11.     f.close()  
运行结果如下:

fail to open the file!

好了言归正转,开始讨论with语法。

首先我们从下面这个问题谈起,try-finally的语法结构:

[python] view plain copy
  1. set things up  
  2. try:  
  3.     do something  
  4. finally:  
  5.     tear things down  

这东西是个常见结构,比如文件打开,set things up就表示f=open('xxx')tear things down就表示f.close()。在比如像多线程锁,资源请求,最终都有一个释放的需求。Try…finally结构保证了tear things down这一段永远都会执行,即使上面do something得工作没有完全执行。

如果经常用这种结构,我们首先可以采取一个较为优雅的办法,封装!

[python] view plain copy
  1. def controlled_execution(callback):  
  2.     set things up  
  3.     try:  
  4.         callback(thing)  
  5.     finally:  
  6.         tear things down  
  7.    
  8. def my_function(thing):  
  9.     do something  
  10.    
  11. controlled_execution(my_function)  

封装是一个支持代码重用的好办法,但是这个办法很dirty,特别是当do something中有修改一些local variables的时候(变成函数调用,少不了带来变量作用域上的麻烦)。

另一个办法是使用生成器,但是只需要生成一次数据,我们用for-in结构去调用他:

[python] view plain copy
  1. def controlled_execution():  
  2.     set things up  
  3.     try:  
  4.         yield thing  
  5.     finally:  
  6.         tear things down  
  7.            
  8. for thing in controlled_execution():  
  9.     do something with thing  

因为thing只有一个,所以yield语句只需要执行一次。当然,从代码可读性也就是优雅的角度来说这简直是糟糕透了。我们在确定for循环只执行一次的情况下依然使用了for循环,这代码给不知道的人看一定很难理解这里的循环是什么个道理。

最终的python-dev团队的解决方案。(python 2.5以后增加了with表达式的语法)

[python] view plain copy
  1. class controlled_execution:  
  2.     def __enter__(self):  
  3.         set things up  
  4.         return thing  
  5.     def __exit__(self, type, value, traceback):  
  6.         tear things down  
  7.            
  8. with controlled_execution() as thing:  
  9.         do something  

在这里,python使用了with-as的语法。当python执行这一句时,会调用__enter__函数,然后把该函数return的值传给as后指定的变量。之后,python会执行下面do something的语句块。最后不论在该语句块出现了什么异常,都会在离开时执行__exit__。
另外,__exit__除了用于tear things down,还可以进行异常的监控和处理,注意后几个参数。要跳过一个异常,只需要返回该函数True即可。下面的样例代码跳过了所有的TypeError,而让其他异常正常抛出。

[python] view plain copy
  1. def __exit__(self, type, value, traceback):  
  2.     return isinstance(value, TypeError)  

在python2.5及以后,file对象已经写好了__enter__和__exit__函数,我们可以这样测试:

[python] view plain copy
  1. >>> f = open("x.txt")  
  2. >>> f  
  3. <open file 'x.txt', mode 'r' at 0x00AE82F0>  
  4. >>> f.__enter__()  
  5. <open file 'x.txt', mode 'r' at 0x00AE82F0>  
  6. >>> f.read(1)  
  7. 'X'  
  8. >>> f.__exit__(NoneNoneNone)  
  9. >>> f.read(1)  
  10. Traceback (most recent call last):  
  11.     File "<stdin>", line 1in <module>  
  12. ValueError: I/O operation on closed file  

之后,我们如果要打开文件并保证最后关闭他,只需要这么做:

[python] view plain copy
  1. with open("x.txt") as f:  
  2.     data = f.read()  
  3.     do something with data  
如果有多个项,我们可以这么写:

[python] view plain copy
  1. with open("x.txt") as f1, open('xxx.txt') as f2:  
  2.     do something with f1,f2  
上文说了__exit__函数可以进行部分异常的处理,如果我们不在这个函数中处理异常,他会正常抛出,这时候我们可以这样写(python 2.7及以上版本,之前的版本参考使用contextlib.nested这个库函数):

[python] view plain copy
  1. try:  
  2.     with open( "a.txt" ) as f :  
  3.         do something  
  4. except xxxError:  
  5.     do something about exception  
阅读更多
换一批

没有更多推荐了,返回首页