python攜程輪訓

㈠ python協程之asyncio

asyncio 是 Python 中的非同步IO庫，用來編寫並發協程，適用於IO阻塞且需要大量並發的場景，例如爬蟲、文件讀寫。

asyncio 在 Python3.4 被引入，經過幾個版本的迭代，特性、語法糖均有了不同程度的改進，這也使得不同版本的 Python 在 asyncio 的用法上各不相同，顯得有些雜亂，以前使用的時候也是本著能用就行的原則，在寫法上走了一些彎路，現在對 Python3.7+ 和 Python3.6 中 asyncio 的用法做一個梳理，以便以後能更好的使用。

協程，又稱微線程，它不被操作系統內核所管理，而完全是由程序控制，協程切換花銷小，因而有更高的性能。

協程可以比作子程序，不同的是，執行過程中協程可以掛起當前狀態，轉而執行其他協程，在適當的時候返回來接著執行，協程間的切換不需要涉及任何系統調用或任何阻塞調用，完全由協程調度器進行調度。

Python 中以 asyncio 為依賴，使用 async/await 語法進行協程的創建和使用，如下 async 語法創建一個協程函數：

在協程中除了普通函數的功能外最主要的作用就是：使用 await 語法等待另一個協程結束，這將掛起當前協程，直到另一個協程產生結果再繼續執行：

asyncio.sleep() 是 asyncio 包內置的協程函數，這里模擬耗時的IO操作，上面這個協程執行到這一句會掛起當前協程而去執行其他協程，直到sleep結束，當有多個協程任務時，這種切換會讓它們的IO操作並行處理。

注意，執行一個協程函數並不會真正的運行它，而是會返回一個協程對象，要使協程真正的運行，需要將它們加入到事件循環中運行，官方建議 asyncio 程序應當有一個主入口協程，用來管理所有其他的協程任務：

在 Python3.7+ 中，運行這個 asyncio 程序只需要一句： asyncio.run(main()) ，而在 Python3.6 中，需要手動獲取事件循環並加入協程任務：

事件循環就是一個循環隊列，對其中的協程進行調度執行，當把一個協程加入循環，這個協程創建的其他協程都會自動加入到當前事件循環中。

其實協程對象也不是直接運行，而是被封裝成一個個待執行的 Task ，大多數情況下 asyncio 會幫我們進行封裝，我們也可以提前自行封裝 Task 來獲得對協程更多的控制權，注意，封裝 Task 需要 當前線程有正在運行的事件循環 ，否則將引 RuntimeError，這也就是官方建議使用主入口協程的原因，如果在主入口協程之外創建任務就需要先手動獲取事件循環然後使用底層方法 loop.create_task() ，而在主入口協程之內是一定有正在運行的循環的。任務創建後便有了狀態，可以查看運行情況，查看結果，取消任務等：

asyncio.create_task() 是 Python3.7 加入的高層級API，在 Python3.6，需要使用低層級API asyncio.ensure_future() 來創建 Future，Future 也是一個管理協程運行狀態的對象，與 Task 沒有本質上的區別。

通常，一個含有一系列並發協程的程序寫法如下（Python3.7+）：

並發運行多個協程任務的關鍵就是 asyncio.gather(*tasks) ，它接受多個協程任務並將它們加入到事件循環，所有任務都運行完成後會返回結果列表，這里我們也沒有手動封裝 Task，因為 gather 函數會自動封裝。

並發運行還有另一個方法 asyncio.wait(tasks) ，它們的區別是：

㈡ python中的協程內部是怎麼實現的

Python 2.x 的 generator 的實現方式是 Lua 5.1 coroutine 在涉及 Lua/C mixed code 時候的 yield 方式。所以在 Lua 5.1 的時候是不能 yield-from-C 的。不過 Lua 從一開始就可以 resume-from-C，這是因為 Lua 借用了 C runtime stack 作為 coroutine 的 scheler（具體細節參見《Lua 5.0 Implementation》）。
從 Lua 5.2 開始，在 Lua C API 里引入了用顯示聲明 continuation function 的方式來實現 yield-from-C。
Python 3.x 的 generator 借鑒了 Lua 5.2 的 yield-from-C 形式，可以有限的保留調用棧上下文。
所以 Python 3.x 的純 Python code coroutine 水平才相當於 Lua 5.2 的 Lua/C mixed code coroutine。Python 2.x 的 coroutine 和 Lua 的 coroutine 實現相差更遠。
如果你在只有 ANSI C compiler 的平台上做 script/C hybrid 開發，Lua coroutine 是唯一的選擇了。

㈢ 詳解Python中的協程，為什麼說它的底層是生成器

