12--迭代器+生成器

一 、迭代器

1 什么是迭代器

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

2 为何要有迭代器

# 1 为了找到一种统一迭代取值方案（适用于str、list、tuple、dict、set，文件对象）
# 2 节省内存


迭代器是用来迭代取值的工具，而涉及到把多个值循环取出来的类型
    有：列表、字符串、元组、字典、集合、文件
    
    l=['egon','liu','alex']
    i=0
    while i < len(l):
        print(l[i])
        i+=1
        
    上述迭代取值的方式只适用于有索引的数据类型：列表、字符串、元组
    为了解决基于索引迭代器取值的局限性
    python必须提供一种能够不依赖于索引的取值方式，这就是迭代器

3 如何用迭代器

3.1可迭代对象与迭代器对象

# 1.可迭代对象：     "可以转换成迭代器的对象" 
    1.内置有__iter__方法的对象   # str、list、tuple、dict、set，文件对象
    2.可迭代对象.__iter__(): 得到迭代器对象

    # eg:
      s1=''          # 字符串s1 是可迭代对象
      s1.__iter__()  # 调用iter() 变成迭代器对象
        
        
# 2.迭代器对象：  内置有__iter__方法 且内置有__next__方法的对象
    1.迭代器对象.__next__（）：得到迭代器的下一个值
    2.迭代器对象.__iter__（）：得到迭代器的本身，说白了调了跟没调一个样子
      但迭代器对象为什么要有__iter__（）？
      是为了for循环能够统一调用可迭代对象和迭代器对象。
    3.内置迭代器对象：只有文件对象

dic={'a':1,'b':2,'c':3}
dic_iterator=dic.__iter__()   # dic_iterator  迭代器对象
print(dic_iterator is dic_iterator.__iter__().__iter__())  # True


# 3.内置对象总结
    可迭代对象：字符串、列表、元组、字典、集合、文件对象
	迭代器对象：文件对象
    
    # 故：迭代器对象一定是可迭代对象，但可迭代对象不一定是迭代器对象


# eg:
s={1,2,3}  # 可迭代对象s
i=iter(s)  # 本质就是在调用s.__iter__(), 返回s的迭代器对象i，
next(i)    # 本质就是在调用i.__next__()
next(i)
next(i)
next(i)    # 抛出StopIteration的异常，代表无值可取，迭代结束

3.2for循环的工作原理

# for循环的工作原理： for循环可以称之为叫迭代器循环
  1.d.__iter__() 得到一个迭代器对象
  2.迭代器对象.__next__() 拿到一个返回值，然后将该返回值赋值给k
  3.循环往复步骤2，直到抛出StopIteration异常，for循环再捕捉异常然后结束循环

d={'a':1,'b':2,'c':3}
for k in d:
    print(k)

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

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


# while循环 实现迭代取值
goods=['mac','lenovo','acer','dell','sony']
i=iter(goods)  # 迭代完成后，若要重新取值，需要重新获取一个迭代器对象
while True:
    try:
        print(next(i))
    except StopIteration:  # 捕捉异常终止循环
        break

3.3 迭代器优缺点

# 1.优点：
  I. 为序列和非序列类型提供了一种统一的迭代取值方式。
  II.惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值。

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

  这也是为什么直接把文件对象 定义成迭代器对象？
  因为文件对象是操作系统给python的，极有可能文件对象数据特别大
  就防止读取文件对象内存占满，故将设置成迭代器对象。

# 2.缺点：
  I. 除非取尽，否则无法获取迭代器的长度
  II.只能取下一个值，不能回到开始，更像是‘一次性的’ 

  迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用next；
  若是要再次迭代同个对象，你只能重新调用iter方法去创建一个新的迭代器对象
  如果有两个或者多个循环使用同一个迭代器，必然只会有一个循环能取到值。

二、生成器

1 如何产生生成器--yield

生成器即自定义的迭代器

# 如何得到自定义的迭代器：   通过关键字 yield 自定义

  1.若函数体包含yield关键字，再函数调用时，并不会执行函数体代码，
    而是返回一个生成器对象
    
  2.生成器内置有.__iter__()和.__next__()方法，故生成器本身就是一个迭代器
    
