Python 多任务3: 协程-阿里云开发者社区

一、总体内容

1.1、协程的介绍
1.2、迭代器以及迭代器的应用
1.3、生成器(生成器与迭代器保存的都是生成数据的代码，而不是数据)
1.4、gevent 来实现一个 图片下载器 & 视频下载器

二、协程介绍

2.1、协程是什么？

协程，又称微线程，纤程。英文名Coroutine：英[kəru:'ti:n]。
协程是python个中另外一种实现多任务的方式，只不过比线程更小占用更小执行单元（理解为需要的资源）。为啥说它是一个执行单元，因为它自带CPU上下文。这样只要在合适的时机，我们可以把一个协程切换到另一个协程。只要这个过程中保存或恢复 CPU上下文那么程序还是可以运行的。
通俗的理解：在一个线程中的某个函数，可以在任何地方保存当前函数的一些临时变量等信息，然后切换到另外一个函数中执行，注意不是通过调用函数的方式做到的，并且切换的次数以及什么时候再切换到原来的函数都由开发者自己确定。

2.2、协程和线程差异
在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。
2.3、简单实现协程(暂时用yield,后面我们主要用 gevent 来实现协程)

import time
def work1():
      while True:
          print("----work1---")
          yield
          time.sleep(0.5)
def work2():
      while True:
          print("----work2---")
          yield
          time.sleep(0.5)
def main():
      w1 = work1()
      w2 = work2()
      while True:
          next(w1)
          next(w2)
if __name__ == "__main__":
      main()

运行结果：

---work1---
----work2---
----work1---
----work2---
----work1---
----work2---
---------等等-------

三、迭代器

3.1、迭代器的介绍
迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器 对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
3.2、可迭代对象我们已经知道可以对list、tuple、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。是否所有的数据类型都可以放到for...in...的语句中，然后让for...in...每次从中取出一条数据供我们使用，即供我们迭代吗？

>>> for i in 100:
...     print(i)
...
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: 'int' object is not iterable

错误原因是： int整型不是iterable，即int整型不是可以迭代的

我们再看一下一个类是否可以进行迭代

class MyList(object):
       def __init__(self):
             self.container = []
       def add(self, item):
             self.container.append(item)
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
for num in mylist:
      print(num)

打印结果是：从下面可以看出不可迭代

TypeError: 'MyList' object is not iterable

我们自定义了一个容器类型MyList，在将一个存放了多个数据的MyList对象放到for...in...的语句中，发现for...in...并不能从中依次取出一条数据返回给我们，也就说我们随便封装了一个可以存放多条数据的类型却并不能被迭代使用。
我们把可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable)。

3.3、如何判断一个对象是否可以迭代

可以使用 isinstance()判断一个对象是否是 Iterable对象,如下判断

>>> from collections import Iterable
>>>  isinstance([],Iterable)
True
>>> isinstance(10,Iterable)
False

3.4、可迭代对象的本质