協程又稱為是微線程，英文名是Coroutine。它和線程一樣可以調度，但是不同的是線程的啟動和調度需要通過操作系統來處理。並且線程的啟動和銷毀需要涉及一些操作系統的變數申請和銷毀處理，需要的時間比較長。而協程呢，它的調度和銷毀都是程序自己來控制的，因此它更加輕量級也更加靈活。

協程有這么多優點，自然也會有一些缺點，其中最大的缺點就是需要編程語言自己支持，否則的話需要開發者自己通過一些方法來實現協程。對於大部分語言來說，都不支持這一機制。go語言由於天然支持協程，並且支持得非常好，使得它廣受好評，短短幾年時間就迅速流行起來。

對於Python來說，本身就有著一個GIL這個巨大的先天問題。GIL是Python的全局鎖，在它的限制下一個Python進程同一時間只能同時執行一個線程，即使是在多核心的機器當中。這就大大影響了Python的性能，尤其是在CPU密集型的工作上。所以為了提升Python的性能，很多開發者想出了使用多進程+協程的方式。一開始是開發者自行實現的，後來在Python3.4的版本當中，官方也收入了這個功能，因此目前可以光明正大地說，Python是支持協程的語言了。

生成器（generator)

生成器我們也在之前的文章當中介紹過，為什麼我們介紹協程需要用到生成器呢，是因為Python的協程底層就是通過生成器來實現的。

通過生成器來實現協程的原因也很簡單，我們都知道協程需要切換掛起，而生成器當中有一個yield關鍵字，剛好可以實現這個功能。所以當初那些自己在Python當中開發協程功能的程序員都是通過生成器來實現的，我們想要理解Python當中協程的運用，就必須從最原始的生成器開始。

生成器我們很熟悉了，本質上就是帶有yield這個關鍵詞的函數。

async，await和future

從Python3.5版本開始，引入了async，await和future。我們來簡單說說它們各自的用途，其中async其實就是@asyncio.coroutine，用途是完全一樣的。同樣await代替的是yield from，意為等待另外一個協程結束。

我們用這兩個一改，上面的代碼就成了：

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

由於我們加上了await，所以每次在列印之前都會等待0.5秒。我們把await換成yield from也是一樣的，只不過用await更加直觀也更加貼合協程的含義。

Future其實可以看成是一個信號量，我們創建一個全局的future，當一個協程執行完成之後，將結果存入這個future當中。其他的協程可以await future來實現阻塞。我們來看一個例子就明白了：

future = asyncio.Future()

async def test(k):

n = 0

while n < k:

await asyncio.sleep(0.5)

print('n = {}'.format(n))

n += 1

future.set_result('success')

async def log():

result = await future

print(result)

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait([

log(),

test(5)

]))

loop.close()

在這個例子當中我們創建了兩個協程，第一個協程是每隔0.5秒print一個數字，在print完成之後把success寫入到future當中。第二個協程就是等待future當中的數據，之後print出來。

在loop當中我們要調度執行的不再是一個協程對象了而是兩個，所以我們用asyncio當中的wait將這兩個對象包起來。只有當wait當中的兩個對象執行結束，wait才會結束。loop等待的是wait的結束，而wait等待的是傳入其中的協程的結束，這就形成了一個依賴循環，等價於這兩個協程對象結束，loop才會結束。

總結

async並不只是可以用在函數上，事實上還有很多其他的用法，比如用在with語句上，用在for循環上等等。這些用法比較小眾，細節也很多，就不一一展開了，大家感興趣的可以自行去了解一下。

不知道大家在讀這篇文章的過程當中有沒有覺得有些費勁，如果有的話，其實是很正常的。原因也很簡單，因為Python原生是不支持協程這個概念的，所以在一開始設計的時候也沒有做這方面的准備，是後來覺得有必要才加入的。那麼作為後面加入的內容，必然會對原先的很多內容產生影響，尤其是協程藉助了之前生成器的概念來實現的，那麼必然會有很多耦合不清楚的情況。這也是這一塊的語法很亂，對初學者不友好的原因。

㈣ python中多進程+協程的使用以及為什麼要用它

前面講了為什麼python里推薦用多進程而不是多線程，但是多進程也有其自己的限制：相比線程更加笨重、切換耗時更長，並且在python的多進程下，進程數量不推薦超過CPU核心數（一個進程只有一個GIL，所以一個進程只能跑滿一個CPU），因為一個進程佔用一個CPU時能充分利用機器的性能，但是進程多了就會出現頻繁的進程切換，反而得不償失。

不過特殊情況（特指IO密集型任務）下，多線程是比多進程好用的。

舉個例子：給你200W條url，需要你把每個url對應的頁面抓取保存起來，這種時候，單單使用多進程，效果肯定是很差的。為什麼呢？

