Python老男孩 day18 迭代器和生成器

https://www.cnblogs.com/haishiniu123/p/6774081.html

迭代器协议:　

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

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

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

Python中强大的for 循环机制

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

很多人会想，for循环的本质就是遵循迭代器协议去访问对象，那么for循环的对象肯定都是迭代器了啊，没错，那既然这样，for循环可以遍历（字符串，列表，元组，字典，集合，文件对象），那这些类型的数据肯定都是可迭代对象啊？但是，我他妈的为什么定义一个列表l=[1,2,3,4]没有l.next()方法，打脸么。

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

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

name=[1,2,3,4,5]
for i in name:
    print(i)

实现for循环的原理（while循环模拟for循环） ：
name=name.__iter__()
while True:
    try:
        print(name.__next__())
    except StopIteration:
        break

#集合中使用迭代器
s={1,2,3}
for i in s:
    print(i)

运行结果：
1
2
3

iter_s=s.__iter__()
print(iter_s)
print(iter_s.__next__())
print(iter_s.__next__())
print(iter_s.__next__())
print(iter_s.__next__())

运行结果：
<set_iterator object at 0x00000000027BDFC0>
1
2
3
报错：StopIteration    手动执行.__next__()对象都遍历完了再执行就会报错

#字典中使用迭代器
dic={'a':1,'b':2}
iter_d=dic.__iter__()
print(iter_d.__next__())

运行结果：
a            #默认迭代的是key值

#文件中使用迭代器
f=open('test.txt','r+')
iter_f=f.__iter__()
print(iter_f)
print(iter_f.__next__(),end='') #通过end参数解决了不是以默认的方式换行的问题
print(iter_f.__next__(),end='')

运行结果：
<_io.TextIOWrapper name='test.txt' mode='r+' encoding='cp936'>
1111
2

补充next()
l=['die','erzi','sunzi','chongsunzi']
iter_l=l.__iter__()
print(next(iter_l)) #next()相当于iter_l.__next__()

运行结果：
die

生成器

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

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

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

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

为何使用生成器之生成器的优点

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

生成器小结：

1.是可迭代对象

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

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

def test():
    yield 1
    yield 2
    yield 3
g=test()   #写完此句才是生成器对象
print('来自函数',g)
print(g.__next__())  #生成器内部有next方法，直接调用就ok
print(g.__next__())

运行结果：
来自函数 <generator object test at 0x0000000002202780>
1
2


#三元表达式
name='linhaifeng'
res='SB' if name == 'alex' else '帅哥'
print(res)

运行结果：
帅哥

#列表解析
#通过for循环的形式实现原理
egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s' %i)
print(egg_list)

#列表解析的表达形式
l=['鸡蛋%s' %i for i in range(10)]#%后面相当于一个要传给前面的一个参数
l1=['鸡蛋%s' %i for i in range(10) if i > 5] #列表解析中的三元表达式形式
#l1=['鸡蛋%s' %i for i in range(10) if i > 5 else i] #报错，没有四元表达式
l2=['鸡蛋%s' %i for i in range(10) if i < 5] #没有四元表达式

print(l)
print(l1)
print(l2)

运行结果：
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4', '鸡蛋5', '鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋6', '鸡蛋7', '鸡蛋8', '鸡蛋9']
['鸡蛋0', '鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4']


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

运行结果：
<generator object <genexpr> at 0x00000000027F2780>
鸡蛋0
鸡蛋1
鸡蛋2
鸡蛋3
鸡蛋4
鸡蛋5
鸡蛋6
鸡蛋7

生成器总结：

综上已经对生成器有了一定的认识，下面我们以生成器函数为例进行总结

语法上和函数类似：生成器函数和常规函数几乎是一样的。它们都是使用def语句进行定义，差别在于，生成器使用yield语句返回一个值，而常规函数使用return语句返回一个值
自动实现迭代器协议：对于生成器，Python会自动实现迭代器协议，以便应用到迭代背景中（如for循环，sum函数）。由于生成器自动实现了迭代器协议，所以，我们可以调用它的next方法，并且，在没有值可以返回的时候，生成器自动产生StopIteration异常
状态挂起：生成器使用yield语句返回一个值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行
优点一：生成器的好处是延迟计算，一次返回一个结果。也就是说，它不会一次生成所有的结果，这对于大数据量处理，将会非常有用。

优点二：生成器还能有效提高代码可读性