多核學習python實現

⑴ 最全面的12種python學習方式

Python 是世界上最受歡迎的編程語言之一，它受到了全世界各地的開發者和創客的歡迎。大多數 linux 和 MacOS 計算機都預裝了某個版本的 Python，現在甚至一些 Windows 計算機供應商也開始安裝 Python 了。
也許你尚未學會它，想學習但又不知道在哪裡入門。這里的 12 個資源將幫助你入門並熟練掌握 Python。
課程、書籍、文章和文檔
1、Python 軟體基金會提供了出色的信息和文檔，可幫助你邁上編碼之旅。請務必查看 Python 入門指南。它將幫助你得到最新版本的 Python，並提供有關編輯器和開發環境的有用提示。該組織還有可以來進一步指導你的優秀文檔。
2、我的 Python 旅程始於海龜模塊。我首先在 Bryson Payne 的《教你的孩子編碼》中找到了關於 Python 和海龜的內容。這本書是一個很好的資源，購買這本書可以讓你看到幾十個示常式序，這將激發你的編程好奇心。Payne 博士還在 Udemy 上以相同的名稱開設了一門便宜的課程。
3、Payne 博士的書激起了我的好奇心，我渴望了解更多。這時我發現了 Al Sweigart 的《用 Python 自動化無聊的東西》。你可以購買這本書，也可以使用它的在線版本，它與印刷版完全相同且可根據知識共享許可免費獲得和分享。Al 的這本書讓我學習到了 Python 的基礎知識、函數、列表、字典和如何操作字元串等等。這是一本很棒的書，我已經購買了許多本捐贈給了當地圖書館。Al 還提供 Udemy 課程；使用他的網站上的優惠券代碼，只需 10 美元即可參加。
4、Eric Matthes 撰寫了《Python 速成》，這是由 No Starch Press 出版的 Python 的逐步介紹（如同上面的兩本書）。Matthes 還有一個很棒的伴侶網站，其中包括了如何在你的計算機上設置 Python 以及一個用以簡化學習曲線的速查表。
5、Python for Everybody 是另一個很棒的 Python 學習資源。該網站可以免費訪問 Charles Severance 的 Coursera 和 edX 認證課程的資料。該網站分為入門、課程和素材等部分，其中 17 個課程按從安裝到數據可視化的主題進行分類組織。Severance（@drchuck on Twitter），是密歇根大學信息學院的臨床教授。
6、Seth Kenlon，我們 Opensource.com 的 Python 大師，撰寫了大量關於 Python 的文章。Seth 有很多很棒的文章，包括「用 JSON 保存和載入 Python 數據」，「用 Python 學習面向對象編程」，「在 Python 游戲中用 Pygame 放置平台」，等等。
在設備上使用 Python
7、最近我對 Circuit Playground Express 非常感興趣，這是一個運行 CircuitPython 的設備，CircuitPython 是為微控制器設計的 Python 編程語言的子集。我發現 Circuit Playground Express 和 CircuitPython 是向學生介紹 Python（以及一般編程）的好方法。它的製造商 Adafruit 有一個很好的系列教程，可以讓你快速掌握 CircuitPython。
8、BBC:Microbit 是另一種入門 Python 的好方法。你可以學習如何使用 MicroPython 對其進行編程，這是另一種用於編程微控制器的 Python 實現。
9、學習 Python 的文章如果沒有提到樹莓派單板計算機那是不完整的。一旦你有了舒適而強大的樹莓派，你就可以在 Opensource.com 上找到成噸的使用它的靈感，包括「7 個值得探索的樹莓派項目」，「在樹莓派上復活 Amiga」，和「如何使用樹莓派作為 VPN 伺服器」。
10、許多學校為學生提供了 iOS 設備以支持他們的教育。在嘗試幫助這些學校的老師和學生學慣用 Python 編寫代碼時，我發現了 Trinket.io。Trinket 允許你在瀏覽器中編寫和執行 Python 3 代碼。 Trinket 的 Python 入門教程將向你展示如何在 iOS 設備上使用 Python。
播客
11、我喜歡在開車的時候聽播客，我在 Kelly Paredes 和 Sean Tibor 的 Teaching Python 播客上找到了大量的信息。他們的內容很適合教育領域。
12、如果你正在尋找一些更通用的東西，我推薦 Michael Kennedy 的 Talk Python to Me 播客。它提供了有關 Python 及相關技術的最佳信息。
你學習 Python 最喜歡的資源是什麼？請在評論中分享。
計算機編程可能是一個有趣的愛好，正如我以前在 Apple II 計算機上編程時所學到的……

