python学习笔记-迭代器与生成器

迭代器

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

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

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

for循环的本质：循环所有对象，全都是使用迭代器协议

（字符串，列表，元祖，字典，集合，文件对象）这些都不是可迭代对象，只不过在for循环调用了他们内部的__iter__方法，把他们变了可迭代对象

然后for循环调用可迭代对象的__next__方法去取值，而且for循环会捕捉Stoplteration异常，以终止迭代

x="hello"
for i in x:   #x_l=x.__iter__()    x_l.__next__()
    print(i)


#内部逻辑
iter_test=x.__iter__()
print(iter_test)
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
#print(next(iter_test))

for循环是基于迭代器协议去工作的

例子：基于索引方法遍历列表

index=0
while index<len(x):
    print(x[index])
    index+=1

有时候用while无法实现就要用到for循环

为何要有for循环
序列类型字符串，列表，元祖都有下标，可以用上面对方式访问，但是还有非序列类型像字典，集合，文件对象。所以，for循环是基于迭代器
提供了一个统一的可以遍历所有对象的方法。

例子：

#集合
s={1,2,3}
for i in s:
    print(i)

#文件对象
f=open("test.txt","r+")
iter_f=f.__iter__()
print(iter_f.__next__(),end='')
print(iter_f.__next__(),end='')

生成器

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

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

生成器函数：常规函数定义，但是使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开对地方继续执行
生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表

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

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

生成器函数

例子：

def test():
    yield 1
    yield 2
    yield 3
g=test()
print(g)
print(g.__next__())
print(g.__next__())

生成器表达式

例子：

#三元表达式
name="steve"
#name='jobs'
res='sb' if name =='steve' else '阿哥'
print(res)

#列表解析
egg_list=[]
for i in range(10):
    egg_list.append("鸡蛋%s" %i)
print(egg_list)
#写法2
l=["鸡蛋%s" %i for i in range(10)]
#l=["鸡蛋%s" %i for i in range(10) if i>5]  #三元表达式
#l=["鸡蛋%s" %i for i in range(10) if i>5 else i] #错误，没有四元表达式
print(l)


laomuji=("鸡蛋%s" %i for i in range(10))  #生成器表达式
print(laomuji)
print(laomuji.__next__())
print(laomuji.__next__())
print(next(laomuji))

总结：

1.把列表解析的[]换成()得到的就是生成器表达式

2.列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存

3.Python不但使用迭代器协议让for循环变得更加通用。大部分内置函数，也是使用迭代器协议访问对象的。例如，sum函数是Python的内置函数，该函数使用迭代器协议访问对象，而生成器实现了迭代器协议，所以，我们可以直接这样计算一系列值的和：

而不用多此一举的先构建一个列表

l=[1,2,3,46]
print(sum(l))
print(sum(list(range(100))))

例子：

def test():
    yield 1
    print("开始2")
    yield 2
    print("开始3")
    yield 3
    print("开始4")
    yield 4
res=test()
print(res)
print(res.__next__())
print(res.__next__())
print(res.__next__())


#还可以保存函数的运行状态
def product_baozi():
    for i in range(100):
        print("正在生成包子")
        yield("一屉包子%s"%i)
        print("开始卖包子")
pro_g=product_baozi()
baozi1=pro_g.__next__()
print(baozi1)
baozi2=pro_g.__next__()
print(baozi2)


def xiadan():
    ret=[]
    for i in range(100):
        ret.append("鸡蛋%s"%i)
    return ret
print(xiadan())
#缺点1：占空间大
#缺点2：效率低


def xiadan():
    for i in range(100):
        yield("鸡蛋%s"%i)
steve_lmj=xiadan()
jidan=steve_lmj.__next__()
print("取鸡蛋",jidan)
print(steve_lmj.__next__())
print(steve_lmj.__next__())
egg_l=list(steve_lmj)
print(egg_l)

生成器总结：
语法上和函数类似：生成器函数和常规函数几乎是一样的，他们都是使用def语句进行定义，差别在于生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
自动实现迭代器协议：对于生成器，python会自动实现迭代器协议，以便应用到迭代背景中，(如for循环，sum函数)，由于生成器自动实现了迭代器协议，所以我们可以调用他的next方法，并且，在没有值可以返回的时候，生成器自动产生stoplteration异常
状态挂起：生成器使用yield语句返回一个值，yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从他离开的地方继续执行

优点一:生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据批量处理将会非常有用
优点二:生成器还能有效提高代码可读性

例子：

{"name":"北京","population":10}
{"name":"山东","population":10231}
{"name":"山西","population":761}

def get_population():
    with open("人口普查","r",encoding="utf-8") as f:
        for i in f: #f是读取一行
            yield i
g=get_population()
#s1=eval(g.__next__())
#print(s1["population"])

all_pop=sum(eval(i)["population"] for i in g)
print(all_pop)

比如计算人口这样大数据的操作，读一行找一行很好用，不用一次性加载整个数据文件

例子1：一次性生成

def producer():
    res=[]
    for i in range(100):
        res.append("包子%s"%i)
    return res


def consumer(res):
    for index,baozi in enumerate(res): #enumerate
        print("第%s个人,吃了%s"%(index,baozi))

res=producer()
consumer(res)

send()方法 

def test():
    print("开始了")
    first=yield 1
    print("第一次",first)
    yield 2
    print("第二次")
t=test()
print(t.__next__())
res=t.send(55)  #res=2   把55传给first
print(res)

send()的一个功能是让发生成器往下执行，另一个功能是send一个值给yield。
此时print("第一次",first) 执行结果是："第一次" None

yield 1相当于return 控制的是函数的返回值
x=yield的另一个特性，接受send传过来对值，赋值给x。

例子2：并发吃包子

import time
def consumer(name):
    print("我是【%s】,我准备开始吃包子了"%name)
    while True:
        baozi=yield
        time.sleep(1)
        print("%s很开心的把【%s】吃掉了"%(name,baozi))
def producer():
    c1=consumer("steve")
    c2=consumer("jobs")
    c1.__next__()
    c2.__next__()
    for i in range(10):
        time.sleep(1)
        c1.send("包子%s"%i)
        c2.send("包子%s"%i)
producer()

迭代器复习：

def test():
    for i in range(4):
        yield i


t = test()
# t1=(i for i in t)
# print(list(t1))

t1 = (i for i in t)
t2 = (i for i in t1)
print(list(t1))
print(list(t2))  # 这条语句执行结果为[],因为执行上一条语句，t1的值取完了。