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

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

s={1,2,3,4}
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

l=[1,2,3]
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)

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

from collections import Iterable,Iterator

s='hello'
l=[1,2,3]
t=(1,2,3)
d={'a':1}
set1={1,2,3,4}
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))

三、生成器

什么是生成器:

可以理解为一种数据类型，这种数据类型自动实现了迭代器协议（其他的数据类型需要调用自己内置的__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(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

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

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

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

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

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

生成器本质就是迭代器

def func():
        n=0
        while True:
             yield n
             n+=1
             
    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 1 #return 1
    print('two')
    yield 2 #return 2
    print('three')
    yield 3 #return 2
    print('four')
    yield 4 #return 2
    print('five')
    yield 5 #return 2

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)

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

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

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

def countdown(n):
    print('start coutdown')
    while n > 0:
        yield n #1
        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

四、协程函数 

定义：如果在一个函数内部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('123'))
print(e.send('123'))
print(e.send('123'))
print(e.send('123'))
print(e.send('123'))

五、协程函数的应用

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

优点：   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')