⑵ python入門教程

⑶ 為什麼使用Python，Python應用場景 特點

python一般認為是腳本語言，或者說是動態語言，速度慢肯定是所有解釋性語言的缺點了，除此之外，python的多線程無法在多核上運行肯定也
是需要解決的問題，不過它最大的優點就是敏捷，堪稱敏捷開發的典範，適合的場合分兩種：專業人士來做一些有意思的事情，比如寫一些很有意思的腳本啊（黑客
必學的語言之一）；非專業人士用來做一些普通的事情，比如搭個自己的網站（django）或者一般的科學計算、格式轉換等等。業界用python做web
開發其實蠻少，不過也有，web框架比較好用的就是django，比較適合快速開發程序員至少得會c語言吧，剩下的看需要。語言無所謂。只要人牛叉，什麼
語言都能寫出牛叉的程序。
-----
1. 支持OOP編程
從根本上講Python仍是一種面向對象的語言，支持多態、繼承等高級概念，在Python里使用OOP十分容易
沒有C++、java那樣復雜，但不必做Python下OOp高手，夠用即可。
2. 免費Python的使用是完全免費的，您可以從網路上免費下載、安裝使用，
Python上的其他程序包，也可下載安裝使用。
Python的免費的同時又有很多的的社區對用戶的提問提出快速的技術支持，學習和使用Python技術不再是一個人在戰斗！
3. 可移植性
Python的實現是用ansi c編寫的，可以運行在目前所有主流平台上，手機、pad上均可運行Python程序，其下的程序包也具有可移植性。
4. 功能強大
從特性的觀點上看，Python是一個混合體，他豐富的工具集使得他介於傳統的腳本語言和系統語言之間。
------
python好不好，還在於自己的積累與感覺。如果你積累的多，游刃有餘，會覺著它很好。從一般情況來看python是腳本語言之王，十年前是這樣，十年後還是這樣。
膠水是指，python藉助C語言介面，幾乎可以驅動所有已知的軟體，模塊。 只要我們用到的，通常你都能找到一個開源的庫。安裝後就可以驅動它。無論是資料庫，網路，互聯網，圖形，游戲，科學計算，GUI，OA，自動控制，甚至宇航員都在用。

python通常不作為工程語言出現。就是正規的軟體生產不使用它。主要用java, c#, xml, c。至於為什麼，這是軟體工程的需要。python不具有完整的語法檢查。

python並不為特定目的而產生。雖然它更適用於系統維護。不過它就是一個通用的腳本語言。

從個人感覺來說，微軟體東西，非常好，省心，一流的技術理念，開發工具是全世界最好的（沒有之一）。不過，因為它只限於微軟的平台，所以范圍上大大
打了折扣。
世界上最流行的伺服器還是unix和linux。而不是windows。桌面操作系統最流行的是windows。不過在所有的平台上都有C語言，大部分平
台，甚至手機平台都有python語言和它的執行環境。這是其它的所有語言，包括java幾乎都很難做到的。

python嚴格說叫CPython，與C/c++有天然的融合性。這也是python強大的原因之一。在windows環境下可以使用
ironpython，這個版本與vc可以結合的比較好。其它的平台可以使用eclipse，不過最好還是直接使用普通的文本編輯器。比較推薦的一個編輯
器是sublime text2, geany, vi等。

python圖形化編程不難。當然MFC也不難。我不認為MFC有多難。其實學習起來只是略難，但是這不是一個數量級的。MFC可以生產出非常強勁的界面。而python界面多屬於簡單的。

