多任务---协程

协程

迭代器

• 迭代： 是访问集合元素的一种方式，用 for…in…从 list、tuple、str等类型中依次取数据，这种遍历也称之为迭代

• 迭代对象：可以通过 for…in…这类语句迭代读取数据的对象

• 迭代器：是一个可以记住遍历的位置的对象。

---

实现一个可迭代对象

import time
from collections import Iterable
from collections import Iterator


class Classmate(object):
    def __init__(self):
        self.names = list()
        self.current_num = 0

    def add(self, name):
        self.names.append(name)

    def __iter__(self):
        """如果想要一个对象称为一个　可以迭代的对象，即可以使用for，那么必须实现__iter__方法"""
        return self
# 调用iter(xxobj)的时候 只要__iter__方法返回一个 迭代器即可
# 至于是自己 还是 别的对象都可以的, 但是要保证是一个迭代器
# (即实现了 __iter__  __next__方法)

    def __next__(self):
        if self.current_num < len(self.names):
            ret = self.names[self.current_num]
            self.current_num += 1
            return ret
        else:
            raise StopIteration


classmate = Classmate()
classmate.add("老王")
classmate.add("王二")
classmate.add("张三")

# print("判断classmate是否是可以迭代的对象:", isinstance(classmate, Iterable))
# classmate_iterator = iter(classmate)
# print("判断classmate_iterator是否是迭代器:", isinstance(classmate_iterator, Iterator))
# print(next(classmate_iterator))

for name in classmate:
    print(name)
    time.sleep(1)

---

iter()函数 与 next()函数

• list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使用next()函数来获取下一条数据。iter()函数实际上就是调用了可迭代对象的 __ iter __ 方法。

---

如何判断一个对象是否是迭代器

可以使用 isinstance() 判断一个对象是否是 Iterator 对象

	In [56]: from collections import Iterator
	
	In [57]: isinstance([], Iterator)
	Out[57]: False
	
	In [58]: isinstance(iter([]), Iterator)
	Out[58]: True
	
	In [59]: isinstance(iter("abc"), Iterator)
	Out[59]: True

---

迭代器Iterator

一个实现了 __iter__方法和__next__方法的对象，就是迭代器。

---

for…in…循环的本质

• for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束。

---

斐波拉契数列（Fibonacci）

• 数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：
  0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

	nums = list()
	a, b, i = 0, 1, 0
	while i < 10:
	    nums.append(a)
	    a, b = b, a + b
	    i += 1
	for num in nums:
	    print(num)

迭代器实现斐波那契数列

class Fibonacci(object):
    def __init__(self, all_num):
        self.all_num = all_num
        self.current_num = 0
        self.a = 0
        self.b = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_num < self.all_num:
            ret = self.a
        
            self.a, self.b = self.b, self.a+self.b
            self.current_num += 1

            return ret
        else:
            raise StopIteration


fibo = Fibonacci(10)


for num in fibo:
    print(num)

---

生成器

• 生成器是一类特殊的迭代器。

---

生成器实现斐波那契数列

• 简单来说：只要在def中有yield关键字的 就称为 生成器

def create_num(all_num):
    print("----1---")
    # a = 0
    # b = 1
    a, b = 0, 1
    current_num = 0
    while current_num < all_num:
        print("----2---")
        # print(a)
        yield a  # 如果一个函数中有yield语句，那么这个就不在是函数，而是一个生成器的模板
        print("----3---")
        a, b = b, a+b
        current_num += 1
        print("----4---")

# 如果在调用create_num的时候，发现这个函数中有yield那么此时，不是调用函数，而是创建一个生成器对象
obj = create_num(10)

ret = next(obj)
print(ret)

ret = next(obj)
print(ret)

obj2 = create_num(2)

ret = next(obj2)
print(ret)

# for num in obj:
#    print(num)

总结

• 使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）
• yield关键字有两点作用：
  • 保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
  • 将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用

• 可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

---

通过异常判断生成器已经结束