# eg:
def func():
    print('第一次')
    yield 1
    print('第二次')
    yield 2
    print('第三次')
    yield 3
    print('第四次')

g=func()   # 生成器对象g
print(g)   # <generator object my_range at 0x104105678>

# 生成器就是通过关键字 yield 自定义的迭代器
g.__iter__()
g.__next__()

2 生成器.next() 执行流程

# 前提：
  生成器函数 调用时，不会触发函数体代码的执行
  只有在生成器对象执行next方法时，才触发函数体代码的运行

  # 生成器对象g 或者 生成器函数体内，一个值也没有; 只有在next调用时，才会产出一个临时的值

    
# 生成器对象.next() 执行流程
  1.触发函数执行直到遇到yield停下来，将yield后的值当做本次调用的结果返回，并在当前位置挂起函数
  2.再次调用next(g)，函数从上次暂停的位置继续执行，直到重新遇到yield
  3.直到没有遇到yield则无值返回，即取值完毕抛出异常结束迭代
    

# eg:
res1=g.__next__()  # 第一次
print(res1)        # 1

res2=g.__next__()  # 第二次
print(res2)        # 2

res3=g.__next__()  # 第三次
print(res3)        # 3

res4=g.__next__()  # 第四次
# 报错，没有第四次的yield，停止迭代了

3 应用--自定义range功能

# 应用案列
def my_range(start,stop,step=1):
    # print('start...')
    while start < stop:
        yield start
        start+=step
    # print('end....')


g=my_range(1,5,2) # 强调：此时生成器对象g一个值也没有

print(next(g))  # 1
print(next(g))  # 3
print(next(g))  # 报错


# 也可for循环
for n in my_range(1,7,2):
    print(n)

4 高级--yield表达式

4.1 yield表达式形式

# 形式
x = yield 返回值   # 此时 x = yield接受的值，不是后面的返回值

# 核心：有两个值，
  1.yield本身值：可以有值传入，并传递给变量  # 通过调用 生成器.send() 为yield传值
  2.yield功能：返回yield后面的返回值

# 强调：
  针对表达式形式的yield，生成器对象必须事先被初始化一次，必须先传值 g.send(None)或者next(g)
  让函数挂起在x=yield的位置，等待调用g.send()方法为函数体传值
  next(g) <===> g.send(None)

    
# 简单示例
def func():
    print('start.....')
    x=yield 1111   # x='xxxxx'
    print(x)
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    yield 2222

g=func()
res=next(g) # 运行到第一个yield 暂停，并把返回值1111 返回
print(res)  # 1111

res=g.send('xxxxx')  
# 继续运行，把'xxxxx' 传给暂停位置的yield（即第一个yield），
# 再往下执行，需要第二个yield暂定，并把返回值2222 返回
print(res)  # 2222

4.2 初始操作可使用装饰器

def init(func):
    def wrapper(*args,**kwargs):
        g=func(*args,**kwargs)
        next(g)
        return g
    return wrapper

@init
def func():
    print('start.....')
    x=yield 1111   # x='xxxxx'
    print(x)
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    print('哈哈哈啊哈')
    yield 2222
    
g=func()

res=g.send('xxxxx')  
print(res)  # 2222

4.3 案例应用

def dog(name):
    food_list=[]
    print('道哥%s准备吃东西啦...' %name)
    while True:
        # x拿到的是yield接收到的值
        x = yield food_list  
        print('道哥%s吃了 %s' %(name,x))
        food_list.append(x) 

        
g=dog('alex')
res=g.send(None)  
print(res)  # []  返回的是 food_list

res=g.send('一根骨头')
print(res)  # ['一根骨头']

res=g.send('肉包子')
print(res)  # ['一根骨头', '肉包子']

g.close()
g.send('一同泔水')  # 关闭之后无法传值

5 yield总结 ***

# 总结yield：
  有了yield关键字，我们就有了一种自定义迭代器的实现方式。
    
  1.yield 可用于返回值
    但不同于return，函数一旦遇到return就结束了，
    而yield可以保存函数的运行状态挂起函数，用来返回多次值
    
  2.yield 可接受传值，并传递给变量 
    注：第一次传值，必须为None，做初始化操作  # next(g) 或 g.send(None)