Python高级编程之生成器(Generator)与coroutine(一):Generator
转载请注明出处：点我这是一系列的文章，会从基础开始一步步的介绍Python中的Generator以及coroutine(协程)(主要是介绍coroutine)，并且详细的讲述了Python中coroutine的各种高级用法，最后会用coroutine实现一个简单的多任务的操作系统。
其实也是看完这篇文章的学习笔记吧！O(∩_∩)O
生成器(Generator)
什么是生成器?在Python中，生成器(Generator)是一个带有yield关键字的函数
1 def gene():
2 a = 1
3 print "开始执行gene(),a = ",a
4 a += 1
5 yield "rio_2607"
6 print "回到gene(),再辞开始执行,a = ",a
7 a += 2
8 yield "uestc"
9 print "又回到了gene(),a = ",a
10 yield "emc"
gene()就是一个生成器，因为函数的定义中有yield关键字。那么生成器跟普通的函数有什么区别呢？
当调用gene()函数的时候，不会立即执行gene()函数中的代码，而是返回一个生成器对象(generator object)：
1 >>> def gene():
2 a = 1
3 print "开始执行gene(),a = ",a
4 a += 1
5 yield "rio_2607"
6 print "回到gene()，再辞开始执行,a = ",a
7 a += 2
8 yield "uestc"
9 print "又回到了gene(),a = ",a
10 yield "emc"
11
12
13 >>> g = gene()
14 >>> type(g)
15 <type 'generator'>
可以看到，g是一个generator类型的对象。那么什么时候会执行函数的代码呢？答：当调用生成器对象的next()函数时就会开始执行函数定义中的代码。
但是跟普通函数一旦开始执行就会一直执行直到结束不同，生成器函数会一直往下执行，但是一旦碰到yield关键字，就会返回yield关键字后面的数据，把函数当前的所有状态封存起来，然后暂停函数的执行，在生成器对象的next()函数再一次被调用的时候，会接着上一次暂停的地方继续往下执行，直到碰到了下一个yield关键字或者函数的代码执行完毕
>>> g = gene()
>>> type(g)
<type 'generator'>
>>> g.next()
开始执行gene(),a =1
'rio_2607'
>>> g.next()
回到gene()，再辞开始执行,a =2
'uestc'
>>> g.next()
又回到了gene(),a =4
'emc'
可以看到，第一次调用g.next()函数时，函数内部的代码才开始执行，当执行到yield "rio_2607"这一句代码时，会返回"rio_2607"，然后函数暂停执行。然后当再次调用next函数的时候，gene()函数会接着往下面执行，可以看到，这时打印出来的a=2，保持了函数上一次离开时候的数据，当碰到yield "uestc"这一句时，函数会再次停止执行，封存此时函数内的数据。当再一次调用next()函数的时候，gene()会接着上次的状态，在上次暂停的地方继续往下执行，可以看到，此时打印输出了a=4，碰到yield之后再次暂停执行。
当生成器执行完毕后，再一次调用next()时，函数会抛出StopIteration异常
>>> g.next()
又回到了gene(),a =4
'emc'
>>> g.next()
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
g.next()
StopIteration
生成器表达式(Generator Expresisions)
生成器表达式(Generator Expresisions)类似于列表推导式(list comprehension)
ge = (x * 2 for x in a)
其中(x * 2 for x in a)就是生成器表达式，这个表达式会返回一个生成器对象:
>>> ge = (x * 2 for x in a)
>>> ge
<generator object <genexpr> at 0x01EA0A30>
在for循环中，for循环会自动调用生成器对象的next()函数并处理StopIteration异常：
>>> ge
<generator object <genexpr> at 0x01EA0A30>
>>> for i in ge:
print i
2
4
6
8
说了那么多，那么生成器除了实现迭代器(Iteration)之外，还有有什么作用呢？
我们有这么一个web server上面的log文件，数据大概是这样的
77.81.4.30 - - "GET /favicon.ico HTTP/1.1" 404 133
24.1.247.118 - - "GET /dynamic/ HTTP/1.1" 200 5105
24.1.247.118 - - "GET /favicon.ico HTTP/1.1" 404 133
24.1.247.118 - - "GET /favicon.ico HTTP/1.1" 404 133
122.117.168.219 - - "GET /ply/ HTTP/1.1" 304 -
122.117.168.219 - - "GET /ply/bookplug.gif HTTP/1.1" 304 -
122.117.168.219 - - "GET /ply/example.html HTTP/1.1" 304 -
89.182.136.236 - - "GET /ply/ HTTP/1.1" 200 8018
89.182.136.236 - - "GET /ply/bookplug.gif HTTP/1.1" 200 23903
89.182.136.236 - - "GET /favicon.ico HTTP/1.1" 404 133
66.249.65.37 - - "GET /papers/SIAM97/SIAM97.pdf HTTP/1.1" 200 188949
117.198.144.124 - - "GET /ply/ply.html HTTP/1.1" 200 97238
117.198.144.124 - - "GET /favicon.ico HTTP/1.1" 404 133
每一行的最后一列要么表示一个字节数据，要么为-，表示字节数据未知
现在我们要统计文件中记录的所有的字节数据大小
python中常规的写法是这样的，在一个for循环中，每次处理一行数据：
1 def non_generator_func():
2 '''
3 分析web server的log文件来判断所有传输的字节数
4 Non-Generator的写法：用一个for循环
5 :return:
6 '''
7 wwwlog = open("access-log")
8 total = 0
9
10 for line in wwwlog:
11 # 获取字节数的字符串表示
12 bytestr = line.rsplit(None, 1)
13 if bytestr != "-":
14 total += int(bytestr)
15
16 print "Total", total
现在来看看使用Generator的风格编写的代码：
1 def generator_func():
2 wwwlog = open("access-log")
3 # 采用生成器表达式(Generator expression),返回一个Generator对象
4 bytecolumn = (line.rsplit(None, 1) for line in wwwlog)
5 bytes = (int(x) for x in bytecolumn if x != "-")
6
7 # 最后一步才进行计算
8 print "Total", sum(bytes)
可以看出，使用Generator，可以编写更少的代码，还会有跟普通的Python编程完全不一样的编程风格。
上面的generator_func()函数的工作方式类似于管道(pipeline):
access-log---> wwwlog ---> bytecollumn --->bytes --->sum() --->total
现在来看另外一个Generator Fucntion的典型用法：在这里，我们模拟实现Unix中的"tail -f"命令。照例先看代码：
1 # tail -f:可以实时的得到新追加到文件中的信息，常用来跟踪日志文件
2 def unix_tail_f(thefile):
3 '''
4 Python版本的 Unix 'tail -f'
5 '''
6 import time
7 # 跳到文件末尾
8 thefile.seek(0,2)
9 while True:
10 line = thefile.readline()
11 if not line:
12 time.sleep(0.1)
13 continue
14 yield line
通过下面的方式来使用unix_tail_f()函数：
1 logfile = open("access-log")
2 for line in follow(logfile):
3 print line,
可以看出，通常使用Generator Fucntion的模式应该为：
现在，我们已经实现了tail -f的效果，接下来我们要更进一步，实现tail -f | grep 的过滤效果。先编写一个Generator Function，名字叫做grep，代码如下：
1 def grep(pattern,lines):
2 for line in lines:
3 if pattern in line:
4 # 如果line中有pattern，则返回这个line并挂起，暂停执行
5 yield line
下面的代码能够达到unix中的tail -f | grep pattern的效果：
1 def tail_f_grep(file,pattern):
2 '''
3 模拟tail -f | grep pattern
4 '''
5 logfile = open(file)
6 loglines = unix_tail_f(logfile)
7 pylines = grep(pattern,loglines)
8
9 # 在for循环中处理结果
10 for line in pylines:
11 print line,
当调用tail_f_grep("access-log","python")可以达到tail -f | grep python的效果。
关于Python中的生成器，Python函数式编程指南(四)：生成器这篇博客讲的挺好的，大家可以看下这篇博客。
页:
[1]