python非同步編程

1. python都可以干什麼

網路爬蟲

爬蟲，指的是從互聯網採集數據的程序腳本 。

爬天爬地爬空氣 ，無聊的時候爬一爬吃雞數據、b站評論，能得出很多有意思的結論。知乎有個很有意思的問題——"利用爬蟲技術能做到哪些很酷很有趣很有用的事情"，感興趣的朋友可以自行搜索。

目前正值各大企業的秋季招聘期，沒有合適的簡歷模板，用Python爬一波就搞定。

人工智慧

其實，Python 無論是在傳統機器學習還是深度學習領域都佔有不可替代的地位。許多諸如 Scikit-learn 等機器學習庫使得 Python 極具優勢 ；

Keras 、TensorFlow 、Pytorch 等深度學習主流框架也決定了 Python在深度學習領域的天選之子地位。

2. python做web開發好嗎

Python適合從簡單到復雜的各種Web項目。它廣泛用於旅行，醫療保健，交通運輸，金融等不同領域，用於Web開發和軟體測試，腳本編寫和生成。
選擇Python進行Web開發的優點：
1、易於使用和閱讀
有幾個因素可以簡化Python在Web開發中的使用：
低入門門檻 Python與我們日常生活中使用的英語相似。語法的簡單性使您可以處理復雜的系統，並確保所有元素之間都具有明確的關系。因此，更多的新手程序員可以學習該語言並更快地加入編程社區。
良好的可視化 效果通過使用不同的圖和圖表，可以以易於理解的格式表示數據。它們是可視化呈現和理解數據的有效方法。Web開發公司利用Python庫（例如Matplotlib）來可視化數據並創建清晰且易於理解的報告。
Python非常易於閱讀，因此開發人員通常在理解由其他程序員編寫的代碼時不會遇到任何問題。這可以促使從事同一項目的開發人員之間的通信效率更高。
2、非同步編碼
由於沒有死鎖或研究爭執或任何其他令人困惑的問題，因此使用Python 編寫和維護非同步代碼無需花費太多精力。此類代碼的每個單元分別運行，從而使您能夠更快地處理各種情況和問題。
3、較少限制的編程方法
與其他編碼語言（例如Java）相比，Python具有較少限制的編程方法。它具有多種範例，可以支持多種編程風格，包括過程性，面向對象和功能性（命令性）。這使Python成為初創公司的絕佳語言，因為項目可能需要隨時更改方法。
4、企業應用集成
Python是企業軟體應用程序的流行選擇，這在很大程度上要歸功於Python與傳統上用於企業開發的其他語言（例如Java，PHP和.NET）的流暢集成。
Python直接與Java，C ++或C代碼進行調用，從而可以對大多數常用協議和數據格式進行大量的過程式控制制和實現。
除此之外，它還可以用於組裝基礎結構的新舊片段，這是復雜移動應用程序中的典型情況。
5、可以使用Python框架快速進行Web開發
Python的另一個優點是它具有許多簡化開發過程的框架。根據您的工作，可能需要不同的框架。
6、科學計算庫方便
有各種各樣的軟體包和庫可用於開發科學和數字應用程序，以及工具包（例如VTK 3D和MayaVi），單獨的成像庫以及許多其他工具。
7、用於機器學習和AI
機器學習（ML）和人工智慧（AI）技術越來越受到關注，因此越來越多的開發人員正在嘗試將它們納入各種項目中。如果使用正確的語言，這是可能的。
根據讓·弗朗索瓦·普吉，IBM的機器學習部門的代表，Python是ML和AI項目的頂尖語言，許多開發商同意。Python具有高效的ML軟體包，用於可視化結果的工具，並且遠遠超出了數據分析和其他使該應用程序領域受益的功能。
Python確實是機器學習和人工智慧最火熱的語言，沒有之一。
最典型的用語在線語音合成，在線語音識別，如果你的項目是建立一個人工智慧的web應用，那麼Python再適合不過了。
8、作為應用程序腳本
由於Python與C，C ++和Java的強大集成，Python可以很方便地用於應用程序腳本編寫。從一開始就被設計為可嵌入的，它對於自定義大型應用程序並為其進行擴展非常有用。
不敢說Python可以代替Lua，不過Python可以和Lua那樣被嵌入C/C++中。
9、軟體測試
Python用於測試自動化。許多QA自動化專家選擇Python是因為它具有簡單的學習曲線-對於技術背景較為有限的人（強大的社區，清晰的語法和可讀性）也非常有用。Python甚至有一個易於使用的單元測試框架（例如，您可以使用它對移動應用程序執行地理位置測試）。
M年前我在一家路由生產商上班，那時候我看到測試部門用Tcl腳本去測試路由器埠，我當時就覺得很詫異，畢竟Tcl腳本的語法真的很怪異，相比這點，Python的語法真的干凈簡潔。
10、在原型製作中使用
用Python創建原型已被證明是一個快速而簡單的過程。編程語言的敏捷性使代碼重構變得容易，並且可以將初始原型快速開發為最終產品。
11、開源
Python具有開放源代碼許可證，該許可證使用戶可以輕松訪問它，並有助於重新分發和無限制的修改。開發人員可以自由使用該語言並為它的改進做出貢獻。
12、伺服器端腳本
如上所述，使用Python進行伺服器端腳本編寫的優點之一是其簡單的語法，從而大大加快了處理速度。該代碼由功能模塊及其之間的連接組成，可讓您根據用戶操作執行程序演算法。Python還支持Web開發中所需的圖形用戶界面。
13、便攜性和交互性
Python具有動態語義和快速原型製作的出色功能，這要歸功於它的交互性和可移植性。它可以輕松地嵌入各種應用程序中，甚至是使用不同編碼語言的應用程序。因此，您可以輕松修復新模塊並擴展Python的核心詞彙。它可以連接各種組件。難怪它有時被稱為「膠水語言」。
推薦學習：《Python教程》

