DevOps 与 敏捷开发的关系

devOps 流程

programming_process

yield

#encoding:UTF-8  
def yield_test(n):  
    for i in range(n):  
        yield call(i)  
        print("i=",i)  
    #做一些其它的事情      
    print("do something.")      
    print("end.")  
  
def call(i):  
    return i*2  
  
#使用for循环  
def kk(jj):
    for i in yield_test(jj):  
        print(i,",####") 

“”"
阅读别人的python源码时碰到了这个yield这个关键字，各种搜索终于搞懂了，在此做一下总结：

通常的for…in…循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。它可以是mylist = [1, 2, 3]，也可以是mylist = [xx for x in range(3)]。
它的缺陷是所有数据都在内存中，如果有海量数据的话将会非常耗内存。
生成器是可以迭代的，但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (xx for x in range(3))，注意这里用到了()，它就不是数组，而上面的例子是[]。
我理解的生成器(generator)能够迭代的关键是它有一个next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。可以用上面的mygenerator测试。
带有 yield 的函数不再是一个普通函数，而是一个生成器generator，可用于迭代，工作原理同上。
yield 是一个类似 return 的关键字，迭代一次遇到yield时就返回yield后面(右边)的值。重点是：下一次迭代时，从上一次迭代遇到的yield后面的代码(下一行)开始执行。
简要理解：yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后(下一行)开始。
带有yield的函数不仅仅只用于for循环中，而且可用于某个函数的参数，只要这个函数的参数允许迭代参数。比如array.extend函数，它的原型是array.extend(iterable)。
send(msg)与next()的区别在于send可以传递参数给yield表达式，这时传递的参数会作为yield表达式的值，而yield的参数是返回给调用者的值。——换句话说，就是send可以强行修改上一个yield表达式值。比如函数中有一个yield赋值，a = yield 5，第一次迭代到这里会返回5，a还没有赋值。第二次迭代时，使用.send(10)，那么，就是强行修改yield 5表达式的值为10，本来是5的，那么a=10
send(msg)与next()都有返回值，它们的返回值是当前迭代遇到yield时，yield后面表达式的值，其实就是当前迭代中yield后面的参数。
第一次调用时必须先next()或send(None)，否则会报错，send后之所以为None是因为这时候没有上一个yield(根据第8条)。可以认为，next()等同于send(None)

作者：千若逸
链接：https://www.jianshu.com/p/d09778f4e055
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
“”"

# 理解的关键在于：下次迭代时，代码从yield的下一跳语句开始执行。
kk(1)
# (0, ',####')
# ('i=', 0)
# do something.
# end.

kk(2)
# (0, ',####')
# ('i=', 0)
# (2, ',####')
# ('i=', 1)
# do something.
# end.

kk(5)
# (0, ',####')
# ('i=', 0)
# (2, ',####')
# ('i=', 1)
# (4, ',####')
# ('i=', 2)
# (6, ',####')
# ('i=', 3)
# (8, ',####')
# ('i=', 4)
# do something.
# end.



# >>> 
# >>> def g():
# ...     print "1"
# ...     x = yield "hello"
# ...     print "2","x =",x
# ...     y=5 + (yield x)
# ...     print "3","y = ",y
# ... 
# >>> f=g()
# >>> 
# >>> f.next()
# 1
# 'hello'
# >>> f.send(5)
# 2 x = 5
# 5
# >>> f.send(2)
# 3 y =  7
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# StopIteration
# >>> 

“”"

生成器

l=(i for i in range(10) if i%2 == 0)

#<generator object at 0x028E1CD8>

协程

‘’’
子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，
C执行完毕返回，B执行完毕返回，最后是A执行完毕。
所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。
协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，
在适当的时候再返回来接着执行。
但协程的特点在于是一个线程执行，那和多线程比，协程有何优势？
最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，
没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。
第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，
在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，
又充分发挥协程的高效率，可获得极高的性能。
Python对协程的支持还非常有限，用在generator中的yield可以一定程度上实现协程。虽然支持不完全，但已经可以发挥相当大的威力了
传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，
但一不小心就可能死锁。
如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后
切换回生产者继续生产，效率极高：

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

函数内使用yield变成生成器，func.next(),遇到yield就返回yield后面跟的值，
下次调用直接从yield的位置开始
如果c=func(),c.send(i)，那么yield的位置会获取i这个值，生成器函数不会返回，会继续运行yield下面的操作
‘’’

def consumer():
    r=''
    while True:
        n=yield r
        print('吃货:包子[%s]来了，吃包子' %n)
        time.sleep(1)
        r='200 ok'

def producer(c):
    c.next()
    for i in range(5):
        print('厨师:包子[%s]做好了' %i)
        r=c.send(i)
        print('厨师:包子被取走了，状态码为%s' %r)
    c.close()
producer(consumer())

运行结果

厨师:包子[0]做好了
吃货:包子[0]来了，吃包子
厨师:包子被取走了，状态码为200 ok
厨师:包子[1]做好了
吃货:包子[1]来了，吃包子
厨师:包子被取走了，状态码为200 ok
厨师:包子[2]做好了
吃货:包子[2]来了，吃包子
厨师:包子被取走了，状态码为200 ok
厨师:包子[3]做好了
吃货:包子[3]来了，吃包子
厨师:包子被取走了，状态码为200 ok
厨师:包子[4]做好了
吃货:包子[4]来了，吃包子
厨师:包子被取走了，状态码为200 ok

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