先说明一个常见问题，文件打开：
try: f =open('xxx')dosomethingexcept:dosomethingfinally: f.close()
1
2
3
4
5
6
7
1
2
3
4
5
6
7
其实不止一次在网上看到有这么写的了，这个是错的。
首先正确的如下：
try: f = open('xxx')except: print'fail to open'exit(-1)try:dosomethingexcept:dosomethingfinally: f.close()
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
很麻烦不是么，但正确的方法就是这么写。
我们为什么要写finally，是因为防止程序抛出异常最后不能关闭文件，但是需要关闭文件有一个前提就是文件已经打开了。
在第一段错误代码中，如果异常发生在f=open(‘xxx’)的时候，比如文件不存在，立马就可以知道执行f.close()是没有意义的。改正后的解决方案就是第二段代码。
好了言归正转，开始讨论with语法。
首先我们从下面这个问题谈起，try-finally的语法结构：
setthings uptry:dosomethingfinally: tear things down
1
2
3
4
5
1
2
3
4
5
这东西是个常见结构，比如文件打开，set things up就表示f=open(‘xxx’)，tear things
down就表示f.close()。在比如像多线程锁，资源请求，最终都有一个释放的需求。Try…finally结构保证了tear things
down这一段永远都会执行，即使上面do something得工作没有完全执行。
如果经常用这种结构，我们首先可以采取一个较为优雅的办法，封装！
defcontrolled_execution(callback):set things uptry: callback(thing)finally: tear things downdefmy_function(thing):do somethingcontrolled_execution(my_function)
1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
封装是一个支持代码重用的好办法，但是这个办法很dirty，特别是当do something中有修改一些local variables的时候（变成函数调用，少不了带来变量作用域上的麻烦）。
另一个办法是使用生成器，但是只需要生成一次数据，我们用for-in结构去调用他：
defcontrolled_execution():set things uptry:yieldthingfinally: tear things downforthingincontrolled_execution(): do somethingwiththing
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
因为thing只有一个，所以yield语句只需要执行一次。当然，从代码可读性也就是优雅的角度来说这简直是糟糕透了。我们在确定for循环只执行一次的情况下依然使用了for循环，这代码给不知道的人看一定很难理解这里的循环是什么个道理。
最终的Python-dev团队的解决方案。（python2.5以后增加了with表达式的语法）
classcontrolled_execution:def__enter__(self):set things upreturnthingdef__exit__(self, type, value, traceback):tear things downwithcontrolled_execution()asthing: do something
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
在这里，python使用了with-as的语法。当python执行这一句时，会调用__enter__函数，然后把该函数return的值传给as后指定的变量。之后，python会执行下面do something的语句块。最后不论在该语句块出现了什么异常，都会在离开时执行__exit__。
另外，__exit__除了用于tear things down，还可以进行异常的监控和处理，注意后几个参数。要跳过一个异常，只需要返回该函数True即可。下面的样例代码跳过了所有的TypeError，而让其他异常正常抛出。
def__exit__(self, type, value, traceback):returnisinstance(value, TypeError)
1
2
1
2
在python2.5及以后，file对象已经写好了enter和exit函数，我们可以这样测试：
>>> f =open("x.txt")>>> f>>> f.__enter__()>>> f.read(1)'X'>>> f.__exit__(None, None, None)>>> f.read(1)Traceback (most recent calllast): File"",line1,inValueError: I/O operationonclosedfile
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
之后，我们如果要打开文件并保证最后关闭他，只需要这么做：
withopen("x.txt")asf:data= f.read()dosomething withdata
1
2
3
1
2
3
如果有多个项，我们可以这么写：
withopen("x.txt")asf1,open('xxx.txt')asf2:dosomethingwithf1,f2
1
2
1
2
上文说了__exit__函数可以进行部分异常的处理，如果我们不在这个函数中处理异常，他会正常抛出，这时候我们可以这样写（python 2.7及以上版本，之前的版本参考使用contextlib.nested这个库函数）：
try:withopen("a.txt")asf :dosomethingexcept xxxError:dosomething aboutexception
1
2
3
4
5
1
2
3
4
5
总之，with-as表达式极大的简化了每次写finally的工作，这对保持代码的优雅性是有极大帮助的。
with-block等价于
try: 执行 __enter__的内容 执行 with_block.finally: 执行 __exit__内容