3. 在Python中使用Asyncio系統（3-4）​Task 和 Future

Task 和 Future

前面我們討論了協程，以及如何在循環中運行它們才有用。現在我想簡單談談Task和Future api。你將使用最多的是Task，因為你的大部分工作將涉及使用create_task()函數運行協程，就像在第22頁的「快速開始」中設置的那樣。Future類實際上是Task的超類，它提供了與循環交互操作的所有功能。

可以這樣簡單地理解:Future表示某個活動的未來完成狀態，並由循環管理。Task是完全相同的，但是具體的「activity」是一個協程——可能是你用async def函數加上create_task()創建的協程。

Future類表示與循環交互的某個東西的狀態。這個描述太模糊了，不太有用，所以你可以將Future實例視為一個切換器，一個完成狀態的切換器。當創建Future實例時，切換設置為「尚未完成」狀態，但稍後它將是「完成」狀態。事實上，Future實例有一個名為done()的方法，它允許你檢查狀態，如示例 3-15所示。

示例 3-15. 用done()方法檢查完成狀態

Future實例還可以執行以下操作：

• 設置一個result值（用.set_result(value)設置值並且使用 .result()獲取值）

• 使用.cancel()方法取消 (並且會用使用.cancelled()檢查是否取消)

• 增加一個Future完成時回調的函數

即使Task更常見，也不可能完全避免使用Future：例如，在執行器上運行函數將返回Future實例，而不是Task。讓我們快速看一下 示例 3-16 ，了解一下直接使用Future實例是什麼感覺。

示例 3-16. 與Future實例的交互

（L3）創建一個簡單的 main函數。我們運行這個函數，等上一會兒然後在Future f上設置一個結果。

（L5）設置一個結果。

（L8）手動創建一個Future實例。注意，這個實例(默認情況下)綁定到我們的循環，但它沒有也不會被附加到任何協程(這就是Tasks的作用)。

（L9）在做任何事情之前，確認future還沒有完成。

（L11）安排main()協程，傳遞future。請記住，main()協程所做的所有工作就是sleep，然後切換Future實例。(注意main()協程還不會開始運行：協程只在事件循環運行時才開始運行。)

(L13)在這里我們在Future實例上而不是Task實例上使用run_until_complete()。這和你以前見過的不一樣。現在循環正在運行，main()協程將開始執行.

（L16）最終，當future的結果被設置時，它就完成了。完成後，可以訪問結果。

當然，你不太可能以這里所示的方式直接使用Future；代碼示例僅用於教育目的。你與asynccio的大部分聯系都是通過Task實例進行的。

你可能想知道如果在Task實例上調用set_result()會發生什麼。在Python 3.8之前可以這樣做，但現在不允許這么做了。任務實例是協程對象的包裝器，它們的結果值只能在內部設置為底層協程函數的結果，如 示例 3-17所示那樣。

示例 3-17. 在task上調用set_result

（L13）唯一的區別是我們創建的是Task實例而不是Future實例。當然，Task API要求我們提供一個協程；這里我們使用sleep()只是因為簡單方便。

（L7）正在傳入一個Task實例。它滿足函數的類型簽名(因為Task是Future的子類)，但從Python 3.8開始，我們不再允許在Task上調用set_result()：嘗試這樣做將引發RuntimeError。這個想法是，一個Task代表一個正在運行的協程，所以結果應該總是來自於task自身。

（L10, L24）但是，我們仍然可以cancel()一個任務，它將在底層協程中引發CancelledError。

Create_task? Ensure_Future? 下定決心吧！

在第22頁的「快速入門」中，我說過運行協程的方法是使用asyncio.create_task()。在引入該函數之前，有必要獲取一個循環實例並使用loop.create_task()完成相同的任務。事實上，這也可以通過一個不同的模塊級函數來實現:asyncio.ensure_future()。一些開發人員推薦create_task()，而其他人推薦ensure_future()。

在我為這本書做研究的過程中，我確信API方法asyncio.ensure_future()是引起對asyncio庫廣泛誤解的罪魁禍首。API的大部分內容都非常清晰，但在學習過程中還存在一些嚴重的障礙，這就是其中之一。當你遇到ensure_future()時，你的大腦會非常努力地將其集成到關於asyncio應該如何使用的心理模型中——但很可能會失敗!

在Python 3.6 asyncio 文檔中，這個現在已經臭名昭著的解釋突出了 ensure_future() 的問題：

