python 生成器

生成器 generator **

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

# 生成器表达式
m = (i for i in range(5))
print(type(m))    # <class 'generator'>
print(next(m))    # 0
print(next(m))    # 1

1、生成器函数
　　函数体中包含 yield 语句的函数， 就是生成器函数，调用后返回生成器对象。

def inc():
    for i in range(5):
        print('~' * 10)
        yield i    # yield 语句，暂停函数执行
        print('#' * 10)

print(type(inc))   # 函数:<class 'function'>
print(type(inc())) # 函数调用的类型:<class 'generator'>
    
g = inc()
print(next(g))     # 0
print(next(g))     # 1 暂停函数执行，拨一下、转一下
for x in g:
    print(x)

　　普通函数调用，函数会立即执行直到执行完毕。
　　生成器函数调用，并不会立即执行函数体，而是需要使用 next 函数来驱动生成器函数执行后获得的生成器对象。
　　生成器表达式和生成器函数都可以得到生成器对象，只不过生成器函数可以写的更加复杂的逻辑。

2、生成器的执行

def gen():
    print(111111)
    yield 1
    print(222222)
    yield 2
    print(333333)
    return 3  # 结束当前函数
    yield 4


g = gen()     # 返回生成器对象，并不立即执行
print(next(g))
# 111111
# 1
print(next(g))
# 222222
# 2
print(next(g))
# 333333
# StopIteration: 3

def fn():
    for i in range(5):
        yield i

g = fn()
for i in g:
    print(i)
if next(g, None) is None:  # next 缺省值
    print('end')

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

3、生成器函数总结

　　包含 yield 语句的生成器函数调用后，生成生成器对象的时候。生成器函数的函数体不会立即执行。
　　next(generator) 会从函数的当前位置向后执行到之后碰到的第一个 yield 语句， 会弹出值，并暂停函数执行。
　　再次调用 next 函数，和上一条一样的处理过程。
　　继续调用 next 函数，生成器函数如果结束执行了（显式或隐式调用了 return 语句），会抛出 Stoplteration 异常。

4、生成器应用

4.1 无限循环

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

g = inc()       # 可迭代对象、迭代器、生成器
print(next(g))  # 1
print(next(g))  # 2
print(next(g))  # 3

4.2 计数器

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

def inc(c=counter()):    # 引用类型
    return next(c)       # 返回生成器
print(inc.__defaults__)  # inc.__defaults__ = (counter(),)

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

def inc():
    def counter():
        count = 0
        while True:
            count += 1
            yield count
    c = counter()              # 生成器对象
    return lambda : next(c)    # 匿名函数对象，闭包
    #def fn():
    #    return next(c)
    #return fn

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

4.3 斐波那契数列

def fib():
    x, y = 0, 1
    while True:
        yield y
        x, y = y, x + y

f = fib()
for i in range(10):
    print(next(f))

4.4 生成器交互

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

def counter():
    count = 0
    while True:
        count += 1
        response = yield count    # 先算右边，暂停函数执行
        if response is not None and isinstance(response, int):
            count = response

c = counter()
print(next(c))     # 1
print(next(c))     # 2
print(next(c))     # 3
print(c.send(100)) # 101
print(next(c))     # 102

# 重置计数器
def inc():
    def counter():
        count = 0
        while True:
            count += 1
            response = yield count
            if response is not None and isinstance(response, int):
                count = response
    c = counter()
    return lambda x = False : c.send(0) if x else next(c)    # 闭包

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

　　调用 send 方法，就可以把 send 的实参传给 yield 语句做结果，这个结果可以在等式右边被赋值给其它变量。
　　send 和 next 一样可以推动生成器启动并执行。

4.5 协程 Coroutine

　　生成器的高级用法；
　　它比进程、线程轻量级，是在用户空间调度函数的一种实现；
　　Python3 asyncio 就是协程实现，已经加入到标准库；
　　Python3.5 使用 async、await 关键字直接原生支持协程；

　　协程调度器实现思路：
　　　　有2个生成器A、B，next(A) 后，A 执行到了 yield 语句暂停，然后去执行 next(B)，B 执行到 yield 语句也暂停，然后再次调用 next(A)，再调用 next(B)，周而复始，就实现了调度的效果。

　　可以引入调度的策略来实现切换的方式，协程是一种非抢占式调度。

# 例：协程实现，分别调度计数器1、2
def counter():
    count = 0
    while True:
        count += 1
        yield count

c1 = counter()
c2 = counter()
for i in range(5):
    print(next(c1))
    next(c2)
    print(next(c2))

# 执行结果：
1
2  # c2
2
4  # c2
3
6  # c2
4
8  # c2
5
10  # c2

5、yield from 语法

　　从 Python 3.3 开始增加了 yield from 语法，使得 yield from iterable 等价于for item in iterable: yield item。
　　yield from就是一种简化语法的语法糖。

def foo():
    for i in range(5):
        yield i

# 使用 yield from 语法简化
def foo():
    yield from range(5)

　　本质上 yield from 的意思就是，从 from 后面的可迭代对象中拿元素一个个 yield 出去。