python~with

With基本语法

（0）要说With语法，首先讲一讲 上下文管理器

举个例子，你在写Python代码的时候经常将一系列操作放在一个语句块中：

当某条件为真 – 执行这个语句块；当某条件为真 – 循环执行这个语句块；有时候我们需要在当程序在语句块中运行时保持某种状态，并且在离开语句块后结束这种状态。

所以，事实上上下文管理器的任务是 – 代码块执行前准备，代码块执行后收拾。

看代码是最好的学习方式，来看看我们通常是如何打开一个文件并写入”Hello World”？

[plain]  view plain  copy

 

1. filename = 'my_file.txt'  
2. mode = 'w' # Mode that allows to write to the file  
3. writer = open(filename, mode)  
4. writer.write('Hello ')  
5. writer.write('World')  
6. writer.close()  

1-2行，我们指明文件名以及打开方式(写入)。

第3行，打开文件，4-5行写入“Hello world”，第6行关闭文件。

这样不就行了，为什么还需要上下文管理器？但是我们忽略了一个很小但是很重要的细节：如果我们没有机会到达第6行关闭文件，那会怎样？

举个例子，磁盘已满，因此我们在第4行尝试写入文件时就会抛出异常，而第6行则根本没有机会执行。

当然，我们可以使用try-finally语句块来进行包装：

[plain]  view plain  copy

 

1. writer = open(filename, mode)  
2. try:  
3.     writer.write('Hello ')  
4.     writer.write('World')  
5. finally:  
6.     writer.close()  

finally语句块中的代码无论try语句块中发生了什么都会执行。因此可以保证文件一定会关闭。这么做有什么问题么？当然没有，但当我们进行一些比写入“Hello world”更复杂的

事情时，try-finally语句就会变得丑陋无比。例如我们要打开两个文件，一个读一个写，两个文件之间进行拷贝操作，那么通过with语句能够保证两者能够同时被关闭。

（1）with 语句的语法格式如下：

[plain]  view plain  copy

 

1. with context_expression [as target(s)]:  
2.        with-body  

这里 context_expression 要返回一个上下文管理器对象，该对象并不赋值给 as 子句中的 target(s) ，如果指定了 as 子句的话，会将上下文管理器的 __enter__() 方法的返

回值赋值给 target(s)。target(s) 可以是单个变量，或者由“()”括起来的元组（不能是仅仅由“,”分隔的变量列表，必须加“()”）。

（2）Python 对一些内建对象进行改进，加入了对上下文管理器的支持，可以用于 with 语句中，比如可以自动关闭文件、线程锁的自动获取和释放等。假设要对一个文件进行

操作，使用 with 语句可以有如下代码：使用 with 语句操作文件对象 

[plain]  view plain  copy

 

1. with open(r'somefileName') as somefile:  
2.         for line in somefile:  
3.             print line  
4.             # ...more code  

这里使用了 with 语句，不管在处理文件过程中是否发生异常，都能保证 with 语句执行完毕后已经关闭了打开的文件句柄。

（3）如果使用传统的 try/finally 范式，则要使用类似如下代码：(用于和with的对比)

[plain]  view plain  copy

 

1. somefile = open(r'somefileName')  
2.     try:  
3.         for line in somefile:  
4.             print line  
5.             # ...more code  
6.     finally:  
7.         somefile.close()  

比较起来，使用 with 语句可以减少编码量。已经加入对上下文管理协议支持的还有模块 threading、decimal 等。

三：实例说明

（1）with 语句的执行过程类似如下代码块：

[plain]  view plain  copy

 

1. context_manager = context_expression  
2. exit = type(context_manager).__exit__    
3. value = type(context_manager).__enter__(context_manager)  
4. exc = True   # True 表示正常执行，即便有异常也忽略；False 表示重新抛出异常，需要对异常进行处理  
5. try:  
6.     try:  
7.         target = value  # 如果使用了 as 子句  
8.         with-body     # 执行 with-body  
9.     except:  
10.         # 执行过程中有异常发生  
11.         exc = False  
12.         # 如果 __exit__ 返回 True，则异常被忽略；如果返回 False，则重新抛出异常  
13.         # 由外层代码对异常进行处理  
14.         if not exit(context_manager, *sys.exc_info()):  
15.             raise  
16. finally:  
17.     # 正常退出，或者通过 statement-body 中的 break/continue/return 语句退出  
18.     # 或者忽略异常退出  
19.     if exc:  
20.         exit(context_manager, None, None, None)   
21.     # 缺省返回 None，None 在布尔上下文中看做是 False  

执行 context_expression，生成上下文管理器 context_manager

调用上下文管理器的 __enter__() 方法；如果使用了 as 子句，则将 __enter__() 方法的返回值赋值给 as 子句中的 target(s)

执行语句体 with-body

不管是否执行过程中是否发生了异常，执行上下文管理器的 __exit__() 方法，__exit__() 方法负责执行“清理”工作，如释放资源等。如果执行过程中没有出现异常，或者语句体中执行了语句 break/continue/return，则以 None 作为参数调用 __exit__(None, None, None) ；如果执行过程中出现异常，则使用 sys.exc_info 得到的异常信息为参数调用 __exit__(exc_type, exc_value, exc_traceback)

出现异常时，如果 __exit__(type, value, traceback) 返回 False，则会重新抛出异常，让with 之外的语句逻辑来处理异常，这也是通用做法；如果返回 True，则忽略异常，不再对异常进行处理

（2）另外python库中还有一个模块contextlib，使你不用构造含有__enter__, __exit__的类就可以使用with：（更加实用了）

[plain]  view plain  copy

 

1. >>> from contextlib import contextmanager  
2. >>> from __future__ import with_statement  
3. >>> @contextmanager  
4. ... def context():  
5. ...     print 'entering the zone'  
6. ...     try:  
7. ...         yield  
8. ...     except Exception, e:  
9. ...         print 'with an error %s'%e  
10. ...         raise e  
11. ...     else:  
12. ...         print 'with no error'  
13. ...  
14. >>> with context():  
15. ...     print '----in context call------'  
16. ...  
17. entering the zone  
18. ----in context call------  
19. with no error  

（3）@property 可以将python定义的函数“当做”属性访问，从而提供更加友好访问方式，但是有时候setter/getter也是需要的

[plain]  view plain  copy

 

1. class Parrot:  
2.     def __init__(self):  
3.         self._voltage = 100000  
4.   
5.     @property  
6.     def voltage(self):  
7.         """Get the current voltage."""  
8.         return self._voltage  
9.   
10. if __name__ == "__main__":  
11.     # instance  
12.     p = Parrot()  
13.     # similarly invoke "getter" via @property  
14.     print p.voltage  
15.     # update, similarly invoke "setter"  
16.     p.voltage = 12