python with语句详解

Python’s with statement provides a very convenient way of dealing with the situation where you have to do a setup and teardown to make something happen.
 A very good example for this is the situation where you want to gain a handler to a file, read data from the file and the close the file handler.
有一些任务，可能事先需要设置，事后做清理工作。对于这种场景，Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理，你需要获取一个文件句柄，从文件中读取数据，
然后关闭文件句柄。
Without the with statement, one would write something along the lines of:
如果不用with语句，代码如下：

file = open("/tmp/foo.txt")
data = file.read()
file.close()

 While this works well, it is unnecessarily verbose. This is where with is useful. The good thing about with apart from the better syntax is that it is very good handling exceptions. The above code would look like this, when using with: 虽然这段代码运行良好，但是太冗长了。这时候就是with一展身手的时候了。除了有更优雅的语法，with还可以很好的处理上下文环境产生的异常。下面是with版本的代码：

with open("/tmp/foo.txt")
 as file:
    data = file.read()

 with如何工作？

while this might look like magic, the way Python handles with is more clever than magic. The basic idea is that the statement after with has to evaluate an object that responds to an __enter__() as well as an __exit__() function.

这看起来充满魔法，但不仅仅是魔法，Python对with的处理还很聪明。基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。 After the statement that follows with is evaluated, the __enter__() function on the resulting object is called. The value returned by this function is assigned to the variable following as. After every statement in the block is evaluated, the __exit__() function is called.

紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。 This can be demonstrated with the following example: 下面例子可以具体说明with如何工作：

#!/usr/bin/env
 python
#
 with_example01.py
 
 
class Sample:
    def __enter__(self):
        print "In
 __enter__()"
        return "Foo"
 
    def __exit__(self, type,
 value, trace):
        print "In
 __exit__()"
 
 
def get_sample():
    return Sample()
 
 
with
 get_sample() as sample:
    print "sample:",
 sample

结果如下：

bash-3.2$
 ./with_example01.py
In
 __enter__()
sample:
 Foo
In
 __exit__()

 As you can see, The __enter__() function is executed The value returned by it - in this case "Foo" is assigned to sample The body of the block is executed, thereby printing the value of sample ie. "Foo" The __exit__() function is called. What makes with really powerful is the fact that it can handle exceptions. You would have noticed that the __exit__() function for Sample takes three arguments - val, type and trace. These are useful in exception handling. Let’s see how this works by modifying the above example.

正如你看到的， 1. __enter__()方法被执行

2. __enter__()方法返回的值 - 这个例子中是"Foo"，赋值给变量'sample'

3. 执行代码块，打印变量"sample"的值为 "Foo"

4. __exit__()方法被调用 with真正强大之处是它可以处理异常。可能你已经注意到Sample类的__exit__方法有三个参数- val, type 和 trace。 这些参数在异常处理中相当有用。我们来改一下代码，看看具体如何工作的。

#!/usr/bin/env
 python
#
 with_example02.py
 
 
class Sample:
    def __enter__(self):
        return self
 
    def __exit__(self, type,
 value, trace):
        print "type:", type
        print "value:",
 value
        print "trace:",
 trace
 
    def do_something(self):
        bar = 1/0
        return bar + 10
 
with
 Sample() as sample:
    sample.do_something()

 Notice how in this example, instead of get_sample(), with takes Sample(). It does not matter, as long as the statement that follows with evaluates to an object that has an __enter__() and __exit__() functions. In this case, Sample()’s __enter__() returns the newly created instance of Sample and that is what gets passed to sample.

这个例子中，with后面的get_sample()变成了Sample()。这没有任何关系，只要紧跟with后面的语句所返回的对象有__enter__()和__exit__()方法即可。此例中，Sample()的__enter__()方法返回新创建的Sample对象，并赋值给变量sample。

When executed:

代码执行后：

bash-3.2$
 ./with_example02.py
type:
 <type 'exceptions.ZeroDivisionError'>
value:
 integer division or modulo
 by zero
trace:
 <traceback object at 0x1004a8128>
Traceback
 (most recent call last):
  File "./with_example02.py",
 line 19, in <module>
    sample.do_something()
  File "./with_example02.py",
 line 15, in do_something
    bar = 1/0
ZeroDivisionError:
 integer division or modulo
 by zero

