python入门之迭代器与生成器

ps这是我看网上egon林海峰老师的课程即一些资料做的笔记，希望有帮助共同进步

一 迭代的概念

迭代器即迭代的工具，那什么是迭代呢？
迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

为大家举例一个简单的案例

l=[1,2,3]
count=0
while count < len(l): #迭代
    print(l[count])
    count+=1

这就是迭代，上面这段代码重复了三次，及迭代了三次。简单的为大家进行一次分析

l=[1,2,3]
count=0
while count < len(l): #迭代
    print(l[count])
    count+=1
#进行第一次迭代时，count=0==》输出l[0]==》1
#第一次迭代结束时，count=count+1=1
#进行第二次迭代时，count=第一次迭代结束后count的初始值==》输出l[1]==》2
#第二次迭代结束时，count=count+1=2
#进行第三次迭代时，count=第二次迭代结束后count的初始值==》输出l[2]==》3
#第二次迭代结束时，count=count+1=3
#此时count=3不小于len(l)=3故迭代结束

二 为何要有迭代器？什么是可迭代对象？什么是迭代器对象？

2.1 为何要有迭代器？

对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

2.2 什么是可迭代对象？

可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下

'hello'.__iter__       # ==》字符串为可迭代对象
(1,2,3).__iter__       # ==》元组为可迭代对象
[1,2,3].__iter__       # ==》列表为可迭代对象
{'a':1}.__iter__       # ==》字典为可迭代对象
{'a','b'}.__iter__     # ==》集合为可迭代对象
open('a.txt').__iter__ # ==》文件为可迭代对象

2.3 什么是迭代器对象？

可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

#文件类型是迭代器对象
open('a.txt').__iter__()
open('a.txt').__next__()

注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

2.4迭代器对象的使用

dic={'a':1,'b':2}
iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__
#但是：迭代器.__iter__()得到的仍然是迭代器本身,如下案例：
print(iter_dic.__iter__() is iter_dic) #====>True

print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
# print(iter_dic.__next__()) #抛出异常StopIteration，或者说结束标志，
#在一个迭代器取值取干净了时，再对其取值取不到
# 若再对其生成一个迭代器则可继续取值  iter_iter = iter.__iter__()

#有了迭代器，我们就可以不依赖索引迭代取值了
iter_dic=dic.__iter__()
while 1:
    try:
        k=next(iter_dic)
        print(dic[k])
    except StopIteration:
        break
#但是这样的写法比较不好，需要我们自己捕捉异常，控制next，于是有了for

#基于for循环，我们可以完全不再依赖索引去取值了
dic={'a':1,'b':2}
for k in dic:
    print(dic[k])


#for循环的工作原理
#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象
#2: 执行next(迭代器对象),将得到的值赋值给k,然后执行循环体代码
#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

迭代器优缺点：
1、优点：统一的方案，更加节省内存(同一时间在内存里只有一个值)
2、与索引相比，不能直接取想要的值,取完就要再生成一个迭代器取值，否则就报错

三、什么是生成器：

生成器(自定义迭代器)  就相当于迭代器
yield类似于return 但是返回结果后函数不会结束，任然执行

即，只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')

g=func()
print(g) #<generator object func at 0x0000000002184360> 
#g.__next__()#会触发函数体代码的运行，然后遇到yield停下来，将yield后的值返回

res=g.__next__()#结果为：===>first(遇到yield 停止)
print(res)#结果为：1
res=g.__next__()#结果为：===>second(遇到yield 停止)
print(res)#结果为：2
res=g.__next__()#结果为：===>third(遇到yield 停止)
print(res)#结果为：3
res=g.__next__()#结果为：===>end 也会报错：StopIteration（可以看作会继续向下找yield但是会超出迭代器）

 生成器就是迭代器

g.__iter__
g.__next__
#2、所以生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)

生成器小案例：

def dog(name):
    print('%s 准备吃东西了....' % name)
    while True:
         # x拿到的是yield接受到的值
         x = yield  # (默认是None)
        print('%s 吃了%s' % (name, x))

g = dog('xm')
#next(g)#每次碰到yield停止运行
g.send(None)  # 等同于next(g) 刚开始不能直接在g.send()里面传其他值，要先传一个None
#相当于先g.next()到暂停的位置
g.send('肉')  # 为yield赋值
g.send('肉包子')#传的值可以为列表
g.close()  # 关闭后就不能传值了

#输出结果为：
====》xm 准备吃东西了....
====》xm 吃了肉
====》xm 吃了肉包子