#codomg:UTF-8
#出处：http://www.runoob.com/w3cnote/python-yield-used-analysis.html
"""怎么用Python生成一个Fibonacci数列"""
def Fibonacci_1(N):
""" 斐波那契1.0
        简单地输出N个斐波那契数
        点评:大概是一个程序员new bee写的，用print复用性太差了
"""
    n, a, b = 0, 0, 1
    while n < N:
        print b
        a, b = b, a+b
        n=n+1

def Fibonacci_2(N):
""" 斐波那契2.0
        返回到N的斐波那契数组
        点评:应该是一个稍有经验的程序员的成果，但是内存随着N增大而增大，浪费内存
"""
    n, a, b = 0, 0, 1
    L=[]
    while n < N:
        L.append(b)
        a, b = b, a+b
        n = n+1
    return L

class Fibonacci_3(object)):
""" 斐波那契3.0
        用一个迭代对象来存斐波那契数
        点评:看样子是出自一个经验丰富的程序员之手，但是我只是要一个斐波那契数，这么长的代码吗？
"""
    def __init__(self, N):
        self.N = N
        self.n, self.a, self.b = 0, 0, 1
    
    def __iter__(self):
        return self
    
    def next(self):
        if self.n < self.N:
            r = self.b
            self.a, self.b = self.b, self.a+self.b
            self.n = self.n + 1
            return r
        raise StopIteration()

def Fibonacci_4(N):
""" 斐波那契4.0
        yield迭代
        厉害了，只跟1.0差一行代码，这一定是一位资深大牛的作品，其实只是熟悉迭代，就是这么简单
"""
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a+b
        n = n+1

#下面的意见部分参考了知乎用户饭后温柔的意见
#https://www.zhihu.com/question/20511233/answer/24459911
"""迭代，就是协程的典型应用
    一般来说，函数我们输入一样的值，就会产生相同的输出。
    而对于迭代对象，每次调用都仅执行一次，但保留当前状态，等待下次调用，衔接上次执行
    达到了相同的输入，不同的输出
    类似于存在一个限制了使用域的全局变量
    虽然输入都一样，但是每次调用都会变更这个变量
    yield就是触发协程的一个关键字
    yield会保存当前内存上下文状态，然后return当前值
    下次调用函数读取状态继续执行
    在上古时代，C语言还没一统天下的那个年代
    函数的命名五花八门，其中有一个名字其实特别形象，是真正符合函数与系统定义的
    那就是“过程”
    对于CPU与系统来说。
    过程是一个独立的，单向的，不可中断的操作，一个过程就要进行到底
    协程是一个独立的，单向的，可中断的操作，多个协程可切换操作，在早期单线程处理器时代可以达到最大化利用CPU的目的，即使现在也是一样
    线程是一组协程或过程组成的活动，多个线程共享资源，但是对资源要进行控制，是多线程处理器的最小处理单元
    进程是一组线程组成的活动，具有较高的独立性，是系统进行资源分配和调度的基本单位
    看到这里我忽然想，一组进程归并起来是不是能出来一个新的程
    这样就叫他集程好了
    其实就是服务器集群
    k8s就是一个集程管理系统，用于服务器集群的负载均衡，也就是资源分配和调度
    厉害了，一个新的概念就此诞生。
"""

""" 如果还不是很清晰协程的概念，再来廖雪峰提供的例子 """
#出处：https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0013868328689835ecd883d910145dfa8227b539725e5ed000
import time

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s...' % n)
        time.sleep(1)
        r = '200 OK'

def produce(c):
    c.next()
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s' % r)
    c.close()

if __name__=='__main__':
    c = consumer()
    produce(c)

"""执行结果
    [PRODUCER] Producing 1...
    [CONSUMER] Consuming 1...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 2...
    [CONSUMER] Consuming 2...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 3...
    [CONSUMER] Consuming 3...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 4...
    [CONSUMER] Consuming 4...
    [PRODUCER] Consumer return: 200 OK
    [PRODUCER] Producing 5...
    [CONSUMER] Consuming 5...
    [PRODUCER] Consumer return: 200 OK

    注意到因为使用的yield，consumer变成一个generator（迭代生成器），把一个consumer传入produce后：

    首先调用c.next()启动迭代；

    然后，一旦生产了东西，通过c.send(n)切换到consumer执行；

    consumer通过yield拿到消息，处理，又通过yield把结果传回；

    produce拿到consumer处理的结果，继续生产下一条消息；

    produce决定不生产了，通过c.close()关闭consumer，整个过程结束。

    整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

    最后套用Donald Knuth的一句话总结协程的特点：

    “子程序就是协程的一种特例。”
"""