例如每次請求的等待時間是2秒，那麼如下（忽略cpu計算時間）：

1、單進程+單線程：需要2秒*200W=400W秒==1111.11個小時==46.3天，這個速度明顯是不能接受的

2、單進程+多線程：例如我們在這個進程中開了10個多線程，比1中能夠提升10倍速度，也就是大約4.63天能夠完成200W條抓取，請注意，這里的實際執行是：線程1遇見了阻塞，CPU切換到線程2去執行，遇見阻塞又切換到線程3等等，10個線程都阻塞後，這個進程就阻塞了，而直到某個線程阻塞完成後，這個進程才能繼續執行，所以速度上提升大約能到10倍（這里忽略了線程切換帶來的開銷，實際上的提升應該是不能達到10倍的），但是需要考慮的是線程的切換也是有開銷的，所以不能無限的啟動多線程（開200W個線程肯定是不靠譜的）

3、多進程+多線程：這里就厲害了，一般來說也有很多人用這個方法，多進程下，每個進程都能佔一個cpu，而多線程從一定程度上繞過了阻塞的等待，所以比單進程下的多線程又更好使了，例如我們開10個進程，每個進程里開20W個線程，執行的速度理論上是比單進程開200W個線程快10倍以上的（為什麼是10倍以上而不是10倍，主要是cpu切換200W個線程的消耗肯定比切換20W個進程大得多，考慮到這部分開銷，所以是10倍以上）。

還有更好的方法嗎？答案是肯定的，它就是：

4、協程，使用它之前我們先講講what/why/how（它是什麼/為什麼用它/怎麼使用它）

what：

協程是一種用戶級的輕量級線程。協程擁有自己的寄存器上下文和棧。協程調度切換時，將寄存器上下文和棧保存到其他地方，在切回來的時候，恢復先前保存的寄存器上下文和棧。因此：

協程能保留上一次調用時的狀態（即所有局部狀態的一個特定組合），每次過程重入時，就相當於進入上一次調用的狀態，換種說法：進入上一次離開時所處邏輯流的位置。

在並發編程中，協程與線程類似，每個協程表示一個執行單元，有自己的本地數據，與其它協程共享全局數據和其它資源。

why：

目前主流語言基本上都選擇了多線程作為並發設施，與線程相關的概念是搶占式多任務（Preemptive multitasking），而與協程相關的是協作式多任務。

不管是進程還是線程，每次阻塞、切換都需要陷入系統調用(system call)，先讓CPU跑操作系統的調度程序，然後再由調度程序決定該跑哪一個進程(線程)。
而且由於搶占式調度執行順序無法確定的特點，使用線程時需要非常小心地處理同步問題，而協程完全不存在這個問題（事件驅動和非同步程序也有同樣的優點）。

因為協程是用戶自己來編寫調度邏輯的，對CPU來說，協程其實是單線程，所以CPU不用去考慮怎麼調度、切換上下文，這就省去了CPU的切換開銷，所以協程在一定程度上又好於多線程。

how:

python裡面怎麼使用協程？答案是使用gevent，使用方法：看這里

使用協程，可以不受線程開銷的限制，我嘗試過一次把20W條url放在單進程的協程里執行，完全沒問題。

所以最推薦的方法，是多進程+協程（可以看作是每個進程里都是單線程，而這個單線程是協程化的）

多進程+協程下，避開了CPU切換的開銷，又能把多個CPU充分利用起來，這種方式對於數據量較大的爬蟲還有文件讀寫之類的效率提升是巨大的。

小例子：

[python]view plain

• #-*-coding=utf-8-*-

• importrequests

• importgevent

• fromgeventimportmonkey;monkey.patch_all()

• importsys

• reload(sys)

• sys.setdefaultencoding('utf8')

• deffetch(url):

• try:

• s=requests.Session()

• r=s.get(url,timeout=1)#在這里抓取頁面

• exceptException,e:

• printe

• return''

• defprocess_start(url_list):

• tasks=[]

• forurlinurl_list:

• tasks.append(gevent.spawn(fetch,url))

• gevent.joinall(tasks)#使用協程來執行

• deftask_start(filepath,flag=100000):#每10W條url啟動一個進程

• withopen(filepath,'r')asreader:#從給定的文件中讀取url

• url=reader.readline().strip()

• url_list=[]#這個list用於存放協程任務

• i=0#計數器，記錄添加了多少個url到協程隊列

• whileurl!='':

• i+=1

• url_list.append(url)#每次讀取出url，將url添加到隊列

• ifi==flag:#一定數量的url就啟動一個進程並執行

• p=Process(target=process_start,args=(url_list,))

