生成器

#生成器
'''
通过列表生成式（列表推导式），可以直接创建一个列表
但是，受到内存限制，列表容量肯定是有限
而且，创建一个包含100万个元素的列表，不仅占用很大内存空间
如果我们仅仅需要访问前面几个元素，那后面大多数元素占用的空间都浪费了
所以，如果列表元素可以按照某种算法推算出来，那我们就可以在循环中不断推算出后续元素
这样就不必创建完整的list，节省大量空间
在python中，这种一边循环，一边计算的机制，成为生成器：generator

得到生成器的方式：
1 使用列表推导式得到生成器
2 借助函数完成

'''
#1 要得到[0,3,6,9,12,15,18,21,,,27]
newlist = [x*3 for x in range(15)]
print(newlist)
print(type(newlist)) #<class 'list'
#得到生成器：把外面的[]换成小括号：
g = (x*3 for x in range(5))
print(type(g)) #<class 'generator'>

#调用生成器：
#方式一：用__next__()来调用生成器，每次只生成一个数，只占用当前一个数字的内存
print(g.__next__())
print(g.__next__())
#方式二：next(生成器对象)，系统内置函数
print(next(g))
print(next(g))
print(next(g))
print(next(g)) #StopIteration - 生成器产生不出更多的数字了，会抛出异常，可以用try except接收这个异常并使用for循环

生成器第二部分：

#生成器
#函数中出现yield关键字，则该函数就是生成器
'''
用函数写生成器的步骤：
1 定义一个函数，函数中使用yield关键字
2 调用函数，接收一下调用的结果
3 得到的结果就是生成器
4 借助于next()或者__next__()来得到元素

'''


'''
g = (x*3 for x in range(5))
while True:
    try:
        e = next(g)
        print(e)
    except StopIteration as err:
        print('打印完成')
        break
'''

#斐波那切数列
'''
def func():
    n = 0
    while True:
        n += 1
        yield n #当函数中出现yield关键字，则该函数就是生成器
        #yield类似return，yield还表示暂停的意思，下次执行时候从刚才停的位置继续执行
g = func()
print(g) #<generator object func at 0x0359DC70>
print(next(g))
print(next(g))
print(next(g))
print(next(g))
'''

def fib(length):
    a,b = 0,1
    n = 0
    while n < length:
        #print(b)
        yield b #返回b，并在此处暂停
        a,b = b,a+b
        n += 1
    return '没有更多元素了'#什么时候能返回abc:如果生成器没有任何可以生成的内容，则把要StopIteration的报错信息放在return里
g = fib(6)
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g))
print(next(g)) #StopIteration: 没有更多元素了

生成器第三部分：send()

'''
生成器方法：
1 __next__(): 获取下一个元素
2 send(value): 向每次生成器调用中传值，注意：第一次调用send(None)，必须往里传None，才可以继续send

'''

def gen():
    i = 0
    while i < 5:
        temp = yield i #temp: None. 把下一次send过来的值赋给temp，可以打印temp的值了，第一次的赋值必须是None
        print('temp: ',temp)
        for x in range(int(temp)):
            print('---> ', x)
        print('*******************')
        i += 1
    return '没有更多的数据了'
g = gen()
#print(next(g))
#print(next(g))
#print(next(g))
#print(next(g))
#print(next(g))
#print(next(g))

#g.__next__()
#g.send(): 生成器里的一个方法
'''
print(g.send(None)) #第一次赋值必须是None
n1 = g.send('haha')
print('n1: ',n1) #TypeError: can't send non-None value to a just-started generator
'''
print(g.send(None))
n2 = g.send(3)
print('n2: ',n2)
n3 = g.send(2)
print('n3: ',n3)

生成器应用：

#进程，线程，协程
#一个进程可以包含多个线程，一个线程可以包含多个协程
#协程底层就是用生成器做的

'''
def task1(n):
    for i in range(n):
        print('正在搬第{}块砖'.format(i))

def task2(n):
    for i in range(n):
        print('正在听第{}首歌'.format(i))

#任务交替运行：板一块砖，听一首歌
task1(10)
task2(5)
'''
#用生成器来让两个任务切换
def task1(n):
    for i in range(n):
        print('正在搬第{}块砖'.format(i))
        yield #yield后面可以不接内容，表示只暂停，不往外扔东西，或只扔空

def task2(n):
    for i in range(n):
        print('正在听第{}首歌'.format(i))
        yield None

g1 = task1(5)
g2 = task2(5)

while True:
    try:
        next(g1)
        next(g2)
    except:
        print('没事啦')
        break

################################################################

https://blog.csdn.net/mieleizhi0522/article/details/82142856

先把yield理解为return

#!/usr/bin/python3.5
# -*- coding=utf-8 -*-

def foo():
	print('starting...')
	while True:
		res = yield 4
		print('res:',res)

g=foo()
print(next(g))
print('*'*20)
print(next(g))

　　

root@ubuntu:/home/vigossr/exercise# ./yield_ex.py
starting...
4
********************
res: None
4

我直接解释代码运行顺序，相当于代码单步调试：

1.程序开始执行以后，因为foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)

2.直到调用next方法，foo函数正式开始执行，先执行foo函数中的print方法，然后进入while循环

3.程序遇到yield关键字，然后把yield想想成return,return了一个4之后，程序停止，并没有执行赋值给res操作，此时next(g)语句执行完成，所以输出的前两行（第一个是while上面的print的结果,第二个是return出的结果）是执行print(next(g))的结果，

4.程序执行print("*"*20)，输出20个*

5.又开始执行下面的print(next(g)),这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是要执行res的赋值操作，这时候要注意，这个时候赋值操作的右边是没有值的（因为刚才那个是return出去了，并没有给赋值操作的左边传参数），所以这个时候res赋值是None,所以接着下面的输出就是res:None,

6.程序会继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.

到这里你可能就明白yield和return的关系和区别了，带yield的函数是一个生成器，而不是一个函数了，这个生成器有一个函数就是next函数，next就相当于“下一步”生成哪个数，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从foo函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。

#!/usr/bin/python3.5
# -*- coding=utf-8 -*-

def foo():
	print('starting...')
	while True:
		res = yield 4
		print('res:',res)

g=foo()
print(next(g))
print('*'*20)
#print(next(g))
print(g.send(7))

　　root@ubuntu:/home/vigossr/exercise# ./yield_ex.py 

starting...
4
********************
res: 7
4
root@ubuntu:/home/vigossr/exercise#

先大致说一下send函数的概念：此时你应该注意到上面那个的紫色的字，还有上面那个res的值为什么是None，这个变成了7，到底为什么，这是因为，send是发送一个参数给res的，因为上面讲到，return的时候，并没有把4赋值给res，下次执行的时候只好继续执行赋值操作，只好赋值为None了，而如果用send的话，开始执行的时候，先接着上一次（return 4之后）执行，先把7赋值给了res,然后执行next的作用，遇见下一回的yield，return出结果后结束。

5.程序执行g.send(7)，程序会从yield关键字那一行继续向下运行，send会把7这个值赋值给res变量

6.由于send方法中包含next()方法，所以程序会继续向下运行执行print方法，然后再次进入while循环

7.程序执行再次遇到yield关键字，yield会返回后面的值后，程序再次暂停，直到再次调用next方法或send方法。