asyncio.ensure_future(coro_or_future, *, _loop =None)

安排執行一個協程對象：把它包裝在future中。返回一個Task對象。如果參數是Future，則直接返回。

什麼!? 當我第一次讀到這篇文章時，我很困惑。下面希望是對ensure_future()的更清楚的描述:

這個函數很好地說明了針對終端用戶開發人員的asyncio API(高級API)和針對框架設計人員的asyncio API(低級API)之間的區別。讓我們在示例 3-18中自習看看它是如何工作的。

示例 3-18. 仔細看看ensure_future()在做什麼

（L3）一個簡單的什麼都不做的協程函數。我們只需要一些能組成協程的東西。

（L6）我們通過直接調用該函數來創建協程對象。你的代碼很少會這樣做，但我想在這里明確地表示，我們正在向每個create_task()和ensure_future()傳遞一個協程對象。

（L7）獲取一個循環。

（L9）首先，我們使用loop.create_task()在循環中調度協程，並返回一個新的Task實例。

（L10）驗證類型。到目前為止，沒有什麼有趣的。

（L12）我們展示了asyncio.ensure_future()可以被用來執行與create_task()相同的動作：我們傳入了一個協程，並返回了一個Task實例(並且協程已經被安排在循環中運行)!如果傳入的是協程，那麼loop.create_task()和asyncio.ensure_future()之間沒有區別。

（L15）如果我們給ensure_future()傳遞一個Task實例會發生什麼呢？注意我們要傳遞的Task實例是已經在第4步通過loop.create_task()創建好的。

（L16）返回的Task實例與傳入的Task實例完全相同:它在被傳遞時沒有被改變。

直接傳遞Future實例的意義何在？為什麼用同一個函數做兩件不同的事情？答案是，ensure_future()的目的是讓框架作者向最終用戶開發者提供可以處理兩種參數的API。不相信我？這是ex-BDFL自己說的：

ensure_future()的要點是，如果你有一個可能是協程或Future(後者包括一個Task，因為它是Future的子類)的東西，並且你想能夠調用一個只在Future上定義的方法(可能唯一有用的例子是cancel())。當它已經是Future(或Task)時，它什麼也不做；當它是協程時，它將它包裝在Task中。

如果您知道您有一個協程，並且希望它被調度，那麼正確的API是create_task()。唯一應該調用ensure_future()的時候是當你提供一個API(像大多數asyncio自己的API)，它接受協程或Future，你需要對它做一些事情，需要你有一個Future。

—Guido van Rossum

總而言之，asyncio.sure_future()是一個為框架設計者准備的輔助函數。這一點最容易通過與一種更常見的函數進行類比來解釋，所以我們來做這個解釋。如果你有幾年的編程經驗，你可能已經見過類似於例3-19中的istify()函數的函數。示例 3-19中listify()的函數。

示例 3-19. 一個強制輸入列表的工具函數

這個函數試圖將參數轉換為一個列表，不管輸入的是什麼。api和框架中經常使用這類函數將輸入強制轉換為已知類型，這將簡化後續代碼——在本例中，您知道參數(來自listify()的輸出)將始終是一個列表。

如果我將listify()函數重命名為ensure_list()，那麼您應該開始看到與asyncio.ensure_future()的類似之處:它總是試圖將參數強制轉換為Future(或子類)類型。這是一個實用函數，它使框架開發人員(而不是像你我這樣的終端用戶開發人員)的工作變得更容易。

實際上，asyncio標准庫模塊本身使用ensure_future()正是出於這個原因。當你下次查看API時，你會發現函數參數被描述為「可等待對象」，很可能內部使用ensure_future()強制轉換參數。例如，asyncio.gather()函數就像下面的代碼一樣:

aws參數表示「可等待對象」，包括協程、task和future。在內部，gather()使用ensure_future()進行類型強制轉換：task和future保持不變，而把協程強制轉為task。

這里的關鍵是，作為終端用戶應用程序開發人員，應該永遠不需要使用asyncio.ensure_future()。它更像是框架設計師的工具。如果你需要在事件循環上調度協程，只需直接使用asyncio.create_task()來完成。

在接下來的幾節中，我們將回到語言級別的特性，從非同步上下文管理器開始。

4. python都可以做什麼

