Python开发——理解With语句

• 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 file, read data form the file and then 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()

There are two annoying things here. First, you end up forgetting to close the file handler. The second is how to handle exceptions that may occur once the file handler has been obtained. One could write something like this to get around this:

这里有两个问题。一是可能忘记关闭文件句柄；二是文件句柄已经存在。下面是处理异常的加强版本：

file = open('/tmp/foo.txt')
try:
    data = file.rad()
finally:
    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__( )方法。

This can be demonstrated with the following example:

下面例子可以具体说明with如何工作：

#!/usr/bin/env python

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

When executed, this will result in:

运行代码，输出如下

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 i.e. '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.

#!/usr/bin/env python
 
 
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 example.

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 ZeroDivision Error exception being thrown. People implementing libraries can write code that clean up resources, close files, etc. in their __exit__() functions.

Thus, Python's with is a nifty constructor that makes code a litter less verbose and makes cleaning up during exceptions a bit easier.

本文原文见Understanding Python's 'with' Statement