def create_num(all_num):
    # a = 0
    # b = 1
    a, b = 0, 1
    current_num = 0
    while current_num < all_num:
        # print(a)
        yield a  # 如果一个函数中有yield语句，那么这个就不在是函数，而是一个生成器的模板
        a, b = b, a+b
        current_num += 1
    return "ok...."

obj2 = create_num(50) # 这时调用，不是在调用函数，而是创建一个生成器对象

while True:
    try:
        ret = next(obj2)
        print(ret)
    except Exception as ret:
        print(ret.value)
        break

---

用send启动生成器

• 可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据

def create_num(all_num):
    a, b = 0, 1
    current_num = 0
    while current_num < all_num:
        ret = yield a
        print(">>>ret>>>>", ret)
        a, b = b, a+b
        current_num += 1

obj = create_num(10)

# obj.send(None)  # send一般不会放到第一次启动生成器，如果非要这样做 那么传递None

ret = next(obj)
print(ret)

# send里面的数据会 传递给第5行，当做yield a的结果，然后ret保存这个结果,,, 
# send的结果是下一次调用yield时 yield后面的值
ret = obj.send("hahahha")  
print(ret)

---

协程—yield

• 协程是python个中另外一种实现多任务的方式
• 通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定

使用yield完成多任务

import time


def task_1():
    while True:
        print("---1----")
        time.sleep(0.1)
        yield


def task_2():
    while True:
        print("---2----")
        time.sleep(0.1)
        yield


def main():
    t1 = task_1()
    t2 = task_2()
    # 先让t1运行一会，当t1中遇到yield的时候，再返回到24行，然后
    # 执行t2，当它遇到yield的时候，再次切换到t1中
    # 这样t1/t2/t1/t2的交替运行，最终实现了多任务....协程
    while True:
        next(t1)
        next(t2)
    


if __name__ == "__main__":
    main()

---

协程—greenlet

• 为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单
• ubantu 中安装greenlet：sudo pip3 install greenlet

使用greenlet完成多任务

from greenlet import greenlet
import time

def test1():
    while True:
        print("---A--")
        gr2.switch()
        time.sleep(0.5)

def test2():
    while True:
        print("---B--")
        gr1.switch()
        time.sleep(0.5)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

#切换到gr1中运行
gr1.switch()

---

协程—gevent

• python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent
• ubantu中安装：pip3 install gevent

genvent实现多任务

import gevent
import time


def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)

def f2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)

def f3(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        # time.sleep(0.5)
        gevent.sleep(0.5)

print("----1---")
g1 = gevent.spawn(f1, 5)
print("----2---")
g2 = gevent.spawn(f2, 5)
print("----3---")
g3 = gevent.spawn(f3, 5)
print("----4---")
g1.join()
g2.join()
g3.join()

---

genvent打补丁

import gevent
import time
from gevent import monkey

monkey.patch_all()  # 打补丁，将下面的延时操作变成 gevent.sleep(0.5)

def f1(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        #用来模拟一个耗时操作，注意不是time模块中的sleep
        time.sleep(0.5)  # 若没有上面的补丁，则这句话没效果，就是安顺序执行，不是多任务
		 #遇到延时等待，切换到下一个执行 

def f2(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

def f3(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        time.sleep(0.5)

gevent.joinall([
    gevent.spawn(f1, 5),
    gevent.spawn(f2, 5),
    gevent.spawn(f3, 5)
])
# g1.join()
# g2.join()
# g3.join()

• gevent任务切换是需要堵塞，如，当执行到 f1 里的 time.sleep(0.5) 时， gevent就发现遇到了延时，程序处于等待状态，这时， gevent 就会切换到 f2 中执行，同理，就实现了多任务（并发）

---

简单总结

	1.进程是资源分配的单位
	2.线程是操作系统调度的单位
	3.进程切换需要的资源很最大，效率很低
	4.线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）
	5.协程切换任务资源很小，效率高
	6.多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发