python基础----迭代器、生成器、协程函数及应用（面向过程实例）

一、什么是迭代器协议

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

二，为什么要用迭代器

优点：

1：迭代器提供了一种不依赖于索引的取值方式，这样就可以遍历那些没有索引的可迭代对象了（字典，集合，文件）

2：迭代器与列表比较，迭代器是惰性计算的，更节省内存

缺点：

1：无法获取迭代器的长度，使用不如列表索引取值灵活

2：一次性的，只能往后取值，不能倒着取值

 l=['a','b','c','d','e']
 i=l.__iter__()
 while True:
     try:
         print(next(i))
     except StopIteration:
         break

课堂例1

 d={'a':,'b':,'c':}
 d.__iter__
 for k in d:        #d.__iter__()
     print(k)

课堂例2

 s={,,,}
 for i in s:
     print(i)

 with open('a.txt','r') as f:
     for line in f:
         print(line)

 f=open('a.txt','r')
 f.__next__
 f.__iter__
 print(f)
 print(f.__iter__())

 for line in f: #f.__iter__()
     print(line)

 i=f.__iter__()

 while True:
     try:                     #异常排查,与StopIteration一起用
         print(next(i))
     except StopIteration:     #异常排查，与try一起用      # except 排除
         break

课堂例3

 l=[,,]
 print(len(l))
 i=l.__iter__()

 print(next(i))
 print(next(i))
 print(next(i))
 print(next(i))

 for x in i:
     print(x)
 for x in i:
     print(x)
 for x in i:
     print(x)
 for x in i:
     print(x)

课堂例4

 查看可迭代对象与迭代器对象

 from collections import Iterable,Iterator

 s='hello'
 l=[,,]
 t=(,,)
 d={'a':}
 set1={,,,}
 f=open('a.txt')

 都是可迭代的
 s.__iter__()
 l.__iter__()
 t.__iter__()
 d.__iter__()
 set1.__iter__()
 f.__iter__()
 print(isinstance(s,Iterable))
 print(isinstance(l,Iterable))
 print(isinstance(t,Iterable))
 print(isinstance(d,Iterable))
 print(isinstance(set1,Iterable))
 print(isinstance(f,Iterable))

 查看是否是迭代器
 print(isinstance(s,Iterator))
 print(isinstance(l,Iterator))
 print(isinstance(t,Iterator))
 print(isinstance(d,Iterator))
 print(isinstance(set1,Iterator))
 print(isinstance(f,Iterator))

课堂例5

三、生成器

什么是生成器:

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__iter__方法），所以生成器就是可迭代对象.

from collections import Iterator   生成器就是一个函数，这个函数内包含有yield这个关键字  ｡◕‿◕｡

生成器分类及在python中的表现形式：（Python有两种不同的方式提供生成器）

1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行.

2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表.

为何使用生成器:

优点:

Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。

生成器小结：

1.是可迭代对象

2.实现了延迟计算,省内存

3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处，其余的可迭代对象可没有这点好处，记住喽！！！

生成器与return的区别：return只能返回一次函数就彻底结束了，而yield能返回多次值
                 
yield功能：

1.yield把函数变成生成器-->生成器本质就是迭代器，相当于把__iter__和__next__方法封装到函数内部

2.用return返回值能返回一次，而yield返回多次

3.函数暂停以及继续运行的状态是通过yield保存的

插一嘴：

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

 >>> L = [x * x for x in range()]
 >>> L
 [, , , , , , , , , ]
 >>> g = (x * x for x in range())
 >>> g
 <generator object <genexpr> at 0x1022ef630>

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

我们可以直接打印出list的每一个元素，但我们怎么打印出generator的每一个元素呢？

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)

 >>> next(g)
 Traceback (most recent call last):
   File "<stdin>", line , in <module>
 StopIteration

我们讲过，generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

生成器本质就是迭代器

 def func():
         n=
         while True:
              yield n
              n+=

     g=func()

     res=next(g)
     res=next(g)

     for i in g:
         pass

yield的表达式形式：

 food=yield

 def eater(name):
     print('%s start to eat' %name)
     while True:
         food=yield
         print('%s eat %s' %(name,food))

 e=eater('zhejiangF4')

e.send与next(e)的区别
          1.如果函数内yield是表达式形式，那么必须先next(e)
          2.二者的共同之处是都可以让函数在上次暂停的位置继续运行，不一样的地方在于send在触发下一次代码的执行时，会顺便给yield传一个值

 def test():
     print('one')
     yield  #return
     print('two')
     yield  #return
     print('three')
     yield  #return
     print('four')
     yield  #return
     print('five')
     yield  #return 

 g=test()
 print(g)
 # print(isinstance(g,Iterator))
 g.__iter__()
 g.__next__()

 res=next(g)
 print(res)

 res=next(g)
 print(res)

 res=next(g)
 print(res)

 res=next(g)
 print(res)

 for i in g:
     print(i)

