首先了解
1.iterator
iterator叫做迭代器，用来遍历可以序列化的数据，比如一个list，set 等，当然如果对象想要能够使用迭代器来遍历，只要在该对象的类中添加__iter__()方法，该方法返回一个迭代器对象，迭代器对象中需要实现next()方法
for example：
>>> class sequenceClass(object): ... def __init__(self, *args): ... self._data = list(args) ... def __iter__(self): ... return DataIter(self) ... >>> class DataIter(object): ... def __init__(self, data): ... self._index = 0 ... self._data = data._data ... def next(self): ... if self._index >= len(self._data): raise StopIteration() ... d = self._data[self._index] ... self._index += 1 ... return d ... >>> data = sequenceClass(1,2,3,4) >>> for x in data: print x ... 1 2 3 4
执行方法如下：
创建对象data : data = sequenceClass(1,2,3,4)
使用for循环遍历data：
1.第一次for循环遍历data时，调用了data的__iter__()方法，该方法返回一个迭代器对象：DataIter
2.接着for循环每次调用DataIter对象的next()方法，next()方法返回数据
3.等到数据遍历完成时，抛出异常StopIteration， 该异常被for循环扑获，遍历结束。
以上是iterator的实现方法，但有一种更加简单的方式，但初学时可能不太好理解，就是使用yield表达式来遍历对象。
2.yield表达式及genetator
Python中，凡是含有yield的函数，被调用时都返回一个generator对象。generator设计的目的是能够更加简单的实现迭代器协议，例如上面的例子，需要单独写一个类来遍历数据，而用generator，直接一个yield表达式就可以用做迭代器了
>>> def test_generator(): ... s = 0 ... for i in xrange(10): ... s = yield i * s ... print 'i:', i ... print 's:', s ... print 'i * s', i * s ... >>> t = test_generator() >>> t <generator object test_generator at 0x10403a820> >>> >>> t.next() 0 >>> t.send(10) i: 0 s: 10 i * s 0 10 >>> t.send(11) i: 1 s: 11 i * s 11 22
执行方法如下：
1.定义了一个函数叫做test_generator
2.调用test_generator，得到t对象
3.运行t时，是一个generator对象
4.t.next()或者t.send(None)启动generator对象, generator对象运行到yield，将yield右面的表达式的值返回，并保存generator对象当前的状，因此，后面的打印都没有被执行。
5.t.send(10)
1）将输入的值10赋值给s
2）执行yield后面的表达式，即将所有print执行完毕，解析如下：
由于在第4步generator保存了对象的当前的状态，因此: i = 0, s是刚输入的值为10， i *s 当然就为0了，接着进入下一次循环，此时i= 1，执行yield表达式，结果得10，保存当前generator状态，返回10，generator停止运行。
6.t.send(11)
1）和第5步类似了，将11输入给s
2）因为第5步，generator保存了当前的对象的值，因此: i = 1, s是刚输入的值为11， i *s 当然就为11了，接着进入下一次循环，此时i= 2，执行yield表达式，结果得22，保存当前generator状态，返回22，generator停止运行。
7.接下来在调用t.send(num)，和第5，6步一样，直到generator内部的循环完成，当再次调用时，将抛出异常：StopIteration
总结一下：
1. yield表达式, 四种形式：
a. 不接受输入值或者输入值是None
yield 1
b. 接受输入值
s = yield 1
c. 接受输入，但不返回数据，这样默认返回None
s = yield
d.既不接受输入，也不返回值，默认返回None
yield
第一种：当函数调用到yield时，返回yield的右边经过计算的值 ，这里说计算的意思是，yield后面可以写成函数，表达式等，
第二种：当函数调用到yield时，必须传入一个值，该值存入s中，然后返回yield后面的表达式的值并保存当前状态
第三种：只是将数据接受进来，然后执行yield后的语句，再次执行到yield时，保存当前状态并返回，这样的用例一般是
只打印一些处理消息，而不需要结果的方式。
第四种：这样的只能遍历generator内部的数据了。
2.使用generator的好处：
1）可以很方便的实现迭代器，即yield不接受输入值
2）使用generator可以减少内存的使用，因为遍历出来的值都是每次进行计算的，不用一次性全部计算完成，然后一个个
遍历，最终释放掉；另外可以在yield后面做一些操作，可以很随意的控制返回值。
3.coroutine 协程
使用yield的函数，若用send来控制，就算coroutine了，若用for循环来控制，就算generator或者iterator，使用方法大多见于
decorator, 如tornado中的gen.coroutine。
实例：
#应用：grep -rl 'root' /etc 模拟linux中的grep -rl 命令，来过滤含有root内容的文件，并打印文件名 # import os # def f1(func): #程序初始化 # def wrapper(*args, **kwargs): # g=func(*args, **kwargs) # next(g) # return g # return wrapper # #阶段一，递归的找文件的绝对路径，把路径发给阶段2 # @f1 # def search(target): # 'search file abspath' # while True: # start_path = yield # g = os.walk(start_path) # for par_dir, _, files in g: # for file in files: # file_path = r'%s\%s' % (par_dir, file) # target.send(file_path) # #阶段2，收到文件路径， 打开文件获取对象，吧文件对象发给阶段3 # @f1 # def opener(target): # 'get file obj: f = open(file_path)' # while True: # file_path = yield # with open(file_path, 'r', encoding='utf-8') as f: # target.send((file_path, f)) # #阶段三，收到文件对象，for循环读取文件的每一行内容，把每一行内容发给阶段4 # @f1 # def cat(target): # 'read file' # while True: # file_path,f = yield # for line in f: # res = target.send((file_path, line)) # if res: # break # #阶段4，收到一行内容，判断root是否在这一行，如果在，则把文件名发给阶段五 # @f1 # def grep(target, pattern): # 'grep functhion' # tag=False # while True: # file_path, line = yield tag # tag = False # if pattern in line: # target.send(file_path) # tag=True # #阶段五，收到文件名，打印结果 # @f1 # def printer(): # 'print function' # while True: # filename = yield # print(filename) # start_path1 = r'E:\Pycharmlx\June\day\day21root' # start_path2 = r'E:\Pycharmlx\June\day\day21root\t' #绝对路径 # g = search(opener(cat(grep(printer(), 'root')))) # # print(g) # g.send(start_path1) # g.send(start_path2)