什么是Python中的協程

本篇文章給大家分享的是有關什么是Python中的協程，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

協程

在python GIL之下，同一時刻只能有一個線程在運行，那么對于CPU計算密集的程序來說，線程之間的切換開銷就成了拖累，而以I/O為瓶頸的程序正是協程所擅長的：

Python中的協程經歷了很長的一段發展歷程。其大概經歷了如下三個階段：

1.最初的生成器變形yield/send；

2.引入@asyncio.coroutine和yield from；

3.在最近的Python3.5版本中引入async/await關鍵字。

（1）從yield說起

先看一段普通的計算斐波那契續列的代碼

  def fibs(n):
       res = [0] * n
       index = 0
       a = 0
       b = 1
       while index < n:
          res[index] = b
          a, b = b, a + b
          index += 1
       return res
    
    
    for fib_res in fibs(20):
       print(fib_res)

如果我們僅僅是需要拿到斐波那契序列的第n位，或者僅僅是希望依此產生斐波那契序列，那么上面這種傳統方式就會比較耗費內存。

這時，yield就派上用場了。

  def fib(n):
       index = 0
       a = 0
       b = 1
       while index < n:
          yield b
          a, b = b, a + b
          index += 1
    
    for fib_res in fib(20):
       print(fib_res)

當一個函數中包含yield語句時，python會自動將其識別為一個生成器。這時fib(20)并不會真正調用函數體，而是以函數體生成了一個生成器對象實例。

yield在這里可以保留fib函數的計算現場，暫停fib的計算并將b返回。而將fib放入for…in循環中時，每次循環都會調用next(fib(20))，喚醒生成器，執行到下一個yield語句處，直到拋出StopIteration異常。此異常會被for循環捕獲，導致跳出循環。

(2) Send來了

從上面的程序中可以看到，目前只有數據從fib(20)中通過yield流向外面的for循環；如果可以向fib(20)發送數據，那不是就可以在Python中實現協程了嘛。

于是，Python中的生成器有了send函數，yield表達式也擁有了返回值。

我們用這個特性，模擬一個慢速斐波那契數列的計算：

    import time
    import random
    
    def stupid_fib(n):
       index = 0
       a = 0
       b = 1
       while index < n:
          sleep_cnt = yield b
          print('let me think {0} secs'.format(sleep_cnt))
          time.sleep(sleep_cnt)
          a, b = b, a + b
          index += 1
    
    
    print('-' * 10 + 'test yield send' + '-' * 10)
    N = 20
    sfib = stupid_fib(N)
    fib_res = next(sfib)
    while True:
       print(fib_res)
       try:
          fib_res = sfib.send(random.uniform(0, 0.5))
       except StopIteration:
          break

python 進行并發編程

在Python 2的時代，高性能的網絡編程主要是使用Twisted、Tornado和Gevent這三個庫，但是它們的異步代碼相互之間既不兼容也不能移植。

asyncio是Python 3.4版本引入的標準庫，直接內置了對異步IO的支持。

asyncio的編程模型就是一個消息循環。我們從asyncio模塊中直接獲取一個EventLoop的引用，然后把需要執行的協程扔到EventLoop中執行，就實現了異步IO。

Python的在3.4中引入了協程的概念，可是這個還是以生成器對象為基礎。

Python 3.5添加了async和await這兩個關鍵字，分別用來替換asyncio.coroutine和yield from。

python3.5則確定了協程的語法。下面將簡單介紹asyncio的使用。實現協程的不僅僅是asyncio，tornado和gevent都實現了類似的功能。

（1）協程定義

用asyncio實現Hello world代碼如下：

    import asyncio
    
    @asyncio.coroutine
    def hello():
        print("Hello world!")
        # 異步調用asyncio.sleep(1):
        r = yield from asyncio.sleep(1)
        print("Hello again!")
    
    # 獲取EventLoop:
    loop = asyncio.get_event_loop()
    # 執行coroutine
    loop.run_until_complete(hello())
    loop.close()

@asyncio.coroutine把一個generator標記為coroutine類型，然后，我們就把這個coroutine扔到EventLoop中執行。 hello()會首先打印出Hello world!，然后，yield from語法可以讓我們方便地調用另一個generator。由于asyncio.sleep()也是一個coroutine，所以線程不會等待asyncio.sleep()，而是直接中斷并執行下一個消息循環。當asyncio.sleep()返回時，線程就可以從yield from拿到返回值（此處是None），然后接著執行下一行語句。

把asyncio.sleep(1)看成是一個耗時1秒的IO操作，在此期間，主線程并未等待，而是去執行EventLoop中其他可以執行的coroutine了，因此可以實現并發執行。

我們用Task封裝兩個coroutine試試：

    import threading
    import asyncio
    
    @asyncio.coroutine
    def hello():
        print('Hello world! (%s)' % threading.currentThread())
        yield from asyncio.sleep(1)
        print('Hello again! (%s)' % threading.currentThread())
    
    loop = asyncio.get_event_loop()
    tasks = [hello(), hello()]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

觀察執行過程：

Hello world! (<_MainThread(MainThread, started 140735195337472)>)
Hello world! (<_MainThread(MainThread, started 140735195337472)>)
(暫停約1秒)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)

由打印的當前線程名稱可以看出，兩個coroutine是由同一個線程并發執行的。

如果把asyncio.sleep()換成真正的IO操作，則多個coroutine就可以由一個線程并發執行。

asyncio案例實戰

我們用asyncio的異步網絡連接來獲取sina、sohu和163的網站首頁：

async_wget.py

      import asyncio
    
    @asyncio.coroutine
    def wget(host):
        print('wget %s...' % host)
        connect = asyncio.open_connection(host, 80)
        reader, writer = yield from connect
        header = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % host
        writer.write(header.encode('utf-8'))
        yield from writer.drain()
        while True:
            line = yield from reader.readline()
            if line == b'\r\n':
                break
            print('%s header > %s' % (host, line.decode('utf-8').rstrip()))
        # Ignore the body, close the socket
        writer.close()
    
    loop = asyncio.get_event_loop()
    tasks = [wget(host) for host in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']]
    loop.run_until_complete(asyncio.wait(tasks))
    loop.close()

結果信息如下：

  wget www.sohu.com...
    wget www.sina.com.cn...
    wget www.163.com...
    (等待一段時間)
    (打印出sohu的header)
    www.sohu.com header > HTTP/1.1 200 OK
    www.sohu.com header > Content-Type: text/html
    ...
    (打印出sina的header)
    www.sina.com.cn header > HTTP/1.1 200 OK
    www.sina.com.cn header > Date: Wed, 20 May 2015 04:56:33 GMT
    ...
    (打印出163的header)
    www.163.com header > HTTP/1.0 302 Moved Temporarily
    www.163.com header > Server: Cdn Cache Server V2.0
    ...

可見3個連接由一個線程通過coroutine并發完成。

小結

asyncio提供了完善的異步IO支持；

異步操作需要在coroutine中通過yield from完成；

多個coroutine可以封裝成一組Task然后并發執行。

以上就是什么是Python中的協程，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。