從語言的角度上來看，除了極少的領域之外，Python幾乎無所不能，該語言通俗易懂、容易入門、功能強大，學習後可以從事以下工作崗位：
1. Web開發
最火的Python web框架Django，支持非同步高並發的Tornado框架，短小精悍的flask,bottle,Django官方的標語把Django定義為the framework for perfectionist with deadlines(大意是一個為完全主義者開發的高效率web框架)
2. 網路編程
支持高並發的Twisted網路框架，py3引入的asyncio使非同步編程變的非常簡單
3. 爬蟲開發
爬蟲領域，Python幾乎是霸主地位，Scrapy/Request/BeautifuSoap/urllib等，想爬啥就爬啥
4. 雲計算開發
目前最火最知名的雲計算框架就是OpenStack,Python現在的火，很大一部分就是因為雲計算市場近幾年的爆發
5. 人工智慧
MASA和Google早期大量使用Python，為什麼Python積累了豐富的科學運算庫，當AI時代來臨後，Python從眾多編程語言中脫穎而出，各種人工智慧演算法都基於Python編寫，由其PyTorch之後，Python作為AI時代頭牌語言的位置基本確立!
6. 自動化運維
問問中國的每個運維人員，運維人員必須會的語言是什麼?10個人詳細會給你一個相同的答案，它的名字叫Python
7. 金融分析
金融公司使用的很多分析程序、高頻交易軟體就是用的Python，目前，Python是金融分析、量化交易領域里用的最多的語言
8. 科學運算
97年開始，NASA就在大量使用Python在進行各種復雜的科學運算，隨著NumPy，SciPy，Matplotlib，Enthought librarys等眾多程序庫的開發，使得Python越來越適合做科學計算、繪制高質量的2D和3D圖像。和科學計算領域最流行的商業軟體Matlab相比，Python是一門通用的程序設計語言，比Matlab所採用的腳本語言的應用范圍更廣泛
9. 游戲開發
在網路游戲開發中Python也有很多應用。相比Lua or C++，Python比Lua有更高階的抽象能力，可以用更少的代碼描述游戲業務邏輯，與Lua相比，Python更適合作為一種Host語言，即程序的入口點是在Python那一端會比較好，然後用C/C++在非常必要的時候寫一些擴展。Python非常適合編寫1萬行以上的項目，而且能夠很好的把網游項目的規模控制在10萬行代碼以內。
10. 桌面軟體
雖然大家很少使用桌面軟體了，但是Python在圖形界面開發上也很強大，你可以用tkinter/PyQT框架開發各種桌面軟體!

5. 一篇文章帶你深度解析Python線程和進程

使用Python中的線程模塊，能夠同時運行程序的不同部分，並簡化設計。如果你已經入門Python，並且想用線程來提升程序運行速度的話，希望這篇教程會對你有所幫助。

線程與進程

什麼是進程

進程是系統進行資源分配和調度的一個獨立單位 進程是具有一定獨立功能的程序關於某個數據集合上的一次運行活動,進程是系統進行資源分配和調度的一個獨立單位。每個進程都有自己的獨立內存空間，不同進程通過進程間通信來通信。由於進程比較重量，占據獨立的內存，所以上下文進程間的切換開銷（棧、寄存器、虛擬內存、文件句柄等）比較大，但相對比較穩定安全。

什麼是線程

CPU調度和分派的基本單位 線程是進程的一個實體，是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位.線程自己基本上不擁有系統資源,只擁有一點在運行中必不可少的資源(如程序計數器,一組寄存器和棧),但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。線程間通信主要通過共享內存，上下文切換很快，資源開銷較少，但相比進程不夠穩定容易丟失數據。

進程與線程的關系圖

線程與進程的區別：

進程

現實生活中，有很多的場景中的事情是同時進行的，比如開車的時候 手和腳共同來駕駛 汽車 ，比如唱歌跳舞也是同時進行的，再比如邊吃飯邊打電話；試想如果我們吃飯的時候有一個領導來電，我們肯定是立刻就接聽了。但是如果你吃完飯再接聽或者回電話，很可能會被開除。

注意：

多任務的概念

什麼叫 多任務 呢？簡單地說，就是操作系統可以同時運行多個任務。打個比方，你一邊在用瀏覽器上網，一邊在聽MP3，一邊在用Word趕作業，這就是多任務，至少同時有3個任務正在運行。還有很多任務悄悄地在後台同時運行著，只是桌面上沒有顯示而已。

現在，多核CPU已經非常普及了，但是，即使過去的單核CPU，也可以執行多任務。由於CPU執行代碼都是順序執行的，那麼，單核CPU是怎麼執行多任務的呢？

答案就是操作系統輪流讓各個任務交替執行，任務1執行0.01秒，切換到任務2，任務2執行0.01秒，再切換到任務3，執行0.01秒，這樣反復執行下去。表面上看，每個任務都是交替執行的，但是，由於CPU的執行速度實在是太快了，我們感覺就像所有任務都在同時執行一樣。

真正的並行執行多任務只能在多核CPU上實現，但是，由於任務數量遠遠多於CPU的核心數量，所以，操作系統也會自動把很多任務輪流調度到每個核心上執行。 其實就是CPU執行速度太快啦！以至於我們感受不到在輪流調度。

並行與並發

並行（Parallelism）

並行：指兩個或兩個以上事件（或線程）在同一時刻發生，是真正意義上的不同事件或線程在同一時刻，在不同CPU資源呢上（多核），同時執行。

特點

並發（Concurrency）

指一個物理CPU(也可以多個物理CPU) 在若幹道程序（或線程）之間多路復用，並發性是對有限物理資源強制行使多用戶共享以提高效率。

特點

multiprocess.Process模塊

process模塊是一個創建進程的模塊，藉助這個模塊，就可以完成進程的創建。

語法：Process([group [, target [, name [, args [, kwargs]]]]])

由該類實例化得到的對象，表示一個子進程中的任務（尚未啟動）。

注意：1. 必須使用關鍵字方式來指定參數；2. args指定的為傳給target函數的位置參數，是一個元祖形式，必須有逗號。