课堂例1

 def func():
     n=
     while True:
         yield n
         n+=

 f=func()
 print(next(f))

课堂例2

 import time
 def tail(file_path):
     with open(file_path,'r') as f:
         f.seek(,)
         while True:
             line=f.readline()
             if not line:
                 time.sleep(0.3)
                 continue
             else:
                 # print(line)
                 yield line
 tail('/tmp/a.txt')

课堂例3

 def countdown(n):
     print('start coutdown')
     while n > 0:
         yield n #
         n-=1
     print('done')

 g=countdown(5)
 print(g)

 print(next(g))
 print(next(g))
 print(next(g))
 print(next(g))
 print(next(g))
 print(next(g))

 for i in g: #iter(g)
     print(i)

 while True:
     try:
         print(next(g))
     except StopIteration:
         break

课堂例4

四、协程函数

定义：如果在一个函数内部yield的使用方式是表达式形式的话，如x=yield，那么该函数成为协程函数  ｡◕‿◕｡

 #例子

 1 def eater(name):
     print('%s start to eat food' %name)
     food_list=[]
     while True:
         food=yield food_list
         print('%s get %s ,to start eat' %(name,food))
         food_list.append(food)
     print('done')
 e=eater('钢蛋')
 print(e)
12 print(next(e))
 print(e.send('包子'))
 print(e.send('韭菜馅包子'))
15 print(e.send('大蒜包子'))

为协程函数添加装饰器:

 def timmer(func):
     def wrapper(*args,**kwargs):
         e=func(*args,**kwargs)
         next(e)
         return e
     return wrapper

 @timmer        #eater=timmer(eater)
 def eater(name):
     print('%s start to eat food' %name)
     food_list=[]
     while True:
         food=yield food_list
         print('%s get %s ,to start eat' %(name,food))
         food_list.append(food)
 e = eater('egon')   #wrapper('egon')
 # print(e)
 # next(e)
 print(e.send('包子'))
 print(e.send('包子'))   #以下每send一次都会执行一次结果
 print(e.send('包子'))
 print(e.send('包子'))

补充:

 def init(func):
     def wrapper(*args,**kwargs):
         res=func(*args,**kwargs)
         next(res)
         return res
     return wrapper

 @init #eater=init(eater)
 def eater(name):
     print('%s start to eat' % name)
     food_list=[]
     while True:
         food = yield food_list
         print('%s eat %s' % (name, food))
         food_list.append(food)

 e = eater('zhejiangF4') #wrapper('zhengjiangF4')
 # print(e)
 # next(e) #e.send(None)

 print(e.send(''))
 print(e.send(''))
 print(e.send(''))
 print(e.send(''))
 print(e.send(''))

五、协程函数的应用

面向过程的编程思想：流水线式的编程思想，在设计程序时，需要把整个流程设计出来

优点：   1：体系结构更加清晰

2：简化程序的复杂度

缺点：可扩展性极其的差，所以说面向过程的应用场景是：不需要经常变化的软件，如：linux内核，httpd，git等软件

旁白： 此实例包含了装饰器、迭代器、生成器、协程函数、os模块中walk命令，需要好好记住！ ♥♥♥♥♥｡◕‿◕｡♥♥♥♥♥

 #grep -rl 'python' C:\egon
 import os,time
 def init(func):
     def wrapper(*args,**kwargs):
         res=func(*args,**kwargs)
         next(res)
         return res
     return wrapper

 #找到一个绝对路径，往下一个阶段发一个
 @init
 def search(target):
     '找到文件的绝对路径'
     while True:
         dir_name=yield #dir_name='C:\\egon'
         print('车间search开始生产产品：文件的绝对路径')
         time.sleep(2)
         g = os.walk(dir_name)
         for i in g:
             # print(i)
             for j in i[-1]:
                 file_path = '%s\\%s' % (i[0], j)
                 target.send(file_path)

 @init
 def opener(target):
     '打开文件，获取文件句柄'
     while True:
         file_path=yield
         print('车间opener开始生产产品：文件句柄')
         time.sleep(2)
         with open(file_path) as f:
             target.send((file_path,f))

 @init
 def cat(target):
     '读取文件内容'
     while True:
         file_path,f=yield
         print('车间cat开始生产产品：文件的一行内容')
         time.sleep(2)
         for line in f:
             target.send((file_path,line))

 @init
 def grep(pattern,target):
     '过滤一行内容中有无python'
     while True:
         file_path,line=yield
         print('车间grep开始生产产品：包含python这一行内容的文件路径')
         time.sleep(0.2)
         if pattern in line:
             target.send(file_path)

 @init
 def printer():
     '打印文件路径'
     while True:
         file_path=yield
         print('车间printer开始生产产品：得到最终的产品')
         time.sleep(2)
         print(file_path)

 g=search(opener(cat(grep('python',printer()))))
 g.send('C:\\egon')
 g.send('D:\\dir1')
 g.send('E:\\dir2')

面向过程实例