# 理解Python的With语句

python学习 专栏收录该内容
11 篇文章 0 订阅

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.

Without the with statement, one would write something along the lines of:

1

2

3

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:

1

2

3

4

5

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:

1

2

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.

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.

This can be demonstrated with the following example:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

#!/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:

1

2

3

4

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。 这些参数在异常处理中相当有用。我们来改一下代码，看看具体如何工作的。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #!/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: 代码执行后： 1 2 3 4 5 6 7 8 9 10 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.

Thus, Python’s with is a nifty construct that makes code a little less verbose and makes cleaning up during exceptions a bit easier.

I have put the code examples given here on
Github.

Github上面找到。

Understanding Python's "With" Statement

• 27
点赞
• 11
评论
• 1
收藏
• 一键三连
• 扫一扫，分享海报

09-22

04-07 7531
09-11 1076
05-08 8989
11-02 35万+
04-11 956
05-26 342
08-21 418
01-14 1272
01-25 483
10-20
10-20
10-20
10-20