生成器

生成器指的是生成器对象，可以有生成器表达式获得，也可以由yield关键字得到一个生成器，调用这个函数得到一个生成器对象。生成器对象是一个可迭代对象，是一个迭代器。生成器对象是延迟计算、惰性求值的。

生成器函数

函数体中包含yield语句的函数，就是生成器函数，调用该函数返回一个生成器对象。

m = (i for i in range(5)) # 生成器表达式
next(m)
next(m)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

# 生成器函数：
def inc():
    for i in range(5):
        yield i
        
print(type(inc)) # 
print(type(inc())) # 

g = inc()
print(type(g)) # 
print(next(g)) # 0
for x in g:
    print(x) # 1 2 3 4
for y in g:
    print(y) 

普通函数调用，函数会立即执行到执行完毕。生成器函数调用，并不会立即执行，而是需要使用next函数来驱动其执行生成器函数调用后获得的生成器对象。

生成器函数相对于生成器表达式的优势在于：生成器的代码可以写的更加复杂。

生成器的执行

def gen():
    print('line 1')
    yield 1
    print('line 2')
    yield 2
    print('line 3')
    return 3
    yield 4

next(gen()) # line 1
next(gen()) # line 1
g = gen() # line 1
print(next(g)) # 1 & line 2 
print(next(g)) # 2 & line 3
# print(next(g)) # StopIteration: 3
print(next(g, 'end')) # 生成器没有元素了，给个默认值

• 在生成器函数中，可以多次yield，每执行一次yield后会暂停执行，把yield表达式的值返回
• 再次执行会执行到下一个yield又会暂停
• return语句依然可以终止函数运行，但return的值不可能被捕获到
• return会导致当前函数返回，无法继续执行也无法继续获取下一个值，抛出StopIteration异常
• 如果函数没有显示的return语句，如果生成器执行到了结尾（相当于return None），一样会抛出StopIteration异常

总结：

1. 包含yield语句的生成器函数调用后，生成生成器对象的时候，函数体并不会执行（也就是，g = gen()不会使得 print('line 1') 执行）
2. next(generator)会从函数的当前位置向后执行，直到碰到yield语句，会弹出值，并暂停函数运行
3. 再次调用next()，和上面一样
4. 继续调用next，如果生成器结束执行了(显示/隐式调用return语句)，会抛出StopIteration异常

生成器应用

1、无限循环

def counter():
    i = 0
    while True:
        i += 1
        yield i
        
c = counter()
next(c)
next(c)
next(c)
...

2、计数器

def inc():
    def counter():
        i = 0
        while True:
            i += 1
            yield i

    c = counter()
    return next(c)

print(inc()) # 1
print(inc()) # 1
print(inc()) # 1

思考：为什么都是返回1？-- 因为函数的调用都是独立的，每次的inc()都使用一个新的counter ，所以每次都能返回1。

修改：

def inc():
    def counter():
        i = 0
        while True:
            i += 1
            yield i
            
    c= counter()
    def inner():
        return next(c)
    return inner # 可以用lambda函数代替

foo = inc()
print(foo()) # 1
print(foo()) # 2 
print(foo()) # 3

思考：为什么能够打印1，2，3？ -- 因为inc()这次返回的是一个函数对象而非常量，且这个函数对象是在inc内部定义的，所以inc函数不会在栈内释放，即counter函数，c，inner函数都在inc函数的栈帧中；调用foo，就是调用inner函数，inner函数返回 next(c)，c 是 inner函数外部的自由变量 (闭包)，c 是唯一的且被next()多次调用，所以能返回1 2 3。

3、斐波那契数列

def fib():
    x = 0
    y = 1
    while True:
        yield y
        x, y = y, x+y
        
foo = fib()
for i in range(100):
    next(foo)

4、生成器交互

python提供了一个和生成器对象交互的方法send，该方法可以和生成器沟通。

# 带重置功能的计数器
def inc():
    def counter():
        i = 0
        while True:
            i += 1
            response = yield i 
            if response is not None: # 重置功能
                i = response
            
    c= counter()
    return lambda x=False: next(c) if not x else c.send(0) 
    
foo = inc()
print(foo())
print(foo())
print(foo())
print(foo(True))
print(foo())
print(foo())

• 调用生成器的send方法，可以将send的实参传给yield做结果，这个结果可以在等式右边被赋值给其他变量
• send 和 next 一样，可以推动生成器执行

5、协程Coroutine

• 生成器的高级语法
• 它比线程、进程轻量级，实在用户空间的调度函数的一种体现
• Python3 asyncio 就是协程实现，已经加入到标准库
• python 3.5 使用 async、await 关键字支持原生协程
• 协程调度器实现思路：
  • 有两个生成器A、B
    • next(A) 之后，A执行到了yield语句暂停，然后去执行next(B)，B执行到yield语句也暂停，然后再次调用next(A)，再调用next(B)，周而复始，就实现了调度的效果
    • 可以引入调度的策略来实现切换的方式
• 协程是一种非抢占式调度，只要没有遇到yield，就能一直执行下去，不会被抢占运行的权力

yield from 语法

从python3.3开始增加了yield语法，使得 yield from iterable 等价于 for item in iterable: yield item 。

yield from 就是一种语法糖。本质上就是在 iterable 中拿元素一个个 yield 出去。

def inc():
    yield from range(1000)
    
foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))