Essentially, if there are exceptions being thrown from anywhere inside the block, the __exit__() function for the object is called. As you can see, the type, value and the stack trace associated with the exception thrown is passed to this function. In this case, you can see that there was a ZeroDivisionError exception being thrown. People implementing libraries can write code that clean up resources, close files etc. in their __exit__() functions.

实际上，在with后面的代码块抛出任何异常时，__exit__()方法被执行。正如例子所示，异常抛出时，与之关联的type，value和stack trace传给__exit__()方法，因此抛出的ZeroDivisionError异常被打印出来了。开发库时，清理资源，关闭文件等等操作，都可以放在__exit__方法当中。

Thus, Python’s with is a nifty construct that makes code a little less verbose and makes cleaning up during exceptions a bit easier.
因此，Python的with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，清理工作更简单。
 译注：本文原文见Understanding Python's "With" Statement  
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　linbo（同济大学·计算机科学与技术系）

#!/usr/bin/env python
# with_example01.py


class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self, type, value, trace):
        print "In __exit__()"


def get_sample():
    return Sample()


with get_sample() as sample:
    print "sample:", sample

 

#!/usr/bin/env python
# with_example02.py


class Sample:
    def __enter__(self):
        return self

    def __exit__(self, type, value, trace):
        print "type:", type
        print "value:", value
        print "trace:", trace

    def do_something(self):
        bar = 1/0
        return bar + 10

with Sample() as sample:
    sample.do_something()

 虽然with看起来简单，但是不能对Python的任意符号使用with语句。它仅仅能工作在支持上下文管理协议（context management protocol）的对象。这显然意味着只有内建了"上下文管理"的对象可以和with一起工作。

第一批支持的对象有

file

decimal.Context

thread.LockType

threading.Lock

threading.RLock

threading.Condtion

threading.Semaphore

threading.BoundedSemaphore

#this is demo

with open('/etc/passwd', 'r') as f
    for eachLine in f
        #...do stuff with eachline or f...

 这段代码用in迭代器遍历文件中的每一行，完成时，关闭文件。无论代码开始，中间，还是结束时发生异常。都会自动关闭。

with context_expr [as var]:

　　with_suite

 

下面介绍上下文管理协议：
如果你要编写一个可以和with一起工作的类。
1.上下文表达式（context_expr),上下文管理器
当with语句执行时，便执行上下文符号（就是with 和as之间的内容）来获得一个上下文管理器。上下文管理器的职责是提供一个上下文对象。
这是通过调用__context__()方法来实现的。该方法返回一个上下文对象，用于在with语句中处理细节。注意，上下文对象本身就是上下文管理器
。所以context_expr既可以是一个真正的上下文管理器，也可以是一个自我管理的上下文对象。后一种情况下，上下文对象仍然有__context__()方法，
返回其自身，如你所想。
2.上下文对象，with语句块
一旦我们获得了上下文对象，就会调用它的__enter()__方法。它将会完成with语句块执行前的所有准备工作，也就是说在执行context_expr之前执行。
你可以注意到在上面的with行的语法中有一个可选的as声明变量跟随在context_expr后面。如果提供了变量，以__enter()__返回的内容来赋值；
否则，丢弃返回值。在我们的文件对象的例子中，上下文对象的__enter()__返回文件对象并赋值给f。
现在执行了with语句块。当with语句执行结束，无论是"和谐的结束"还是由于异常，都会调用上下文对象的__exit()__方法。__exit()__有三个参数。
如果with语句块正常结束，三个参数全部是None。如果发生异常三个参数的值分别等于调用sys.exc_info()函数返回的三个值：类型（异常）、值（异常实例）和
跟踪记录traceback，相应的跟踪记录对象。
你可以自己决定如何在__exit()__里面处理异常。惯例是当你处理完异常时不返回任何值，或返回None，或返回其它布尔值为False对象。
这样可以使异常抛给你的用户来处理。如果你想屏蔽这个异常，返回一个True的布尔值。如果没有异常或者在你处理之后返回True，
程序便会继续执行with子句的下一段代码。
上下文管理器主要用作共享资源，你可以想象到__enter__()和__exit__()方法基本上是执行一些分配和释放资源的低层次的工作，比如数据库连接、
锁分配、信号量加减、状态管理、打开和关闭文件、异常处理等。
有一个contextlib模块帮助你编写对象的上下文处理器。