虛擬機可以跑linux，配置好就可以。也可以獨立安裝一個linux。也可以直接在windows下學習python。沒有太多區別。建議你買一個200多元的樹莓派，很好玩。安裝的是linux操作系統。

IDLE是我初學，甚至幾年中用得最多的。後來有了sublime才基本上不用它。idle只有一個缺點，就是有時候程序大了，輸入鍵盤會有感覺延遲。
---
python應用的很多的呀，web的比如豆瓣，還有非常多的網頁游戲的後端。我知道的都是作為後台服務，無論開發速度還是調試之類的都很好。前端的應用產品雖然python可以實現，但是在GUI方面的開發效率還是沒有VS或者XCode快。
----
如果說c是劍，c++是刀，java是槍的話，python就是飛刀，學精了可以成為李尋歡那樣的高手，當作常規武器用，不過絕大多數人只能把飛刀當作暗器，在某些特定場合，出奇制勝
----
做web開發肯定首選php 數據挖掘首選python
--
Python的web框架很多，比如Django，webpy等 - webpy

⑷ python多線程對多核的利用

GIL 與 Python 線程的糾葛
GIL 是什麼東西？它對我們的 python 程序會產生什麼樣的影響？我們先來看一個問題。運行下面這段 python 程序，CPU 佔用率是多少？
# 請勿在工作中模仿，危險:)
def dead_loop():
while True:
pass

dead_loop()

答案是什麼呢，佔用 100％ CPU？那是單核！還得是沒有超線程的古董 CPU。在我的雙核 CPU 上，這個死循環只會吃掉我一個核的工作負荷，也就是只佔用 50％ CPU。那如何能讓它在雙核機器上佔用 100％ 的 CPU 呢？答案很容易想到，用兩個線程就行了，線程不正是並發分享 CPU 運算資源的嗎。可惜答案雖然對了，但做起來可沒那麼簡單。下面的程序在主線程之外又起了一個死循環的線程
import threading

def dead_loop():
while True:
pass

# 新起一個死循環線程
t = threading.Thread(target=dead_loop)
t.start()

# 主線程也進入死循環
dead_loop()

t.join()