我们分析对可迭代对象进行迭代使用的过程，发现每迭代一次（即在for...in...中每循环一次）都会返回对象中的下一条数据，一直向后读取数据直到迭代了所有数据后结束。那么，在这个过程中就应该有一个“人”去记录每次访问到了第几条数据，以便每次迭代都可以返回下一条数据。我们把这个能帮助我们进行数据迭代的“人”称为迭代器(Iterator：[ɪtə'reɪtə])。
可迭代对象的本质 就是可以向我们提供一个这样的中间“人”即迭代器帮助我们对其进行迭代遍历使用。
可迭代对象通过iter方法向我们提供一个迭代器，我们在迭代一个可迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据.
那么也就是说，一个具备了__iter__方法的对象，就是一个可迭代对象。
在一个类里面加上 __iter__就可以使这个类成为可迭代的对象

class MyList(object):
      def __init__(self):
           self.container = list()
      def add(self, item):
           self.container.append(item)
      def __iter__(self):
           """返回一个迭代器"""
           # 我们暂时忽略如何构造一个迭代器对象
           pass
mylist = MyList()
mylist.add(1)
mylist.add(2)
print(isinstance(mylist,Iterable))

打印结果是：True, 这回测试发现添加了__iter__方法的mylist对象已经是一个 可迭代对象 了

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

>>> li = [11, 22, 33, 44, 55]
>>> li_iter = iter(li)
>>> next(li_iter)
11
>>> next(li_iter)
22
>>> next(li_iter)
33
>>> next(li_iter)
44
>>> next(li_iter)
55
>>> next(li_iter)
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    StopIteration

注意，当我们已经迭代完最后一个数据之后，再次调用next()函数会抛出StopIteration的异常，来告诉我们所有数据都已迭代完成，不用再执行next()函数了。

3.6、如何判断一个对象是否是迭代器
可以使用 isinstance() 判断一个对象是否是 Iterator 对象：

>>>  from collections import Iterator
>>>  isinstance([], Iterator)
False
>>> isinstance(iter([]), Iterator)
True
>>>  isinstance(iter("abc"), Iterator)
True

3.7、迭代器Iterator
通过上面的分析，我们已经知道，迭代器是用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。实际上，在使用next()函数的时候，调用的就是迭代器对象的__next__方法（Python3中是对象的__next__方法，Python2中是对象的next()方法）。所以，我们要想构造一个迭代器，就要实现它的__next__方法。但这还不够，python要求迭代器本身也是可迭代的，所以我们还要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。

from collections import Iterator
from collections import Iterable
class MyList(object):
      def __init__(self):
           self.name_list = []
           self.all_count = 0
      def add_name(self,temp):
           self.name_list.append(temp)
      def __iter__(self):
           return self
      def __next__(self):
             if self.all_count < len(self.name_list):
                     ret = self.name_list[self.all_count]
                    self.all_count += 1
                    return ret
             else:
                    raise StopIteration
my_list = MyList()
my_list.add_name("张三")
my_list.add_name("李四")
my_list.add_name("王五")
print("判断my_list是否是可以迭代的对象：",isinstance(my_list,Iterable))
my_list_iterator = iter(my_list)
print("判断my_list_iterator是否是迭代器：",isinstance(my_list_iterator,Iterator))
for name in my_list:
       print(name)

打印结果是：

判断my_list是否是可以迭代的对象： True
判断my_list_iterator是否是迭代器： True
张三
李四
王五

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

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

我们发现迭代器最核心的功能就是可以通过next()函数的调用来返回下一个数据值。如果每次返回的数据值不是在一个已有的数据集合中读取的，而是通过程序按照一定的规律计算生成的，那么也就意味着可以不用再依赖一个已有的数据集合，也就是说不用再将所有要迭代的数据都一次性缓存下来供后续依次读取，这样可以节省大量的存储（内存）空间。
举例：比如，数学中有个著名的 斐波拉契数列（Fibonacci），数列中第一个数为0，第二个数为1，其后的每一个数都可由前两个数相加得到：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

class FibIterator(object):
        """斐波那契数列迭代器"""
      def __init__(self,num):
            """
            :param num: 指明生成数列的前num个数
            """
            self.all_num = num
            # 用来保存当前生成到数列中的第几个数了
            self.num = 0
            # 用来保存前前一个数，初始值为数列中的第一个数0
            self.start_a = 0
            # 用来保存前后一个数，初始值为数列中的第二个数1
            self.start_b = 1
      def __iter__(self):
            # """迭代器的__iter__返回自身即可"""
            return self
      def __next__(self):
            # """被next()函数调用来获取下一个数"""
            if self.num < self.all_num:
                  self.num += 1
                  retValue = self.start_a
                  self.start_a,self.start_b = self.start_b,self.start_a+self.start_b
                  return self.start_a
            else:
                  raise StopIteration
fibIterator = FibIterator(20)
for num in fibIterator:
         print(num)

3.10、并不是只有for循环能接收可迭代对象
除了for循环能接收可迭代对象，list、tuple等也能接收。

li = list(FibIterator(15))
print(li)
tp = tuple(FibIterator(6))
print(tp)

打印结果

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
(1, 1, 2, 3, 5, 8)

3.11、以后再见到 元组转列表，列表转元组，不要再认为是简简单单的转换了；比如下面的例子

list1 = list((1,2,3,4,5))
print(list1)
打印结果是：[1, 2, 3, 4, 5]

这可不是简简单单的转换，list()这就是利用了迭代器,把返回的每一个元组数据都放在了列表里面，生成一个新的列表；

四、生成器

4.1、生成器介绍
利用迭代器，我们可以在每次迭代获取数据（通过next()方法）时按照特定的规律进行生成。但是我们在实现一个迭代器时，关于当前迭代到的状态需要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到记录当前状态，并配合next()函数进行迭代使用，我们可以采用更简便的语法，即生成器(generator)。生成器是一类特殊的迭代器。

4.2、创建生成器方法

创建生成器方法1

In [15]: L = [ x*2 for x in range(3)]
In [16]: L
Out[16]: [0, 2, 4]
In [17]: G = ( x*2 for x in range(3))
In [18]: G
Out[18]: <generator object <genexpr> at 0x7f626c132db0>

创建 L 和 G 的区别仅在于最外层的 [ ] 和 ( ) ， L 是一个列表，而 G 是一个生成器。我们可以直接打印出列表L的每一个元素，而对于生成器G，我们可以按照迭代器的使用方法来使用，即可以通过next()函数、for循环、list()等方法使用。

In [19]: next(G)
Out[19]: 0
In [20]: next(G)
Out[20]: 2
In [21]: next(G)
Out[21]: 4
In [26]: G = ( x*2 for x in range(5))
In [27]: for x in G:
....:     print(x)
....:     
0
2
4

创建生成器方法2
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的 for 循环无法实现的时候，还可以用函数来实现。我们仍然用 二 中提到的斐波那契数列来举例，回想我们在上一节用迭代器的实现方式：

def fib(n):
    current = 0
    num1, num2 = 0, 1
    while current < n:
         yield num1
         num1, num2 = num2, num1+num2
         current += 1
    return 'done'
fib1 = fib(5)
for i in fib1:
      print(i)

在使用生成器实现的方式中，我们将原本在迭代器next方法中实现的基本逻辑放到一个函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是函数，而是一个生成器了。简单来说：只要在def中有yield关键字的就称为生成器
此时按照调用函数的方式( 案例中为F = fib(5) )使用生成器就不再是执行函数体了，而是会返回一个生成器对象（案例中为F ），然后就可以按照使用迭代器的方式来使用生成器了。
但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：

while True:
     try:
         x = next(fib1)
         print("value:%d" % x)
     except StopIteration as e:
         print("生成器返回值:%s" % e.value)
         break

总结

使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）
yield关键字有两点作用：

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

可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）
Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）。

4.3、使用send唤醒
我们除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。
例子：执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send("python")，send发送过来的值，c.next()等价c.send(None)

def send_use(num):
      i = 0
      while i < num:
           temp = yield i
           print(temp)
           i += 1
s = send_use(5)
print(next(s))
print(next(s))
print(next(s))
print(next(s))
print(s.send("哈哈"))

4.4、使用__next__()方法（不常使用）

def send_use(num):
      i = 0
      while i < num:
           yield i
           i += 1
s = send_use(5)
print(s.__next__())
print(s.__next__())
print(s.__next__())

4.5、greenlet为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单

安装方式

sudo pip3 install 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()

运行效果

---A--
---B--
---A--
---B--
---A--
---B--
---A--
---B--

4.6、gevent (重点)

其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。
由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO
安装 gevent

pip3 install gevent

gevent的使用

import gevent
def f(n):
     for i in range(n):
          print(gevent.getcurrent,i)
g1 = gevent.spawn(f,5)
g2 = gevent.spawn(f,5)
g3 = gevent.spawn(f,5)
g1.join()
g2.join()
g3.join()

运行结果(可以看到，3个gevent是依次运行而不是交替运行)

<built-in function getcurrent> 0
<built-in function getcurrent> 1
<built-in function getcurrent> 2
<built-in function getcurrent> 3
<built-in function getcurrent> 4
<built-in function getcurrent> 0
<built-in function getcurrent> 1
<built-in function getcurrent> 2
<built-in function getcurrent> 3
<built-in function getcurrent> 4
<built-in function getcurrent> 0
<built-in function getcurrent> 1
<built-in function getcurrent> 2
<built-in function getcurrent> 3
<built-in function getcurrent> 4

gevent切换执行

import gevent
def f(n):
     for i in range(n):
         print(gevent.getcurrent,i)
         # 用来模拟一个耗时操作，注意不是time模块中的sleep
         gevent.sleep(0.3)
g1 = gevent.spawn(f,5)
g2 = gevent.spawn(f,5)
g3 = gevent.spawn(f,5)
g1.join()
g2.join()
g3.join()

运行结果: 可以看到是交替执行的

<built-in function getcurrent> 0
<built-in function getcurrent> 0
<built-in function getcurrent> 0
<built-in function getcurrent> 1
<built-in function getcurrent> 1
<built-in function getcurrent> 1
<built-in function getcurrent> 2
<built-in function getcurrent> 2
<built-in function getcurrent> 2
<built-in function getcurrent> 3
<built-in function getcurrent> 3
<built-in function getcurrent> 3
<built-in function getcurrent> 4
<built-in function getcurrent> 4
<built-in function getcurrent> 4

4.7、给程序打补丁（如果你在使用gevent的模块中sleep()用的是time模块,那么为了使gevent也起作用，那么就要进行打补丁）

需要加上下面的代码

# 有耗时操作时需要
monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块

完整的代码如下

from gevent import monkey
import gevent
import time
# 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()
def f(name,n):
      for i in range(n):
           print(gevent.getcurrent,"name=%s"%name,i)
           # 用来模拟一个耗时操作，注意不是time模块中的sleep
           time.sleep(0.3)
gevent.joinall([
       gevent.spawn(f,"work1",5),
       gevent.spawn(f,"work1",5)
])

运行结果如下：

<built-in function getcurrent> name=work1 0
<built-in function getcurrent> name=work1 0
<built-in function getcurrent> name=work1 1
<built-in function getcurrent> name=work1 1
<built-in function getcurrent> name=work1 2
<built-in function getcurrent> name=work1 2
<built-in function getcurrent> name=work1 3
<built-in function getcurrent> name=work1 3
<built-in function getcurrent> name=work1 4
<built-in function getcurrent> name=work1 4

五、gevent 来实现一个图片下载器

5.1、我们在下载网络的时候会用到 urllib.request,在用到打开一个链接urllib.request.urlopen的时候会报错：urllib.error.URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1051)>,这是我的报错

原因是：查找相关资料后确定为Python 2.7.9 之后版本引入了一个新特性
当你urllib.urlopen一个 https 的时候会验证一次 SSL 证书
当目标使用的是自签名的证书时就会爆出一个上面的错误，
处理办法如下：在全局添加下面代码

import ssl 
ssl._create_default_https_context = ssl._create_unverified_context

5.2、使用协程 gevent 实现的图片下载器

import urllib.request
import ssl
from gevent import monkey
import gevent
monkey.patch_all()
ssl._create_default_https_context = ssl._create_unverified_context
def down_loader_image(image_name,image_url):
         """
         使用进程 gevent的图片下载器
         :param image_name: 图片的名字
         :param image_url: 图片的url
         """
        req = urllib.request.urlopen(image_url)
        image_content = req.read()
        with open("/Users/wangchong/Desktop/%s"%image_name,"wb") as f:
              f.write(image_content)
def main():
     gevent.joinall([
               gevent.spawn(down_loader_image,"20.png","https://rpic.douyucdn.cn/live-cover/appCovers/2018/11/15/5658062_20181115170406_small.jpg"),
               gevent.spawn(down_loader_image,"21.png","https://rpic.douyucdn.cn/live-cover/roomCover/2018/09/27/b0983e7b6267f5b8371106ccf5f113ab_big.jpg")
      ])
if __name__ == '__main__':

5.3、使用协程 gevent 实现多个视频下载

import urllib.request
import ssl
from gevent import monkey
import gevent
#有IO才做时需要这一句,将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()
ssl._create_default_https_context = ssl._create_unverified_context
def down_loader_image(video_name,video_url):
         """
         使用进程 gevent的图片下载器
         :param video_name: 视频的名字
         :param video_url: 图片的url
         """
        req = urllib.request.urlopen(video_url)
        data = req.read()
        with open("/Users/wangchong/Desktop/%s"% video_name,"wb") as f:
              f.write(data)
        print('%d bytes received from %s.' % (len(data), video_url))
def main():
     gevent.joinall([
               gevent.spawn(down_loader_image,"1.mp4","http://images.ciotimes.com/2.wx_test.mp4"),
               gevent.spawn(down_loader_image,"2.mp4","http://images.ciotimes.com/3.wx_test.mp4")
      ])
if __name__ == '__main__':
      main()

提示上面的url可以换为自己需要下载视频、音乐、图片等网址

六、总结：进程、线程、协程对比

6.1、对 进程、线程、协程 三者的描述

有一个老板想要开个工厂进行生产某件商品（例如剪子）
他需要花一些财力物力制作一条生产线，这个生产线上有很多的器件以及材料这些所有的为了能够生产剪子而准备的资源称之为：进程
只有生产线是不能够进行生产的，所以老板的找个工人来进行生产，这个工人能够利用这些材料最终一步步的将剪子做出来，这个来做事情的工人称之为：线程
这个老板为了提高生产率，想到3种办法：

在这条生产线上多招些工人，一起来做剪子，这样效率是成倍増长，即 单进程多线程 方式
老板发现这条生产线上的工人不是越多越好，因为一条生产线的资源以及材料毕竟有限，所以老板又花了些财力物力购置了另外一条生产线，然后再招些工人这样效率又再一步提高了，即多进程多线程方式
老板发现，现在已经有了很多条生产线，并且每条生产线上已经有很多工人了（即程序是多进程的，每个进程中又有多个线程），为了再次提高效率，老板想了个损招，规定：如果某个员工在上班时临时没事或者再等待某些条件（比如等待另一个工人生产完谋道工序之后他才能再次工作），那么这个员工就利用这个时间去做其它的事情，那么也就是说：如果一个线程等待某些条件，可以充分利用这个时间去做其它事情，其实这就是：协程方式

6.2、总体描述

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

Python 多任务3: 协程

一、总体内容

二、协程介绍

三、迭代器

四、生成器

五、gevent 来实现一个图片下载器

六、总结：进程、线程、协程对比

热门文章

最新文章

相关课程

相关电子书

相关实验场景