迭代器与生成器

一 迭代器

1、什么是迭代器

迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一层的结果而继续的，单纯的重复并不是迭代。

2、为何要有迭代器

迭代器是用来迭代取值的工具，而涉及到把多个值循环取出来的类型

l = ['egon', 'liu', 'alex']
i = 0
while i< len(l):
  	print(l[i])
    i +=1 

上述迭代取值的方式只适用于有索引的数据类型：列表、字符串、元组

为了解决基于索引迭代取值的局限性

python 必须提供一种能够不依赖于索引的取值方式，这就是迭代器

3、如何用迭代器

可迭代对象

可迭代对象：但凡内置有__ iter __方法都称之为可迭代对象

s1=''
s1.__iter__()

l=[]
l.__iter__()

t=(1,)
t.__iter__()

d={'a':1}
d.__iter__()

set1={1,2,3}
set1.__iter__()

with open('a.txt',mode='w') as f:
    f.__iter__()
    pass

迭代器对象

但凡内置有__ next __ 方法并且有 __ iter__ 都称之为迭代器对象

调用可迭代对象下的__ iter __方法会生成迭代器对象

具体有：打开的文件对象

d = {'a':1, 'b':2, 'c':3}
d_iterator = d.__iter__() #转成成迭代器对像
print(d_iterator) #迭代器对象

print(d_iterator.__next__) #a
print(d_iterator.__next__) #b
print(d_iterator.__next__) #c
print(d_iterator.__next__)#抛出异常 StopInteration

使用 while 循环迭代取值

while True:
  	try:
      	print(d_iterator.__next())
    except StopIteration:
    		break

3、可迭代对象与迭代器对象详解

3.1 可迭代对象（'可以生成迭代器的对象'）：

​ 内置有__ iter __ 方法的对象

​ 可迭代对象.__ iter __( ):得到迭代器对象

3.2 迭代器对象：

​ 内置有__ next __ 方法并且内置有 __ iter __方法的对象

​ 迭代器对象.__ iter __( ):得到的仍是迭代器本身。

​ 执行迭代器.__ next __( )（或 next（迭代器））就可以计算出迭代器的的下一个值。

迭代器是 python 提供的一种统一的，不依赖于索引的迭代取值方式，只要存在多个元素，无论序列类型还是非序列类型都可以按照迭代器的方式取值

可迭代对象：字符串、列表、元组、字典、集合、打开的文件

迭代器对象：打开的文件

python中为什么将文件对象内置为迭代器对象？

​ 原因是防止文件中内容过大，占用过多的内存空间，所以设置成迭代对象，

当需要一个值时，就计算出文件的一个值

4、for 循环的工作原理

d={'a':1, 'b':2, 'c':3}

for k in d:
  	print(k)

工作原理：

​ 1 d.__ iter __( )得到一个迭代器对象

​ 2 迭代器对象. __ next __( )拿到一个返回值，然后将该返回值赋值给 k

​ 3 循环往复步骤 2，直到抛出 StopIteration异常 for 循环会捕捉异常然后结束循坏

with open('a.txt',mode='rt',encoding='utf-8') as f:
    for line in f: # f.__iter__()
        print(line)

list('hello') #原理同 for 循环

5、迭代器优缺点

基于索引的迭代取值，所有迭代的状态都保存在了索引中，而基于迭代器实现迭代的方式不再需要索引，所有迭代的状态就保存在迭代器中。这种处理方式优缺点：

优点：

​ 1、为序列和非序列类型提供了一种统一的迭代取值方式

​ 2、惰性计算：迭代器对象标识的是一个数据流，它就是一个功能，占用内存空间非常小，可以只需要时才去调用 next来计算出一个值。

​ 就迭代器本身来说，它本身是一个功能，占用内存空间很小，同一时刻在内存中只有一个值，因而可以存放无线大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放与内存中，受内存大小的限制，可以存放的值的个数是有限的。

缺点：

​ 1、无法按索引取到指定的值

​ 2、每次都只能取下一个值，不能取已经取过的值，如果有两个或者多个循环使用同一迭代器。只会有一次循环能取到值，若想要迭代取同样的值，必须重新调用 __ iter __方法重新创新一个新的迭代器对象。

二 生成器与 yield

1、生成器

​ 生成器就是自定义的迭代器

​ 具体的说：函数体包含yield 关键字，再调用函数，此时并不会执行函数体代码，只是得到的一个返回值，即是生成器对象。

​ 只有通过调用迭代器的 next 的方法才能触发函数体代码运行

2、yield 关键字

​ yield 可以用于返回值，但不同于 return，函数一旦遇到了 return 就结束了，而 yield 可以保存函数的运行状态挂起函数，用来返回多次值

如下：

def func():
  	print('第一次')
    yield 1
    print('第二次')
    yield 2
    print('第三次')
    yield 3
    print('第四次')
    
g = func()  #产生生成器对象
print(g)
g.__iter__()
res = g.__next__()  #会触发函数体代码的运行，然后遇到 yield 停下来，将 yield 后值当做本次调用的结果返回

示例：

def my_range(start, stop, step=1):
    print('my_range is running...')
    while start < stop:
        yield start
        start += step
    print('my_range is end')


g = my_range(0, 4)  # 得到☝一个生成器对象，此时不会执行函数体代码
print(g)  # <generator object my_range at 0x107ee3e08>
res1 = g.__next__()
print(res1) #0
res2 = next(g)
print(res2) #1
res3 = next(g)
print(res3) #2
res4=next(g)
print(res4) #3
res5 = next(g)
print(res5) #抛出异常 StopIteration

生成器对象属于迭代器，所以可以使用 for 循环迭代取值，如下：

for k in my_range(0,5):
		print(k)
    
结果展示：
my_range is running...
0
1
2
3
4
my_range is end

只要函数体内有 yield ，那么函数名 +( )就是产生生成器，不会运行函数体代码

3、yield 表达式用法

用法一：x = yield

​ 生成器对象.send(实参 ) ：会将实参传给 yield

def dog(name):
  	print(f'{name} 准备吃东西！')
    while True:
      	x = yield  #x 拿到 yield 接收的值
        print(f'{name}吃了{x}')

g= dog('egon') #产生生成器对象
#初始化：第一次必须先传一个 None，将函数挂起
#next(g)
g.send(None) #等同于 next(g)
g.send('肉包子') #将 '肉包子' 传给 yield
g.send('一根骨头') #将'一根骨头'传给 yield
g.close() #关闭迭代器，无法传参
g.send('狗肉') #抛出异常StopIteration

用法二：x = yield 返回值

​ 生成器对象.send(实参 ) ：会将实参传给 yield

def dog(name):
    print('dog %s 准备吃东西了'%name)
    while True:
        # x 拿到的是 yield 接收到的值
        x = yield 1111  #先将yield的值传给 x后运行，然后直到遇到下一个yield，挂起函数并返回 111
        print('dog %s吃了%s'%(name, x))

g = dog('egon')#产生生成器对象
#第一次必须先传一个 None，将函数挂起（否则会报错），然后才能传
res=g.send(None) #等同于 next(g)
print(res) #111
res=g.send('肉包子') #将 '肉包子' 传给 yield
print(res) #1111
res = g.send('一根骨头') #将'一根骨头'传给 yield
print(res) #1111