參數介紹：

group：參數未使用，默認值為None。

target：表示調用對象，即子進程要執行的任務。

args：表示調用的位置參數元祖。

kwargs：表示調用對象的字典。如kwargs = {'name':Jack, 'age':18}。

name：子進程名稱。

代碼：

除了上面這些開啟進程的方法之外，還有一種以繼承Process的方式開啟進程的方式：

通過上面的研究，我們千方百計實現了程序的非同步，讓多個任務可以同時在幾個進程中並發處理，他們之間的運行沒有順序，一旦開啟也不受我們控制。盡管並發編程讓我們能更加充分的利用IO資源，但是也給我們帶來了新的問題。

當多個進程使用同一份數據資源的時候，就會引發數據安全或順序混亂問題，我們可以考慮加鎖，我們以模擬搶票為例，來看看數據安全的重要性。

加鎖可以保證多個進程修改同一塊數據時，同一時間只能有一個任務可以進行修改，即串列的修改。加鎖犧牲了速度，但是卻保證了數據的安全。

因此我們最好找尋一種解決方案能夠兼顧：1、效率高（多個進程共享一塊內存的數據）2、幫我們處理好鎖問題。

mutiprocessing模塊為我們提供的基於消息的IPC通信機制：隊列和管道。隊列和管道都是將數據存放於內存中 隊列又是基於（管道+鎖）實現的，可以讓我們從復雜的鎖問題中解脫出來， 我們應該盡量避免使用共享數據，盡可能使用消息傳遞和隊列，避免處理復雜的同步和鎖問題，而且在進程數目增多時，往往可以獲得更好的可獲展性（ 後續擴展該內容 ）。

線程

Python的threading模塊

Python 供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和 threading 模塊允許程序員創建和管理線程。thread 模塊 供了基本的線程和鎖的支持，而 threading 供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間 共享數據的隊列數據結構。

python創建和執行線程

創建線程代碼

1. 創建方法一:

2. 創建方法二:

進程和線程都是實現多任務的一種方式，例如：在同一台計算機上能同時運行多個QQ（進程),一個QQ可以打開多個聊天窗口（線程）。資源共享：進程不能共享資源，而線程共享所在進程的地址空間和其他資源，同時，線程有自己的棧和棧指針。所以在一個進程內的所有線程共享全局變數，但多線程對全局變數的更改會導致變數值得混亂。

代碼演示:

得到的結果是：

首先需要明確的一點是GIL並不是Python的特性，它是在實現Python解析器(CPython)時所引入的一個概念。就好比C++是一套語言（語法）標准，但是可以用不同的編譯器來編譯成可執行代碼。同樣一段代碼可以通過CPython，PyPy，Psyco等不同的Python執行環境來執行（其中的JPython就沒有GIL）。

那麼CPython實現中的GIL又是什麼呢？GIL全稱Global Interpreter Lock為了避免誤導，我們還是來看一下官方給出的解釋：

主要意思為:

因此，解釋器實際上被一個全局解釋器鎖保護著，它確保任何時候都只有一個Python線程執行。在多線程環境中，Python 虛擬機按以下方式執行:

由於GIL的存在，Python的多線程不能稱之為嚴格的多線程。因為 多線程下每個線程在執行的過程中都需要先獲取GIL，保證同一時刻只有一個線程在運行。

由於GIL的存在，即使是多線程，事實上同一時刻只能保證一個線程在運行， 既然這樣多線程的運行效率不就和單線程一樣了嗎，那為什麼還要使用多線程呢？

由於以前的電腦基本都是單核CPU，多線程和單線程幾乎看不出差別，可是由於計算機的迅速發展，現在的電腦幾乎都是多核CPU了，最少也是兩個核心數的，這時差別就出來了：通過之前的案例我們已經知道，即使在多核CPU中，多線程同一時刻也只有一個線程在運行，這樣不僅不能利用多核CPU的優勢，反而由於每個線程在多個CPU上是交替執行的，導致在不同CPU上切換時造成資源的浪費，反而會更慢。即原因是一個進程只存在一把gil鎖，當在執行多個線程時，內部會爭搶gil鎖，這會造成當某一個線程沒有搶到鎖的時候會讓cpu等待，進而不能合理利用多核cpu資源。

但是在使用多線程抓取網頁內容時，遇到IO阻塞時，正在執行的線程會暫時釋放GIL鎖，這時其它線程會利用這個空隙時間，執行自己的代碼，因此多線程抓取比單線程抓取性能要好，所以我們還是要使用多線程的。

GIL對多線程Python程序的影響

程序的性能受到計算密集型(CPU)的程序限制和I/O密集型的程序限制影響,那什麼是計算密集型和I/O密集型程序呢?

計算密集型：要進行大量的數值計算，例如進行上億的數字計算、計算圓周率、對視頻進行高清解碼等等。這種計算密集型任務雖然也可以用多任務完成，但是花費的主要時間在任務切換的時間，此時CPU執行任務的效率比較低。

IO密集型：涉及到網路請求(time.sleep())、磁碟IO的任務都是IO密集型任務，這類任務的特點是CPU消耗很少，任務的大部分時間都在等待IO操作完成（因為IO的速度遠遠低於CPU和內存的速度）。對於IO密集型任務，任務越多，CPU效率越高，但也有一個限度。

