标签：

From: http://learnpythonthehardway.org/book/ex37.html

1. with X as Y: pass

1.1 yield 

2. exec

2.1 namespace

1. with-as statement（也称context manager）

From: http://zhoutall.com/archives/325

(1) 常见写法，但比较啰嗦

try:
    f = open(‘xxx‘)
except:
    print ‘fail to open‘
    exit(-1)
try:
    do something
except:
    do something
finally:
    f.close()

(2) 使用封装如何？不用反复写finally，但导致：所有的函数都要被 controlled_execution( ) 下，太累赘。

def controlled_execution(callback):
    set things up
    try:
        callback(thing)
    finally:
        tear things down
 
def my_function(thing):
    do something
 
controlled_execution(my_function)

(3) 另一个办法是使用生成器，但是只需要生成一次数据，我们用for-in结构去调用他：

def controlled_execution():  //因为thing只有一个，所以yield语句只需要执行一次，从代码可读性也就是优雅的角度来说这简直是糟糕透了
    set things up
    try:
        yield thing  //--> see "yield"
    finally:
        tear things down
         
for thing in controlled_execution():
    do something with thing

(4) with-as新方案

class controlled_execution:
    def __enter__(self):
        set things up
        return thing
    def __exit__(self, type, value, traceback):
        tear things down
         
with controlled_execution() as thing:
        do something

当python执行这一句时，会调用__enter__函数，然后把该函数return的值传给as后指定的变量。之后，python会执行下面do something的语句块。最后不论在该语句块出现了什么异常，都会在离开时执行__exit__。

另外，__exit__除了用于tear things down，还可以进行异常的监控和处理，注意后几个参数。要跳过一个异常，只需要返回该函数True即可。

在python2.5及以后，file对象已经写好了__enter__和__exit__函数，我们可以这样测试：

>>> f = open("x.txt")
>>> f
<open file ‘x.txt‘, mode ‘r‘ at 0x00AE82F0>
>>> f.__enter__()
<open file ‘x.txt‘, mode ‘r‘ at 0x00AE82F0>
>>> f.read(1)
‘X‘
>>> f.__exit__(None, None, None)
>>> f.read(1)
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>

之后，我们如果要打开文件并保证最后关闭他，只需要这么做：

with open("x.txt") as f:
    data = f.read()
    do something with data

如果有多个项，我们可以这么写：

with open("x.txt") as f1, open(‘xxx.txt‘) as f2:
    do something with f1,f2

上文说了__exit__函数可以进行部分异常的处理，如果我们不在这个函数中处理异常，他会正常抛出，这时候我们可以这样写（python 2.7及以上版本，之前的版本参考使用contextlib.nested这个库函数）：

try:
    with open( "a.txt" ) as f :
        do something
except xxxError:
    do something about exception

1.1 yield

 From: http://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/

清单 1. 简单输出斐波那契數列前 N 个数

 def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        print b         // 不太好！ 其实改为yield就好了。
        a, b = b, a + b 
        n = n + 1

执行 fab(5)，我们可以得到如下输出：

 >>> fab(5) 
 1 
 1 
 2 
 3 
 5

要提高 fab 函数的可复用性，最好不要直接打印出数列，而是返回一个 List。

以下是 fab 函数改写后的第二个版本：

清单 2. 输出斐波那契數列前 N 个数第二版

 def fab(max): 
    n, a, b = 0, 0, 1 
    L = [] 
    while n < max: 
        L.append(b) 
        a, b = b, a + b 
        n = n + 1 
    return L       // 暂用内存太大！

可以使用如下方式打印出 fab 函数返回的 List：

 >>> for n in fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

改写后的 fab 函数通过返回 List 能满足复用性的要求，但是更有经验的开发者会指出，该函数在运行中占用的内存会随着参数 max 的增大而增大。

如果要控制内存占用，最好不要用 List来保存中间结果，而是通过 iterable 对象来迭代。例如，在 Python2.x 中，代码：

清单 3. 通过 iterable 对象来迭代

for i in range(1000): pass  //会导致生成一个 1000 个元素的 List

for i in xrange(1000): pass // iterable对象是解决的办法！

利用 iterable 我们可以把 fab 函数改写为一个支持 iterable 的 class，以下是第三个版本的 Fab：

清单 4. 第三个版本

 class Fab(object): 

    def __init__(self, max): 
        self.max = max 
        self.n, self.a, self.b = 0, 0, 1 

    def __iter__(self): 
        return self 

    def next(self): 
        if self.n < self.max: 
            r = self.b 
            self.a, self.b = self.b, self.a + self.b 
            self.n = self.n + 1 
            return r 
        raise StopIteration()

Fab 类通过 next() 不断返回数列的下一个数，内存占用始终为常数：

 >>> for n in Fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

然而，使用 class 改写的这个版本，代码远远没有第一版的 fab 函数来得简洁。

如果我们想要保持第一版 fab 函数的简洁性，同时又要获得 iterable 的效果，yield 就派上用场了：

清单 5. 使用 yield 的第四版

 def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1 

第四个版本的 fab 和第一版相比，仅仅把 print b 改为了 yield b，就在保持简洁性的同时获得了 iterable 的效果。

调用第四版的 fab 和第二版的 fab 完全一致：

 >>> for n in fab(5):   // for执行一次函数，其实只是调用了函数内的一次运算；再调一次就再继续算一次！
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

 >>> f = fab(5)  // fab(5) 是iterable function，这里就是指的fab的实例
 >>> f.next()    // 与清单4 中的next比较下，其实是相同的思想
 1 
 >>> f.next() 
 1 
 >>> f.next() 
 2 
 >>> f.next() 
 3 
 >>> f.next() 
 5 
 >>> f.next() 
 Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
 StopIteration

>>> exec ‘print "Hello World"‘
Hello World

>>> eval_r(‘2*3‘)
6

>>> eval_r(‘3+4‘)
7
>>> exec ‘a=100‘ 
>>> a 
100 
>>> execfile(r‘d:\code\ex\test.py‘)
hello world!
>>>

[Python] Symbol Review

标签：

原文地址：http://www.cnblogs.com/jesse123/p/5624664.html