按道理它應該能做到佔用兩個核的 CPU 資源，可是實際運行情況卻是沒有什麼改變，還是只佔了 50％ CPU 不到。這又是為什麼呢？難道 python 線程不是操作系統的原生線程？打開 system monitor 一探究竟，這個佔了 50% 的 python 進程確實是有兩個線程在跑。那這兩個死循環的線程為何不能占滿雙核 CPU 資源呢？其實幕後的黑手就是 GIL。
GIL 的迷思：痛並快樂著
GIL 的全稱為 Global Interpreter Lock ，意即全局解釋器鎖。在 Python 語言的主流實現 CPython 中，GIL 是一個貨真價實的全局線程鎖，在解釋器解釋執行任何 Python 代碼時，都需要先獲得這把鎖才行，在遇到 I/O 操作時會釋放這把鎖。如果是純計算的程序，沒有 I/O 操作，解釋器會每隔 100 次操作就釋放這把鎖，讓別的線程有機會執行（這個次數可以通過sys.setcheckinterval 來調整）。所以雖然 CPython 的線程庫直接封裝操作系統的原生線程，但 CPython 進程做為一個整體，同一時間只會有一個獲得了 GIL 的線程在跑，其它的線程都處於等待狀態等著 GIL 的釋放。這也就解釋了我們上面的實驗結果：雖然有兩個死循環的線程，而且有兩個物理 CPU 內核，但因為 GIL 的限制，兩個線程只是做著分時切換，總的 CPU 佔用率還略低於 50％。
看起來 python 很不給力啊。GIL 直接導致 CPython 不能利用物理多核的性能加速運算。那為什麼會有這樣的設計呢？我猜想應該還是歷史遺留問題。多核 CPU 在 1990 年代還屬於類科幻，Guido van Rossum 在創造 python 的時候，也想不到他的語言有一天會被用到很可能 1000＋ 個核的 CPU 上面，一個全局鎖搞定多線程安全在那個時代應該是最簡單經濟的設計了。簡單而又能滿足需求，那就是合適的設計（對設計來說，應該只有合適與否，而沒有好與不好）。怪只怪硬體的發展實在太快了，摩爾定律給軟體業的紅利這么快就要到頭了。短短 20 年不到，代碼工人就不能指望僅僅靠升級 CPU 就能讓老軟體跑的更快了。在多核時代，編程的免費午餐沒有了。如果程序不能用並發擠干每個核的運算性能，那就意謂著會被淘汰。對軟體如此，對語言也是一樣。那 Python 的對策呢？
Python 的應對很簡單，以不變應萬變。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下幾點：
欲練神功，揮刀自宮：
CPython 的 GIL 本意是用來保護所有全局的解釋器和環境狀態變數的。如果去掉 GIL，就需要多個更細粒度的鎖對解釋器的眾多全局狀態進行保護。或者採用 Lock-Free 演算法。無論哪一種，要做到多線程安全都會比單使用 GIL 一個鎖要難的多。而且改動的對象還是有 20 年歷史的 CPython 代碼樹，更不論有這么多第三方的擴展也在依賴 GIL。對 Python 社區來說，這不異於揮刀自宮，重新來過。
就算自宮，也未必成功：
有位牛人曾經做了一個驗證用的 CPython，將 GIL 去掉，加入了更多的細粒度鎖。但是經過實際的測試，對單線程程序來說，這個版本有很大的性能下降，只有在利用的物理 CPU 超過一定數目後，才會比 GIL 版本的性能好。這也難怪。單線程本來就不需要什麼鎖。單就鎖管理本身來說，鎖 GIL 這個粗粒度的鎖肯定比管理眾多細粒度的鎖要快的多。而現在絕大部分的 python 程序都是單線程的。再者，從需求來說，使用 python 絕不是因為看中它的運算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。費了大力氣把 GIL 拿掉，反而讓大部分的程序都變慢了，這不是南轅北轍嗎。
難道 Python 這么優秀的語言真的僅僅因為改動困難和意義不大就放棄多核時代了嗎？其實，不做改動最最重要的原因還在於：不用自宮，也一樣能成功！
其它神功
那除了切掉 GIL 外，果然還有方法讓 Python 在多核時代活的滋潤？讓我們回到本文最初的那個問題：如何能讓這個死循環的 Python 腳本在雙核機器上佔用 100％ 的 CPU？其實最簡單的答案應該是：運行兩個 python 死循環的程序！也就是說，用兩個分別占滿一個 CPU 內核的 python 進程來做到。確實，多進程也是利用多個 CPU 的好方法。只是進程間內存地址空間獨立，互相協同通信要比多線程麻煩很多。有感於此，Python 在 2.6 里新引入了 multiprocessing這個多進程標准庫，讓多進程的 python 程序編寫簡化到類似多線程的程度，大大減輕了 GIL 帶來的不能利用多核的尷尬。
這還只是一個方法，如果不想用多進程這樣重量級的解決方案，還有個更徹底的方案，放棄 Python，改用 C/C++。當然，你也不用做的這么絕，只需要把關鍵部分用 C/C++ 寫成 Python 擴展，其它部分還是用 Python 來寫，讓 Python 的歸 Python，C 的歸 C。一般計算密集性的程序都會用 C 代碼編寫並通過擴展的方式集成到 Python 腳本里（如 NumPy 模塊）。在擴展里就完全可以用 C 創建原生線程，而且不用鎖 GIL，充分利用 CPU 的計算資源了。不過，寫 Python 擴展總是讓人覺得很復雜。好在 Python 還有另一種與 C 模塊進行互通的機制 : ctypes
利用 ctypes 繞過 GIL
ctypes 與 Python 擴展不同，它可以讓 Python 直接調用任意的 C 動態庫的導出函數。你所要做的只是用 ctypes 寫些 python 代碼即可。最酷的是，ctypes 會在調用 C 函數前釋放 GIL。所以，我們可以通過 ctypes 和 C 動態庫來讓 python 充分利用物理內核的計算能力。讓我們來實際驗證一下，這次我們用 C 寫一個死循環函數
extern"C"
{
void DeadLoop()
{
while (true);
}
}

