生成器

一、yield关键字（生成器）

yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。

def func():
    print(1)
    yield
    print(2)
    yield


g = func()
print(g)

生成器的本质就是迭代器，同时也并不仅仅是迭代器，不过迭代器之外的用途实在是不多，所以我们可以大声地说：生成器提供了非常方便的自定义迭代器的途径。并且从Python 2.5+开始，[PEP 342：通过增强生成器实现协同程序]的实现为生成器加入了更多的特性，这意味着生成器还可以完成更多的工作。这部分我们会在稍后的部分介绍。

def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()
print(g)
print(g.__iter__()) # 迭代器

print(F"g.__iter__ == g: {g.__iter__() == g}")

res1 = g.__next__()
print(f"res1: {res1}")

res2 = next(g)
print(f"res2: {res2}")

<generator object func at 0x02B38C90>
<generator object func at 0x02B38C90>
g.iter == g: True
from func 1
res1: a
from func 2
res2: b

def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()
for i in g:
    print(i)
# 转化成列表 会将print自动打印出来
print(f"list(func()): {list(func())}") # 转化成列表

from func 1
a
from func 2
b

from func 1
from func 2
list(func()): ['a', 'b']

二、yield和return区别

既然生成器函数也是函数，那么它可以使用return输出返回值吗？

既然你都选择自定义一个函数作为生成器，你还return干啥？如果这是在Python2中，Python解释器会赠送给你一个异常，但是在Python3中，他也不管你这种傻瓜行为了。课件return也会终止生成器的执行，也没多大的意义所在，也无法捕获return返回的值；可以通过异常进行捕获获取except StopIteration as exc:print(exc.value) ，获取返回的值也可以通过yield from捕获；

在使用yield生成器的时候，如果使用for语句去迭代生成器，则不会显式的出发StopIteration异常，而是自动捕获StopIteration异常，所以如果遇到return，只是会终止迭代，而不会触发异常，故而也就没办法获取return的值。如下：

def yield_return():
    yield 'a'
    yield 'b'
    return None
    yield 'c'


for i in yield_return():
    print(i)

a
b

三、迭代器套迭代器

如果我需要在生成器的迭代过程中接入另一个生成器的迭代怎么办？写成下面这样好傻好天真。并且你这样做的意图是什么？使用for循环嵌套会发现，当函数调用时候就会打印生成器，所以使用for循环是不可取的

def sub_generator():
    yield 1
    yield 2
    for i in range(3):
        yield i


for i in sub_generator():
    print(i)

0
1
2

函数第一加载则是运行，所有先循环三次打印

1
2

0
1
2

因为底层是迭代器进行__next__,所有会执行后面的for循环，发现还是生成器，继续__next__获取下一个值

使用range

