迭代器与生成器

一、 什么是迭代器

1.迭代器指的是迭代取值的工具
2.迭代是一重复的过程，每一次重复都是基于上一次的结果而来

#单纯的重复不是迭代

i=0
while True:
	print(i)

#迭代：重复+每次重复都是基于上一次的结果而进行

l=['a','b','c']
#l='hello'
#l=('a','b','c')
i=0
while i < len(l):
	print(l[i])
	i+=1

二、. 为何要用迭代器

迭代器提供了一种通用的且不依赖于索引的迭代取值方式
迭代器可以节省内存空间，值可以被一次一次取出来，而非一次全部取出。

三、如何用迭代器

1，可迭代的对象iterable：但凡内置有__iter__方法的对象都称之为可迭代的对象

如：str，list，tuple，dict，set,文件对象

a=1
b=1.1
c='hello'
d=['a','b']
e=('a','b')
j={'x':1}
g={1,2,3}
f=open('a.txt','w')

执行可迭代对象下的__iter__方法，返回的值就是一个迭代器对象iterator

dic={'x':1,'y':2,'z':3}
iter_dic=dic.__iter__()

print(iter_dic)
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__()) #StopIteration应该被当成一种结束信号



f=open('a.txt','rt',encoding='utf-8')
iter_f=f.__iter__()

print(iter_f.__next__())
print(iter_f.__next__())
print(iter_f.__next__())
print(iter_f.__next__())


l=['a','b','c']
iter_l=l.__iter__()

print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())
print(iter_l.__next__())



l=['a','b','c']
print(l.__iter__().__next__())
print(l.__iter__().__next__())
print(l.__iter__().__next__())
iter_l=l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())

2， 迭代器对象

既内置有__next__方法的对象，执行迭代器__next__方法可以不依赖索引取值

又内置有__iter__方法的对象，执行迭代器__iter__方法得到的仍然是迭代器本身

ps:

1.迭代器对象一定是可迭代的对象，而可迭代的对象却不一定是迭代器对象

2.文件对象本身就是一个迭代器对象

l=['a','b','c']
iter_l=l.__iter__() # 调用可迭代的对象__iter__得到的是迭代对象，
print(iter_l is iter_l.__iter__().__iter__().__iter__().__iter__().__iter__().__iter__())

dic={1,2,3,4}
dic={'x':1,'y':2,'z':3}
print(len(dic)) #dic.__len__()
iter_dic=iter(dic) # dic.__iter__()

while True:
	try:
		print(next(iter_dic)) #iter_dic.__next__()
	except StopIteration:
		break

print('='*100)
#同一个迭代器只能完整地取完一次值
iter_dic=iter(dic) #dic.__iter__()
while True:
	try:
		print(next(iter_dic)) #iter_dic.__next__()
	except StopIteration:
		break

3，for循环本质应该称之为迭代器循环

#工作原理
#1. 先调用in后面那个对象的__iter__方法，将其变成一个迭代器对象
#2. 调用next(迭代器)，将得到的返回值赋值给变量名k
#3. 循环往复直到next(迭代器)抛出异常，for会自动捕捉异常然后结束循环

ps：从for角度，可以分辨出但凡可以被for循环循环取值的对象都是可迭代的对象

dic={'x':1,'y':2,'z':3}

for k in dic:
	print(k)

四、迭代器总结

优点：

1. 提供一种通用的且不依赖于索引的迭代取值方式

2. 同一时刻在内存中只存在一个值，更节省内存

缺点：

1. 取值不如按照索引的方式灵活，（不能取指定的某一个值，而且只能往后取）

2. 无法预测迭代器的长度

 l=[1,2,2,3,3,3,3,3,3,3,3,3,3,3]
iter_l=iter(l)
print(iter_l)

names = ['egon', 'alex', 'yxx']
res=map(lambda x:x+"_NB",names)
print(res)

obj=range(1,1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000)
print(obj)

五、生成器（迭代器函数）

#大前提：生成器就是一种自定义的迭代器，本质就是迭代器

#但凡函数内包含yield关键字，调用函数不会执行函数体代码，会得到一个返回值，该返回值就是生成器对象

eg1：

def func():
    print('first')
    yield 1
    print('second')
    yield 2
    print('third')
    yield 3
    print('fourth')

g=func()
# print(g)
# print(g.__iter__().__iter__() is g)

g.__next__()
g.__next__()
g.__next__()# 分别执行函数的三个阶段
# res1=next(g) #会触发函数的执行，直到碰到一个yield停下来，并且将yield后的值当作本次next的结果返回
# # print(res1)# 打印出来的是yield带出的返回值
#
# res2=next(g)
# # print(res2)
#
# res3=next(g)
# # print(res3)
#
# res4=next(g)

eg2：自己编写一个range函数

def my_range(start,stop,step=1):
    while start < stop: # 3 < 3
        yield start
        start+=step #start=3

obj=my_range(1,5,2) # 1 3

print(next(obj))
print(next(obj))
print(next(obj))

for i in my_range(1,10,2):
    print(i)

eg3：用yield传值

# 了解（*）：yield的表达式形式的应用: x=yield
def dog(name):
    print('狗狗 %s 准备开吃' %name)
    food_list=[]
    while True:
        food=yield food_list #  food=yield='肉包子'
        print('%s 吃了 %s' %(name,food))
        food_list.append(food)




g=dog('汪汪')

# 强调：针对表达式形式的yield的使用，第一步必须让函数先暂停到一个yield的位置，才能进行传值操作
# next(g) # 张开狗嘴，让生成器先暂停到yield的位置，准备接收外部传进来的值
res1=next(g) #g.send(None)
print(res1)

res2=g.send('屎包子') # 1. 先为当前暂停位置的yield赋值 2. next(生成器)直到再次碰到一个yield停下来，然后其的值当做本次next的结果
print(res2)

res3=g.send('肉包子')
print(res3)

res4=g.send('骨头')
print(res4)

总结yield:只能在函数内使用

1. yield提供了一种自定义迭代器的解决方案
2. yield可以保存函数的暂停的状态
3. yield对比return
   相同点：都可以返回值，值的类型与个数都没有限制
   不同点：yield可以返回多次值，而return只能返回一次值函数就结束了

应用：可以用yield实现协程