用上面的 C 代碼編譯生成動態庫 libdead_loop.so （Windows 上是 dead_loop.dll）
，接著就要利用 ctypes 來在 python 里 load 這個動態庫，分別在主線程和新建線程里調用其中的 DeadLoop
from ctypes import *
from threading import Thread

lib = cdll.LoadLibrary("libdead_loop.so")
t = Thread(target=lib.DeadLoop)
t.start()

lib.DeadLoop()

這回再看看 system monitor，Python 解釋器進程有兩個線程在跑，而且雙核 CPU 全被占滿了，ctypes 確實很給力！需要提醒的是，GIL 是被 ctypes 在調用 C 函數前釋放的。但是 Python 解釋器還是會在執行任意一段 Python 代碼時鎖 GIL 的。如果你使用 Python 的代碼做為 C 函數的 callback，那麼只要 Python 的 callback 方法被執行時，GIL 還是會跳出來的。比如下面的例子：
extern"C"
{
typedef void Callback();
void Call(Callback* callback)
{
callback();
}
}

from ctypes import *
from threading import Thread

def dead_loop():
while True:
pass

lib = cdll.LoadLibrary("libcall.so")
Callback = CFUNCTYPE(None)
callback = Callback(dead_loop)

t = Thread(target=lib.Call, args=(callback,))
t.start()

lib.Call(callback)

注意這里與上個例子的不同之處，這次的死循環是發生在 Python 代碼里 (DeadLoop 函數) 而 C 代碼只是負責去調用這個 callback 而已。運行這個例子，你會發現 CPU 佔用率還是只有 50％ 不到。GIL 又起作用了。
其實，從上面的例子，我們還能看出 ctypes 的一個應用，那就是用 Python 寫自動化測試用例，通過 ctypes 直接調用 C 模塊的介面來對這個模塊進行黑盒測試，哪怕是有關該模塊 C 介面的多線程安全方面的測試，ctypes 也一樣能做到。
結語
雖然 CPython 的線程庫封裝了操作系統的原生線程，但卻因為 GIL 的存在導致多線程不能利用多個 CPU 內核的計算能力。好在現在 Python 有了易經筋（multiprocessing）, 吸星大法（C 語言擴展機制）和獨孤九劍（ctypes），足以應付多核時代的挑戰，GIL 切還是不切已經不重要了，不是嗎。

⑸ python如何利用多核cpu

你需要利用JavaScript，然後才能夠直接使用這個多核的CPU用編程的語言。

⑹ 學習Python就業有哪些方向

學習Python可以從事以下工作：
一、人工智慧
Python作為人工智慧的黃金語言，選擇人工智慧作為就業方向是理所當然的，而且就業前景好，薪資普遍較高，拉勾網上，人工智慧工程師的招聘起薪普遍在20K-35K，當然，如果是初級工程師，起薪也已經超過了12500元/月。
二、大數據
我們目前正處於大數據時代，Python這門語言在大數據上比Java更加有效率，大數據雖然難學，但是Python可以更好地和大數據對接，用Python做大數據的薪資也至少是20K以上了，大數據持續火爆，未來做大數據工程師，薪資還將逐漸上漲。
三、網路爬蟲工程師
網路爬蟲作為數據採集的利器，在大數據時代作為數據的源頭，十分有用武之地。利用Python可以更快的提升對數據抓取的精準程度和速度，是數據分析師的福祉，通過網路爬蟲，讓BOSS再也不用擔心你沒有數據。做爬蟲工程師的的薪資為20K起，當然，因為大數據，薪資也將一路上揚。
四、Python web全棧工程師
全棧工程師是指掌握多種技能，並能利用多種技能獨立完成產品的人。也叫全端工程師(同時具備前端和後台能力)，英文Full Stack developer。全棧工程師不管在哪個語言中都是人才中的人才，而Python web全棧工程師工資基本上都高出20K，所以如果你能力足夠，首選就是Pythonweb全棧工程師。
五、Python自動化運維
運維工作者對Python的需求很大，小夥伴們快快行動起來吧，學習Python自動化運維也能有個10k-15k的工資，很不錯哦。
六、Python自動化測試
Python這門語言十分高效，只要是和自動化有關系的，它可以發揮出巨大的優勢，目前做自動化測試的大部分的工作者都需要學習Python幫助提高測試效率。