yield from generator（可迭代对象）(参考)[https://blog.csdn.net/qq_27825451/article/details/85244237]

简单地说，yield from generator 。实际上就是返回另外一个生成器。而yield只是返回一个元素。从这个层面来说，有下面的等价关系：yield from iterable本质上等于 for item in iterable: yield item 。

def sub_generator():
    yield 1
    yield 2

    yield from range(3) # 有意思


for i in sub_generator():
    print(i)

1
2
0
1
2

四、协同程序

协同程序（协程）一般来说是指这样的函数：

彼此间有不同的局部变量、指令指针，但仍共享全局变量；
可以方便地挂起、恢复，并且有多个入口点和出口点；
多个协同程序间表现为协作运行，如A的运行过程中需要B的结果才能继续执行。

协程的特点决定了同一时刻只能有一个协同程序正在运行（忽略多线程的情况）。得益于此，协程间可以直接传递对象而不需要考虑资源锁、或是直接唤醒其他协程而不需要主动休眠，就像是内置了锁的线程。在符合协程特点的应用场景，使用协程无疑比使用线程要更方便。

从另一方面说，协程无法并发其实也将它的应用场景限制在了一个很狭窄的范围，这个特点使得协程更多的被拿来与常规函数进行比较，而不是与线程。当然，线程比协程复杂许多，功能也更强大，所以我建议大家牢牢地掌握线程即可，是不是听了一脸懵逼，那么就别管他了，以下介绍的方法了解即可。

由于Python2.5+对生成器的增强实现了协程的其他特点，在这个版本中，生成器加入了如下方法：

4.1 send(value)

send是除next外另一个恢复生成器的方法。Python2.5+中，yield语句变成了yield表达式，这意味着yield现在可以有一个值，而这个值就是在生成器的send方法被调用从而恢复执行时，调用send方法的参数。

def h():
    print('--start--')
    first = yield 5  # 等待接收 Fighting! 值
    print('1', first)
    second = yield 12  # 等待接收 hahaha! 值
    print('2', second)
    yield 13
    print('--end--')


g = h()
first = next(g)  # m 获取了yield 5 的参数值 5
# (yield 5)表达式被赋予了'Fighting!',  d 获取了yield 12 的参数值12
second = g.send('Fighting!')
third = g.send('hahaha!')  # (yield 12)表达式被赋予了'hahaha!'
print(f'--over--')
print(f"first:{first}, second:{second}, third:{third}")

--start--
1 Fighting!
2 hahaha!
--over--
first:5, second:12, third:13
--end--

调用send传入非None值前，生成器必须处于挂起状态，否则将抛出异常。不过，未启动的生成器仍可以使用None作为参数调用send。
如果使用next恢复生成器，yield表达式的值将是None

4.2 close()

这个方法用于关闭生成器。对关闭的生成器后再次调用next或send将抛出StopIteration异常。

def repeater():
    n = 0
    while True:
        n = (yield n)


r = repeater()
r.close()
print(next(r))  # StopIteration

4.3 throw(type, value=None, traceback=None)#

中断Generator是一个非常灵活的技巧，可以通过throw抛出一个GeneratorExit异常来终止Generator。Close()方法作用是一样的，其实内部它是调用了throw(GeneratorExit)的。我们看close的源代码：

def close(self):
    try:
        self.throw(GeneratorExit)
    except (GeneratorExit, StopIteration):
        pass 
    else:
        raise RuntimeError("generator ignored GeneratorExit") # Other exceptions are not caught

五、自定义range()方法

def range(*args, step=1):
    args = list(args)
    if len(args) == 1:
        count = 0
        while count < args[0]:
            yield count
            count += step
    elif len(args) == 2:
        while args[0] < args[1]:
            yield args[0]
            args[0] += step

            
g = range(5)
for i in range(3):
    print(i)

def range(*args, **kwargs):
    if not kwargs:
        if len(args) == 1:
            count = 0
            while count < args[0]:
                yield count
                count += 1
        if len(args) == 2:
            start, stop = args
            while start < stop:
                yield start
                start += 1
        if len(args) == 3:
            start, stop, step = args
            while start < stop:
                yield start
                start += step

    else:
        step = 1

        if len(args) == 1:
            start = args[0]
        if len(args) == 2:
            start, stop = args

        for k, v in kwargs.items():
            if k not in ['start', 'step', 'stop']:
                raise ('参数名错误')

            if k == 'start':
                start = v
            elif k == 'stop':
                stop = v
            elif k == 'step':
                step = v

        while start < stop:
            yield start
            start += step


for i in range(3):
    print(i)
print('*' * 50)
for i in range(99, 101):
    print(i)
print('*' * 50)
for i in range(1, 10, 3):
    print(i)
print('*' * 50)
for i in range(1, step=2, stop=5):
    print(i)
print('*' * 50)
for i in range(1, 10, step=2):
    print(i)

六、生成器表达式

# 把列表推导式的[]换成()
lt = [i for i in range(10000000)]
print(lt)

# 生成器表达式
g = (i for i in range(10000000))
print(g)
print(g.__next__())

# 列表和元组的区别
# 列表就是一筐鸡蛋,元组是一只老母鸡(节省空间)

<generator object at 0x031664E0>
0

七、总结

yield的三个特性：

yield可以把函数变成生成器（自定制的迭代器对象，具有__iter__和__next__方法） ******
yield可以停止函数，再下一次next再次运行yield下面的代码
有n个yield生成器就有n个元素，就可以next n次，第n+1次next会报错

return 的特性：

返回值
终止函数

yield和return:

相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
不同点：return只能返回一次之；yield可以返回多次值

在当下的阶段，必将由程序员来主导，甚至比以往更甚。