當然為了避免GIL對我們程序產生影響，我們也可以使用，線程鎖。

Lock&RLock

常用的資源共享鎖機制：有Lock、RLock、Semphore、Condition等，簡單給大家分享下Lock和RLock。

Lock

特點就是執行速度慢，但是保證了數據的安全性

RLock

使用鎖代碼操作不當就會產生死鎖的情況。

什麼是死鎖

死鎖：當線程A持有獨占鎖a，並嘗試去獲取獨占鎖b的同時，線程B持有獨占鎖b，並嘗試獲取獨占鎖a的情況下，就會發生AB兩個線程由於互相持有對方需要的鎖，而發生的阻塞現象，我們稱為死鎖。即死鎖是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將無法向前推進。

所以，在系統設計、進程調度等方面注意如何不讓這四個必要條件成立，如何確定資源的合理分配演算法，避免進程永久占據系統資源。

死鎖代碼

python線程間通信

如果各個線程之間各干各的，確實不需要通信，這樣的代碼也十分的簡單。但這一般是不可能的，至少線程要和主線程進行通信，不然計算結果等內容無法取回。而實際情況中要復雜的多，多個線程間需要交換數據，才能得到正確的執行結果。

python中Queue是消息隊列，提供線程間通信機制，python3中重名為為queue，queue模塊塊下提供了幾個阻塞隊列，這些隊列主要用於實現線程通信。

在 queue 模塊下主要提供了三個類，分別代表三種隊列，它們的主要區別就在於進隊列、出隊列的不同。

簡單代碼演示

此時代碼會阻塞，因為queue中內容已滿，此時可以在第四個queue.put('蘋果')後面添加timeout，則成為 queue.put('蘋果'，timeout=1)如果等待1秒鍾仍然是滿的就會拋出異常，可以捕獲異常。

同理如果隊列是空的，無法獲取到內容默認也會阻塞，如果不阻塞可以使用queue.get_nowait()。

在掌握了 Queue 阻塞隊列的特性之後，在下面程序中就可以利用 Queue 來實現線程通信了。

下面演示一個生產者和一個消費者，當然都可以多個

使用queue模塊，可在線程間進行通信，並保證了線程安全。

協程

協程，又稱微線程，纖程。英文名Coroutine。

協程是python個中另外一種實現多任務的方式，只不過比線程更小佔用更小執行單元（理解為需要的資源）。為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。只要這個過程中保存或恢復 CPU上下文那麼程序還是可以運行的。

通俗的理解：在一個線程中的某個函數，可以在任何地方保存當前函數的一些臨時變數等信息，然後切換到另外一個函數中執行，注意不是通過調用函數的方式做到的，並且切換的次數以及什麼時候再切換到原來的函數都由開發者自己確定。

在實現多任務時，線程切換從系統層面遠不止保存和恢復 CPU上下文這么簡單。操作系統為了程序運行的高效性每個線程都有自己緩存Cache等等數據，操作系統還會幫你做這些數據的恢復操作。所以線程的切換非常耗性能。但是協程的切換只是單純的操作CPU的上下文，所以一秒鍾切換個上百萬次系統都抗的住。

greenlet與gevent

為了更好使用協程來完成多任務，除了使用原生的yield完成模擬協程的工作，其實python還有的greenlet模塊和gevent模塊，使實現協程變的更加簡單高效。

greenlet雖說實現了協程，但需要我們手工切換，太麻煩了，gevent是比greenlet更強大的並且能夠自動切換任務的模塊。

其原理是當一個greenlet遇到IO(指的是input output 輸入輸出，比如網路、文件操作等)操作時，比如訪問網路，就自動切換到其他的greenlet，等到IO操作完成，再在適當的時候切換回來繼續執行。

模擬耗時操作：

如果有耗時操作也可以換成，gevent中自己實現的模塊，這時候就需要打補丁了。

使用協程完成一個簡單的二手房信息的爬蟲代碼吧！

以下文章來源於Python專欄 ，作者宋宋

文章鏈接：https://mp.weixin.qq.com/s/2r3_ipU3HjdA5VnqSHjUnQ

6. python非同步有哪些方式

yield相當於return，他將相應的值返回給調用next()或者send()的調用者，從而交出了CPU使用權，而當調用者再次調用next()或者send()的時候，又會返回到yield中斷的地方，如果send有參數，還會將參數返回給yield賦值的變數,如果沒有就和next（）一樣賦值為None。但是這里會遇到一個問題，就是嵌套使用generator時外層的generator需要寫大量代碼，看如下示例：
注意以下代碼均在Python3.6上運行調試

#!/usr/bin/env python# encoding:utf-8def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before yield")
from_inner = 0
from_outer = 1
g = inner_generator()
g.send(None) while 1: try:
from_inner = g.send(from_outer)
from_outer = yield from_inner except StopIteration: breakdef main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()041

為了簡化，在Python3.3中引入了yield from

yield from

使用yield from有兩個好處，