• p.start()

• url_list=[]#重置url隊列

• i=0#重置計數器

• url=reader.readline().strip()

• ifurl_listnot[]:#若退出循環後任務隊列里還有url剩餘

• p=Process(target=process_start,args=(url_list,))#把剩餘的url全都放到最後這個進程來執行

• p.start()

• if__name__=='__main__':

• task_start('./testData.txt')#讀取指定文件





細心的同學會發現：上面的例子中隱藏了一個問題：進程的數量會隨著url數量的增加而不斷增加，我們在這里不使用進程池multiprocessing.Pool來控制進程數量的原因是multiprocessing.Pool和gevent有沖突不能同時使用，但是有興趣的同學可以研究一下gevent.pool這個協程池。

㈤ python協程（4）：asyncio

asyncio是官方提供的協程的類庫，從python3.4開始支持該模塊

async & awiat是python3.5中引入的關鍵字，使用async關鍵字可以將一個函數定義為協程函數，使用awiat關鉛扒洞鍵字可以在遇到IO的時候掛起當前協程（也就是任務），去執行其他協程。
await + 可等待的對象（協程對象、Future對象、Task對象 -> IO等待）
注意：在python3.4中是通過asyncio裝飾器定義協程，在python3.8中已經移除了asyncio裝飾器。

事件循環，可以把他當做是槐枯一個while循環，這個while循環在周期性的運行並執行一些協程（任務），在特定條件下終止循環。
loop = asyncio.get_event_loop()：生成一個事件循環
loop.run_until_complete(任務)：將任務放到事件循環

Tasks用於並發調度協程，通過asyncio.create_task(協程對象)的方式創建Task對象，這樣可以讓協程加入事件循環中等待被調度執行。除了使用 asyncio.create_task() 函數以外，還可以用低層級的 loop.create_task() 或 ensure_future() 函數。不建議手動實例化 Task 對象。

本質上是將協程對象封裝成task對象，並將協程立即加入事件循環，同時追蹤協程的狀態。

注意：asyncio.create_task() 函數在 Python 3.7 中被加入。在 Python 3.7 之前，可此昌以改用 asyncio.ensure_future() 函數。

下面結合async & awiat、事件循環和Task看一個示例
示例一：

*注意：python 3.7以後增加了asyncio.run（協程對象），效果等同於loop = asyncio.get_event_loop()，loop.run_until_complete(協程對象) *

示例二：

注意：asyncio.wait 源碼內部會對列表中的每個協程執行ensure_future從而封裝為Task對象，所以在和wait配合使用時task_list的值為[func(),func()] 也是可以的。

示例三：

㈥ 學習python的話大概要學習哪些內容

想要學習Python，需要掌握的內容還是比較多的，對於自學的同學來說會有一些難度，不推薦自學能力差的人。我們將學習的過程劃分為4個階段，每個階段學習對應的內容，具體的學習順序如下：

Python學習順序：

①Python軟體開發基礎

• 掌握計算機的構成和工作原理

• 會使用Linux常用工具

• 熟練使用Docker的基本命令

• 建立Python開發環境，並使用print輸出

• 使用Python完成字元串的各種操作

• 使用Python re模塊進行程序設計

• 使用Python創建文件、訪問、刪除文件

• 掌握import 語句、From…import 語句、From…import* 語句、方法的引用、Python中的包

②Python軟體開發進階

• 能夠使用Python面向對象方法開發軟體

• 能夠自己建立資料庫，表，並進行基本資料庫操作

• 掌握非關系資料庫MongoDB的使用，掌握Redis開發

• 能夠獨立完成TCP/UDP服務端客戶端軟體開發，能夠實現ftp、http伺服器，開發郵件軟體

• 能開發多進程、多線程軟體

③Python全棧式WEB工程師

• 能夠獨立完成後端軟體開發，深入理解Python開發後端的精髓

• 能夠獨立完成前端軟體開發，並和後端結合，熟練掌握使用Python進行全站Web開發的技巧

④Python多領域開發

• 能夠使用Python熟練編寫爬蟲軟體

• 能夠熟練使用Python庫進行數據分析

• 招聘網站Python招聘職位數據爬取分析

• 掌握使用Python開源人工智慧框架進行人工智慧軟體開發、語音識別、人臉識別

• 掌握基本設計模式、常用演算法

• 掌握軟體工程、項目管理、項目文檔、軟體測試調優的基本方法

想要系統學習，你可以考察對比一下開設有IT專業的熱門學校，好的學校擁有根據當下企業需求自主研發課程的能，南京北大青鳥、中博軟體學院、南京課工場等都是不錯的選擇，建議實地考察對比一下。

祝你學有所成，望採納。