⑺ 學python的10個有效方法有哪些

學習python主要是自學或者報班學習的方式，但不建議自學。

如果想通過學習python改行，那就需要明確一下自己的方向。因為python編程有很多方向，有網路爬蟲、數據分析、Web開發、測試開發、運維開發、機器學習、人工智慧、量化交易等等，各個方向都有特定的技能要求。

想學的話，當然是可以學習的。python是一門語法優美的編程語言，不僅可以作為小工具使用提升我們日常工作效率，也可以單獨作為一項高新就業技能！

python可以做的事情：

• 軟體開發：用python做軟體是很多人正在從事的工作，不管是B/S軟體，還是C/S軟體，都能做。並且需求量還是挺大的；

• 數據挖掘：python可以製作出色的爬蟲工具來進行數據挖掘，而在很多的網路公司中數據挖掘的崗位也不少；

• 游戲開發：python擴展性很好，擁有游戲開發的庫，而且游戲開發絕對是暴力職業；

• 大數據分析：如今是大數據的時代，用python做大數據也是可以的，大數據分析工程師也是炙手可熱的職位；

• 全棧工程師：如今程序員都在向著全棧的方向發展，而學習python更具備這方面的優勢；

• 系統運維：python在很多linux中都支持，而且語法特點很向shell腳本，學完python做個系統運維也是很不錯的。

互聯網行業目前還是最熱門的行業之一，學習IT技能之後足夠優秀是有機會進入騰訊、阿里、網易等互聯網大廠高薪就業的，發展前景非常好，普通人也可以學習。

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

祝你學有所成，望採納。

⑻ python怎麼實現一個進程

想要充分利用多核CPU資源，Python中大部分情況下都需要使用多進程，Python中提供了multiprocessing這個包實現多進程。multiprocessing支持子進程、進程間的同步與通信，提供了Process、Queue、Pipe、Lock等組件。

開辟子進程

multiprocessing中提供了Process類來生成進程實例

Process([group [, target [, name [, args [, kwargs]]]]])1

• group分組，實際上不使用

• target表示調用對象，你可以傳入方法的名字

• args表示給調用對象以元組的形式提供參數，比如target是函數a，他有兩個參數m，n，那麼該參數為args=(m, n)即可

• kwargs表示調用對象的字典

• name是別名，相當於給這個進程取一個名字

先來個小例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime()) #獲取當前進程號和正在運行是的時間


• time.sleep(wTime) #等待（休眠）


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,)) #申請子進程


• p.start() #運行進程


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())12345678910111213141516171819



運行結果：

Parent process run. subProcess is 30196
Parent process end,Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:21 2017
subProcess 30196 run, Mon Mar 27 11:20:23 2017
subProcess 30196 run, Mon Mar 27 11:20:25 2017

根據運行結果可知，父進程運行結束後子進程仍然還在運行，這可能造成僵屍（ zombie）進程。

通常情況下，當子進程終結時，它會通知父進程，清空自己所佔據的內存，並在內核里留下自己的退出信息。父進程在得知子進程終結時，會從內核中取出子進程的退出信息。但是，如果父進程早於子進程終結，這可能造成子進程的退出信息滯留在內核中，子進程成為僵屍（zombie）進程。當大量僵屍進程積累時，內存空間會被擠占。

有什麼辦法可以避免僵屍進程呢？
這里介紹進程的一個屬性 deamon，當其值為TRUE時，其父進程結束，該進程也直接終止運行（即使還沒運行完）。
所以給上面的程序加上p.deamon = true，看看效果。

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True #加入daemon


• p.start() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())



執行結果：

Parent process run. subProcess is 31856
Parent process end,Mon Mar 27 11:40:10 2017