1、可以將main中send的參數一直返回給最里層的generator，
2、同時我們也不需要再使用while循環和send (), next()來進行迭代。

我們可以將上邊的代碼修改如下：

def inner_generator():
i = 0
while True:
i = yield i if i > 10: raise StopIterationdef outer_generator():
print("do something before coroutine start") yield from inner_generator()def main():
g = outer_generator()
g.send(None)
i = 0
while 1: try:
i = g.send(i + 1)
print(i) except StopIteration: breakif __name__ == '__main__':
main()

執行結果如下：

do something before coroutine start123456789101234567891011

這里inner_generator()中執行的代碼片段我們實際就可以認為是協程，所以總的來說邏輯圖如下：

我們都知道Python由於GIL(Global Interpreter Lock)原因，其線程效率並不高，並且在*nix系統中，創建線程的開銷並不比進程小，因此在並發操作時，多線程的效率還是受到了很大制約的。所以後來人們發現通過yield來中斷代碼片段的執行，同時交出了cpu的使用權，於是協程的概念產生了。在Python3.4正式引入了協程的概念，代碼示例如下：

import asyncio# Borrowed from http://curio.readthedocs.org/en/latest/[email protected] countdown(number, n):
while n > 0:
print('T-minus', n, '({})'.format(number)) yield from asyncio.sleep(1)
n -= 1loop = asyncio.get_event_loop()
tasks = [
asyncio.ensure_future(countdown("A", 2)),
asyncio.ensure_future(countdown("B", 3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()12345678910111213141516

示例顯示了在Python3.4引入兩個重要概念協程和事件循環，
通過修飾符@asyncio.coroutine定義了一個協程，而通過event loop來執行tasks中所有的協程任務。之後在Python3.5引入了新的async & await語法，從而有了原生協程的概念。

async & await

在Python3.5中，引入了aync&await 語法結構，通過」aync def」可以定義一個協程代碼片段，作用類似於Python3.4中的@asyncio.coroutine修飾符，而await則相當於」yield from」。

先來看一段代碼，這個是我剛開始使用async&await語法時，寫的一段小程序。

#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time


async def wait_download(url):
response = await requets.get(url)
print("get {} response complete.".format(url))


async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))


loop = asyncio.get_event_loop()
loop.run_until_complete(main())

這里會收到這樣的報錯：

Task exception was never retrieved
future: <Task finished coro=<wait_download() done, defined at asynctest.py:9> exception=TypeError("object Response can't be used in 'await' expression",)>
Traceback (most recent call last):
File "asynctest.py", line 10, in wait_download
data = await requests.get(url)
TypeError: object Response can't be used in 'await' expression123456

這是由於requests.get()函數返回的Response對象不能用於await表達式，可是如果不能用於await，還怎麼樣來實現非同步呢？
原來Python的await表達式是類似於」yield from」的東西，但是await會去做參數檢查，它要求await表達式中的對象必須是awaitable的，那啥是awaitable呢？ awaitable對象必須滿足如下條件中其中之一：

1、A native coroutine object returned from a native coroutine function .

原生協程對象

2、A generator-based coroutine object returned from a function decorated with types.coroutine() .

types.coroutine()修飾的基於生成器的協程對象，注意不是Python3.4中asyncio.coroutine

3、An object with an await method returning an iterator.

實現了await method，並在其中返回了iterator的對象

根據這些條件定義，我們可以修改代碼如下：

#!/usr/bin/env python# encoding:utf-8import asyncioimport requestsimport time


async def download(url): # 通過async def定義的函數是原生的協程對象
response = requests.get(url)
print(response.text)


async def wait_download(url):
await download(url) # 這里download(url)就是一個原生的協程對象
print("get {} data complete.".format(url))


async def main():
start = time.time()
await asyncio.wait([
wait_download("http://www.163.com"),
wait_download("http://www.mi.com"),
wait_download("http://www.google.com")])
end = time.time()
print("Complete in {} seconds".format(end - start))


loop = asyncio.get_event_loop()
loop.run_until_complete(main())27282930

好了現在一個真正的實現了非同步編程的小程序終於誕生了。
而目前更牛逼的非同步是使用uvloop或者pyuv，這兩個最新的Python庫都是libuv實現的，可以提供更加高效的event loop。

uvloop和pyuv

pyuv實現了Python2.x和3.x，但是該項目在github上已經許久沒有更新了，不知道是否還有人在維護。
uvloop只實現了3.x, 但是該項目在github上始終活躍。

它們的使用也非常簡單，以uvloop為例，只需要添加以下代碼就可以了

import asyncioimport uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())123

7. python多線程只第一個while循環

Python 多線程只執行第一個 while 循環的原因是因為 Python 的全局鎖 (GIL) 的存在。GIL 是為了保證多線程操作時不會出現數據競爭和死鎖的問題，它會確保在任意時刻只有一個線程在執行 Python 代碼。雖然多線程在 Python 中可以提高程序的並發性，但是由於 GIL 的存在，導致 Python 的多線程無法真正地實現並行計算。因此，在 Python 中，多線程適合於 IO 密集型任務，而不適合於 CPU 密集型任務。

