理解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 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()

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.read()
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__()方法。

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

When executed, this will result in:
行代碼，輸出以下

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_somet hing()
  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語句是提供一個有效的機制，讓代碼更簡練，同時在異常產生時，清理工做更簡單。

I have put the code examples given here on Github.

 

Addtional:

Python 對一些內建對象進行改進，加入了對上下文管理器的支持，能夠用於 with 語句中，好比能夠自動關閉文件、線程鎖的自動獲取和釋放等。假設要對一個文件進行操做，使用 with 語句能夠有以下代碼：

清單 2. 使用 with 語句操做文件對象

1 2 3 4

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

這裏使用了 with 語句，無論在處理文件過程當中是否發生異常，都能保證 with 語句執行完畢後已經關閉了打開的文件句柄。若是使用傳統的 try/finally 範式，則要使用相似以下代碼：

清單 3. try/finally 方式操做文件對象

1 2 3 4 5 6 7

somefile = open(r'somefileName') try:     for line in somefile:         print line         # ...more code finally:     somefile.close()