這是問題又來了，子進程並沒有執行完，這不是所期望的結果。有沒辦法將子進程執行完後才讓父進程結束呢？
這里引入p.join()方法，它使子進程執行結束後，父進程才執行之後的代碼

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timedef run_proc(wTime):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(wTime)


• n += 1if __name__ == "__main__":


• p = Process(target=run_proc, args=(2,))


• p.daemon = True


• p.start()


• p.join() #加入join方法


• print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())21



執行結果：

subProcess 32076 run, Mon Mar 27 11:46:07 2017
subProcess 32076 run, Mon Mar 27 11:46:09 2017
subProcess 32076 run, Mon Mar 27 11:46:11 2017
Parent process run. subProcess is 32076
Parent process end,Mon Mar 27 11:46:13 2017

這樣所有的進程就能順利的執行了。

將進程定義成類

通過繼承Process類，來自定義進程類，實現run方法。實例p通過調用p.start()時自動調用run方法。
如下：

• # -*- coding:utf-8 -*-from multiprocessing import Process, Poolimport osimport timeclass Myprocess(Process):



• def __init__(self, wTime):


• Process.__init__(self)


• self.wTime = wTime def run(self):


• n = 0


• while n < 3: print "subProcess %s run," % os.getpid(), "{0}".format(time.ctime())


• time.sleep(self.wTime)


• n += 1if __name__ == "__main__":


• p = Myprocess(2)


• p.daemon = True


• p.start() #自動調用run方法


• p.join() print "Parent process run. subProcess is ", p.pid print "Parent process end,{0}".format(time.ctime())2122232425262728



執行結果和上一個例子相同。

創建多個進程

很多時候系統都需要創建多個進程以提高CPU的利用率，當數量較少時，可以手動生成一個個Process實例。當進程數量很多時，或許可以利用循環，但是這需要程序員手動管理系統中並發進程的數量，有時會很麻煩。這時進程池Pool就可以發揮其功效了。可以通過傳遞參數限制並發進程的數量，默認值為CPU的核數。
直接上例子：

• # -*- coding:utf-8 -*-from multiprocessing import Process,Poolimport os,timedef run_proc(name): ##定義一個函數用於進程調用


• for i in range(5):


• time.sleep(0.2) #休眠0.2秒


• print 'Run child process %s (%s)' % (name, os.getpid())#執行一次該函數共需1秒的時間if __name__ =='__main__': #執行主進程


• print 'Run the main process (%s).' % (os.getpid())


• mainStart = time.time() #記錄主進程開始的時間


• p = Pool(8) #開辟進程池


• for i in range(16): #開辟14個進程


• p.apply_async(run_proc,args=('Process'+str(i),))#每個進程都調用run_proc函數，


• #args表示給該函數傳遞的參數。



• print 'Waiting for all subprocesses done ...'


• p.close() #關閉進程池


• p.join() #等待開辟的所有進程執行完後，主進程才繼續往下執行


• print 'All subprocesses done'


• mainEnd = time.time() #記錄主進程結束時間


• print 'All process ran %0.2f seconds.' % (mainEnd-mainStart) #主進程執行時間21222324



執行結果：
開頭部分

Run the main process (30920).
Waiting for all subprocesses done …
Run child process Process0 (32396)
Run child process Process3 (25392)
Run child process Process1 (28732)
Run child process Process2 (32436)

末尾部分：

Run child process Process15 (25880)
All subprocesses done
All process last 2.49 seconds.

相關說明：

這里進程池對並發進程的限制數量為8個，而程序運行時會產生16個進程，進程池將自動管理系統內進程的並發數量，其餘進程將會在隊列中等待。限制並發數量是因為，系統中並發的進程不是越多越好，並發進程太多，可能使CPU大部分的時間用於進程調度，而不是執行有效的計算。

採用多進程並發技術時，就單個處理機而言，其對進程的執行是串列的。但具體某個時刻哪個進程獲得CPU資源而執行是不可預知的（如執行結果的開頭部分，各進程的執行順序不定），這就體現了進程的非同步性。

如果單個程序執行14次run_proc函數，那麼它會需要至少16秒,通過進程的並發，這里只需要2.49秒，可見並發的優勢。