對於如何解決多線程只執行第一個 while 循環的問題，可以使用多進程和協程來代替多線程。多進程可以在不同的進程中運行 Python 代碼，每個進程都有自己的 GIL，因此可以實現真正的並行計算。而協程則是一種輕量級的線程，它不需要像線程一樣佔用系統資源，只需要在程序內部切換來實現並發計算皮渣。悔睜因此，在 Python 中，多進程和協程都是比較好的並發編程方式。

需要注意的是，多線程雖然存在 GIL 的限制，但對於一些 IO 密集型任務，多線程仍然可以提高程序的並發能力，因為在 IO 操作時，線程會釋放 GIL，從而可以讓其他線程進入運行狀態。因此，在實際編程中，需要燃前悄根據具體的任務需求，選擇合適的並發編程方式。

8. python培訓入門教程怎樣入門呢_如何學python入門

送你一份學習python的路線圖

一、Python的普及入門

1.1Python入門學習須知和書本配套學習建議

1.2Python簡史

1.3Python的市場需求及職業規劃

1.4Python學習是選擇2.0還是3.0？

二、Python的學謹念習環境安裝

1.在Windows安裝Python的教程

2.在Linux上安裝python

3.搭建Python多版本共存管理工具Pyenv

4.Python開發環境配置

三、開啟你的Python之路

1.Python世界的開端：helloworld

2.Python世界的開端：四則運算

3.Python流程式控制制語句深度解讀

4.Python循環

四、Python中級進階

1.Python數據類型詳解

2.Python列表及元組詳解

3.Python字元串操作深度解析

4.Python函數式編程指南：函數

5.Python函數式編程指南：迭代器

6.Python函數式編程指南：生成器

7.Python裝飾器詳解

五、Python高級技巧

1.裝飾器深度解析

2.深入Python字典

3.Python線程技術

4.Python的非同步IO：Asyncio簡介

5.Python實現線程安全隊列

六、Python常用工具

1.2017最受歡迎的15大Python庫

2.5個高效Python庫

3.Django官方教程

4.PythonDjango的正確學習方法

5.Python自然語逗晌爛言處理工具小結

6.數據科學常用Python工具

七、Python實戰練習

1.Python破解鬥地主殘局

2.python實現爬蟲功能

4.使用Python_PCA分析進行金融數據分析

5.用python製作游戲外掛嗎？

6.運用爬蟲抓取網易雲音樂評論生成詞雲

7.使用Scrapy爬起點網的完本小說

8.TensorFlow計算加速

八、其他

1.選擇學習編程，為什麼一定首推Python？

2.為什麼Python這么火？

3.Python如何快速入門？

4.Python入門之學習資料推薦

5.Python必備的19個編程資山漏源

6.Python入門知識點總結

7.Python學不好怎麼辦？

8.Python學習有哪些階段？

9.參加Python培訓會有前景嗎？

10.Python培訓班真的有效嗎？

11.參加Python培訓前應該做哪些准備？

12.11道Python基本面試題|深入解答

13.Python求職怎麼拿到Offer

9. python主要是做什麼

在我看來，Python 可以做任何事情。無論是從入門級選手到專業級選手都在做的爬蟲，還是Web 程序開發、桌面程序開發還是科學計
算、圖像處理，Python都可以勝任。
Python為我們提供了非常完善的基礎代碼庫，覆蓋了網路、文件、GUI、資料庫、文本等大量內容，被形象地稱作「內置電池(Batteries
included)」。用Python開發，許多功能不必從零編寫，直接使用現成的即可。
除了內置的庫外，Python還有大量的第三方庫，也就是別人開發的，供你直接使用的東西。當然，如果你開發的代碼通過很好的封裝，
也可以作為第三方庫給別人使用。
許多大型網站就是用Python開發的，例如YouTube、Instagram，還有國內的豆瓣。很多大公司，包括Google、Yahoo等，甚至
NASA(美國航空航天局)都大量地使用Python。
龜叔給Python的定位是「優雅」、「明確」、「簡單」，所以Python程序看上去總是簡單易懂，初學者學Python，不但入門容易，而且
將來深入下去，可以編寫那些非常非常復雜的程序。
總的來說，Python的哲學就是簡單優雅，盡量寫容易看明白的代碼，盡量寫少的代碼。如果一個資深程序員向你炫耀他寫的晦澀難懂、
動不動就幾萬行的代碼，你可以盡情地嘲笑他。
python學習網，免費的python學習網站，歡迎在線學習！

10. Python非同步編程7：非同步迭代器

迭代器：在其內部實現yield方法和next方法的對象。可迭代對象：在類內部實現一個iter方法，並返回一個迭代器。

非同步迭代器：實現了__aiter__()和__anext__()方法的對象，必須返回一個awaitable對象。async_for支持處理非同步迭代器的

__anext__()方法返回的可等侍春待對象，直到引發一個stopAsyncIteration異常謹乎，這個改動由PEP 492引入。

非同步可迭代對象：可在async_for語句中被使用的對象，必須通過它的__aiter__()方法老晌耐返回一個asynchronous_iterator（非同步迭代器）.  這個改動由PEP 492引入。

示例： 不能直接寫在普通方法或者暴露在外面。必須寫在協程函數，任意協程函數均可。