stacklesspython安裝

A. python stackless 怎麼多線程並發

1 介紹

1.1 為什麼要使用Stackless

摘自stackless網站。

Note

Stackless Python 是Python編程語言的一個增強版本，它使程序員從基於線程的編程方式中獲得好處，並避免傳統線程所帶來的性能與復雜度問題。Stackless為 Python帶來的微線程擴展，是一種低開銷、輕量級的便利工具，如果使用得當，可以獲益如下：

• 改進程序結構

• 增進代碼可讀性

• 提高編程人員生產力

以上是Stackless Python很簡明的釋義，但其對我們意義何在？——就在於Stackless提供的並發建模工具，比目前其它大多數傳統編程語言所提供的，都更加易用： 不僅是Python自身，也包括Java、C++，以及其它。盡管還有其他一些語言提供並發特性，可它們要麼是主要用於學術研究的（如 Mozart/Oz），要麼是罕為使用、或用於特殊目的的專業語言（如Erlang）。而使用stackless，你將會在Python本身的所有優勢之 上，在一個（但願）你已經很熟悉的環境中，再獲得並發的特性。

這自然引出了個問題：為什麼要並發？

1.1.1 現實世界就是並發的

現實世界就是「並發」的，它是由一群事物（或「演員」）所組成，而這些事物以一種對彼此所知有限的、鬆散耦合的方式相互作用。傳說中面向對象編程有 一個好處，就是對象能夠對現實的世界進行模擬。這在一定程度上是正確的，面向對象編程很好地模擬了對象個體，但對於這些對象個體之間的交互，卻無法以一種 理想的方式來表現。例如，如下代碼實例，有什麼問題？

• def familyTacoNight():


• husband.eat(dinner)


• wife.eat(dinner)


• son.eat(dinner)


• daughter.eat(dinner)

第一印象，沒問題。但是，上例中存在一個微妙的安排：所有事件是次序發生的，即：直到丈夫吃完飯，妻子才開始吃；兒子則一直等到母親吃完才吃；而女 兒則是最後一個。在現實世界中，哪怕是丈夫還堵車在路上，妻子、兒子和女兒仍然可以該吃就吃，而要在上例中的話，他們只能餓死了——甚至更糟：永遠沒有人 會知道這件事，因為他們永遠不會有機會拋出一個異常來通知這個世界！

1.1.2 並發可能是(僅僅可能是)下一個重要的編程範式

我個人相信，並發將是軟體世界裡的下一個重要範式。隨著程序變得更加復雜和耗費資源，我們已經不能指望摩爾定律來每年給我們提供更快的CPU了，當 前，日常使用的個人計算機的性能提升來自於多核與多CPU機。一旦單個CPU的性能達到極限，軟體開發者們將不得不轉向分布式模型，靠多台計算機的互相協 作來建立強大的應用（想想GooglePlex）。為了取得多核機和分布式編程的優勢，並發將很快成為做事情的方式的事實標准。

1.2 安裝stackless

安裝Stackless的細節可以在其網站上找到。現在Linux用戶可以通過SubVersion取得源代碼並編譯；而對於Windows用戶， 則有一個.zip文件供使用，需要將其解壓到現有的Python安裝目錄中。接下來，本教程假設Stackless Python已經安裝好了，可以工作，並且假設你對Python語言本身有基本的了解。

2 stackless起步

本章簡要介紹了stackless的基本概念，後面章節將基於這些基礎，來展示更加實用的功能。

2.1 微進程(tasklet)

微進程是stackless的基本構成單元，你可以通過提供任一個Python可調用對象（通常為函數或類的方法）來建立它，這將建立一個微進程並將其添加到調度器。這是一個快速演示:

• Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32


• bit (Intel)] on win32


• Type "help", "right", "credits" or "license" for more information.


• >>> import stackless


• >>>


• >>> def print_x(x):


• ... print x


• ...


• >>> stackless.tasklet(print_x)('one')


• <stackless.tasklet object at 0x00A45870>


• >>> stackless.tasklet(print_x)('two')


• <stackless.tasklet object at 0x00A45A30>


• >>> stackless.tasklet(print_x)('three')


• <stackless.tasklet object at 0x00A45AB0>


• >>>


• >>> stackless.run()


• one


• two


• three


• >>>

注意，微進程將排起隊來，並不運行，直到調用stackless.run()。

2.2 調度器(scheler)

調度器控制各個微進程運行的順序。如果剛剛建立了一組微進程，它們將按照建立的順序來執行。在現實中，一般會建立一組可以再次被調度的微進程，好讓每個都有輪次機會。一個快速演示:

• Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32


• bit (Intel)] on win32


• Type "help", "right", "credits" or "license" for more information.


• >>> import stackless


• >>>


• >>> def print_three_times(x):


• ... print "1:", x


• ... stackless.schele()


• ... print "2:", x


• ... stackless.schele()


• ... print "3:", x


• ... stackless.schele()


• ...


• >>>


• >>> stackless.tasklet(print_three_times)('first')


• <stackless.tasklet object at 0x00A45870>


• >>> stackless.tasklet(print_three_times)('second')


• <stackless.tasklet object at 0x00A45A30>


• >>> stackless.tasklet(print_three_times)('third')


• <stackless.tasklet object at 0x00A45AB0>


• >>>


• >>> stackless.run()


• 1: first


• 1: second


• 1: third


• 2: first


• 2: second


• 2: third


• 3: first


• 3: second


• 3: third


• >>>

注意：當調用stackless.schele()的時候，當前活動微進程將暫停執行，並將自身重新插入到調度器隊列的末尾，好讓下一個微進程被執行。一旦在它前面的所有其他微進程都運行過了，它將從上次 停止的地方繼續開始運行。這個過程會持續，直到所有的活動微進程都完成了運行過程。這就是使用stackless達到合作式多任務的方式。

2.3 通道(channel)

通道使得微進程之間的信息傳遞成為可能。它做到了兩件事：

• 能夠在微進程之間交換信息。

• 能夠控制運行的流程。

又一個快速演示:

• C:>c:python24python


• Python 2.4.3 Stackless 3.1b3 060504 (#69, May 3 2006, 19:20:41) [MSC v.1310 32


• bit (Intel)] on win32


• Type "help", "right", "credits" or "license" for more information.


• >>> import stackless


• >>>


• >>> channel = stackless.channel()


• >>>


• >>> def receiving_tasklet():


• ... print "Recieving tasklet started"


• ... print channel.receive()


• ... print "Receiving tasklet finished"


• ...


• >>> def sending_tasklet():


• ... print "Sending tasklet started"


• ... channel.send("send from sending_tasklet")


• ... print "sending tasklet finished"


• ...


• >>> def another_tasklet():


• ... print "Just another tasklet in the scheler"


• ...


• >>> stackless.tasklet(receiving_tasklet)()


• <stackless.tasklet object at 0x00A45B30>


• >>> stackless.tasklet(sending_tasklet)()


• <stackless.tasklet object at 0x00A45B70>


• >>> stackless.tasklet(another_tasklet)()


• <stackless.tasklet object at 0x00A45BF0>


• >>>


• >>> stackless.run()


• Recieving tasklet started


• Sending tasklet started


• send from sending_tasklet


• Receiving tasklet finished


• Just another tasklet in the scheler


• sending tasklet finished


• >>>

接收的微進程調用channel.receive()的時候，便阻塞住，這意味著該微進程暫停執行，直到有信息從這個通道送過來。除了往這個通道發送信息以外，沒有其他任何方式可以讓這個微進程恢復運行。

若有其他微進程向這個通道發送了信息，則不管當前的調度到了哪裡，這個接收的微進程都立即恢復執行；而發送信息的微進程則被轉移到調度列表的末尾，就像調用了stackless.schele()一樣。

同樣注意，發送信息的時候，若當時沒有微進程正在這個通道上接收，也會使當前微進程阻塞:

• >>> stackless.tasklet(sending_tasklet)()


• <stackless.tasklet object at 0x00A45B70>


• >>> stackless.tasklet(another_tasklet)()


• <stackless.tasklet object at 0x00A45BF0>


• >>>


• >>> stackless.run()


• Sending tasklet started


• Just another tasklet in the scheler


• >>>


• >>> stackless.tasklet(another_tasklet)()


• <stackless.tasklet object at 0x00A45B30>


• >>> stackless.run()


• Just another tasklet in the scheler


• >>>


• >>> #Finally adding the receiving tasklet


• ...


• >>> stackless.tasklet(receiving_tasklet)()


• <stackless.tasklet object at 0x00A45BF0>


• >>>


• >>> stackless.run()


• Recieving tasklet started


• send from sending_tasklet


• Receiving tasklet finished


• sending tasklet finished

發送信息的微進程，只有在成功地將數據發送到了另一個微進程之後，才會重新被插入到調度器中。

2.4 總結

以上涵蓋了stackless的大部分功能。似乎不多是吧？——我們只使用了少許對象，和大約四五個函數調用，來進行操作。但是，使用這種簡單的API作為基本建造單元，我們可以開始做一些真正有趣的事情。

3 協程(coroutine)

3.1 子常式的問題

大多數傳統編程語言具有子常式的概念。一個子常式被另一個常式（可能還是其它某個常式的子常式）所調用，或返回一個結果，或不返回結果。從定義上說，一個子常式是從屬於其調用者的。

見下例:

• def ping():


• print "PING"


• pong()



• def pong():


• print "PONG"


• ping()



• ping()

有經驗的編程者會看到這個程序的問題所在：它導致了堆棧溢出。如果運行這個程序，它將顯示一大堆討厭的跟蹤信息，來指出堆棧空間已經耗盡。

3.1.1 堆棧

我仔細考慮了，自己對C語言堆棧的細節究竟了解多少，最終還是決定完全不去講它。似乎，其他人對其所嘗試的描述，以及圖表，只有本身已經理解了的人才能看得懂。我將試著給出一個最簡單的說明，而對其有更多興趣的讀者可以從網上查找更多信息。

每當一個子常式被調用，都有一個「棧幀」被建立，這是用來保存變數，以及其他子常式局部信息的區域。於是，當你調用 ping() ，則有一個棧幀被建立，來保存這次調用相關的信息。簡言之，這個幀記載著 ping 被調用了。當再調用 pong() ，則又建立了一個棧幀，記載著 pong 也被調用了。這些棧幀是串聯在一起的，每個子常式調用都是其中的一環。就這樣，堆棧中顯示： ping 被調用所以 pong 接下來被調用。顯然，當 pong() 再調用 ping() ，則使堆棧再擴展。下面是個直觀的表示：

幀 堆棧

1 ping 被調用

2 ping 被調用，所以 pong 被調用

3 ping 被調用，所以 pong 被調用，所以 ping 被調用

4 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用

5 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用，所以 ping 被調用

6 ping 被調用，所以 pong 被調用，所以 ping 被調用，所以 pong 被調用，所以 ping 被調用……

現在假設，這個頁面的寬度就表示系統為堆棧所分配的全部內存空間，當其頂到頁面的邊緣的時候，將會發生溢出，系統內存耗盡，即術語「堆棧溢出」。

3.1.2 那麼，為什麼要使用堆棧？

上例是有意設計的，用來體現堆棧的問題所在。在大多數情況下，當每個子常式返回的時候，其棧幀將被清除掉，就是說堆棧將會自行實現清理過程。這一般 來說是件好事，在C語言中，堆棧就是一個不需要編程者來手動進行內存管理的區域。很幸運，Python程序員也不需要直接來擔心內存管理與堆棧。但是由於 Python解釋器本身也是用C實現的，那些實現者們可是需要擔心這個的。使用堆棧是會使事情方便，除非我們開始調用那種從不返回的函數，如上例中的，那 時候，堆棧的表現就開始和程序員別扭起來，並耗盡可用的內存。

3.2 走進協程

此時，將堆棧弄溢出是有點愚蠢的。 ping() 和 pong() 本不是真正意義的子常式，因為其中哪個也不從屬於另一個，它們是「協程」，處於同等的地位，並可以彼此間進行無縫通信。

幀 堆棧

1 ping 被調用

2 pong 被調用

3 ping 被調用

4 pong 被調用

5 ping 被調用

6 pong 被調用

在stackless中，我們使用通道來建立協程。還記得嗎，通道所帶來的兩個好處中的一個，就是能夠控制微進程之間運行的流程。使用通道，我們可以在 ping 和 pong 這兩個協程之間自由來回，要多少次就多少次，都不會堆棧溢出:

• #


• # pingpong_stackless.py


• #



• import stackless



• ping_channel = stackless.channel()


• pong_channel = stackless.channel()



• def ping():


• while ping_channel.receive(): #在此阻塞


• print "PING"


• pong_channel.send("from ping")



• def pong():


• while pong_channel.receive():


• print "PONG"


• ping_channel.send("from pong")



• stackless.tasklet(ping)()


• stackless.tasklet(pong)()



• # 我們需要發送一個消息來初始化這個游戲的狀態


• # 否則，兩個微進程都會阻塞


• stackless.tasklet(ping_channel.send)('startup')



• stackless.run()

你可以運行這個程序要多久有多久，它都不會崩潰，且如果你檢查其內存使用量（使用Windows的任務管理器或Linux的top命令），將會發現 使用量是恆定的。這個程序的協程版本，不管運行一分鍾還是一天，使用的內存都是一樣的。而如果你檢查原先那個遞歸版本的內存用量，則會發現其迅速增長，直 到崩潰。

3.3 總結

是否還記得，先前我提到過，那個代碼的遞歸版本，有經驗的程序員會一眼看出毛病。但老實說，這裡面並沒有什麼「計算機科學」方面的原因在阻礙它的正 常工作，有些讓人堅信的東西，其實只是個與實現細節有關的小問題——只因為大多數傳統編程語言都使用堆棧。某種意義上說，有經驗的程序員都是被洗了腦，從 而相信這是個可以接受的問題。而stackless，則真正察覺了這個問題，並除掉了它。

4 輕量級線程

與當今的操作系統中內建的、和標准Python代碼中所支持的普通線程相比，「微線程」要更為輕量級，正如其名稱所暗示。它比傳統線程佔用更少的內存，並且微線程之間的切換，要比傳統線程之間的切換更加節省資源。

為了准確說明微線程的效率究竟比傳統線程高多少，我們用兩者來寫同一個程序。

4.1 hackysack模擬

Hackysack是一種游戲，就是一夥臟乎乎的小子圍成一個圈，來回踢一個裝滿了豆粒的沙包，目標是不讓這個沙包落地，當傳球給別人的時候，可以耍各種把戲。踢沙包只可以用腳。

在我們的簡易模擬中，我們假設一旦游戲開始，圈裡人數就是恆定的，並且每個人都是如此厲害，以至於如果允許的話，這個游戲可以永遠停不下來。

4.2 游戲的傳統線程版本

• import thread


• import random


• import sys


• import Queue



• class hackysacker:


• counter = 0


• def __init__(self,name,circle):


• self.name = name


• self.circle = circle


• circle.append(self)


• self.messageQueue = Queue.Queue()



• thread.start_new_thread(self.messageLoop,())



• def incrementCounter(self):


• hackysacker.counter += 1


• if hackysacker.counter >= turns:


• while self.circle:


• hs = self.circle.pop()


• if hs is not self:


• hs.messageQueue.put('exit')


• sys.exit()



• def messageLoop(self):


• while 1:


• message = self.messageQueue.get()


• if message == "exit":


• debugPrint("%s is going home" % self.name)


• sys.exit()


• debugPrint("%s got hackeysack from %s" % (self.name, message.name))


• kickTo = self.circle[random.randint(0,len(self.circle)-1)]


• debugPrint("%s kicking hackeysack to %s" % (self.name, kickTo.name))


• self.incrementCounter()


• kickTo.messageQueue.put(self)



• def debugPrint(x):


• if debug:


• print x



• debug=1


• hackysackers=5


• turns = 5



• 
  

B. python 集成開發環境哪個好

1. Pydev+Eclipse–最好的免費python IDE

Pydev的是PythonIDE中使用最普遍的，原因很簡單，它是免費的，同時還提供很多強大的功能來支持高效的Python編程。Pydev是一個運行在eclipse上的開源插件，它把python帶進了eclipse的王國，如果你本來就是是一個eclipse的用戶那麼Pydev將給你家裡一樣的感覺。

Pydev能高居榜首，得益於這些關鍵功能，包括Django集成、自動代碼補全、多語言支持、集成的Python調試、代碼分析、代碼模板、智能縮進、括弧匹配、錯誤標記、源代碼控制集成、代碼折疊、UML編輯和查看和單元測試整合等。

2. PyCharm–最好的商業python IDE

PyCharm是專業的python集成開發環境，有兩個版本。一個是免費的社區版本，另一個是面向企業開發者的更先進的專業版本。

大部分的功能在免費版本中都是可用的，包括智能代碼補全、直觀的項目導航、錯誤檢查和修復、遵循PEP8規范的代碼質量檢查、智能重構，圖形化的調試器和運行器。它還能與IPython
notebook進行集成，並支持Anaconda及其他的科學計算包，比如matplotlib和NumPy。

PyCharm專業版本支持更多高級的功能，比如遠程開發功能、資料庫支持以及對web開發框架的支持等。

3.VIM

VIM是一個很先進的文本編輯器，在python開發者社區中很受歡迎。它是一個開源軟體並遵循GPL協議，所以你可以免費的使用它。

雖然VIM是最好的文本編輯器，但是它提供的功能不亞於此，經過正確的配置後它可以成為一個全功能的Python開發環境。此外VIM還是一個輕量級的、模塊化、快速響應的工具，非常適合那些很牛的程序員—編程從不用滑鼠的人。

4. Wing IDE

Wing IDE是另外一個商業的、面向專業開發人員的python集成開發環境，可以運行在windows、OSX和Linux系統上，支持最新版本的python，包括stackless Python。Wing
IDE分三個版本：免費的基礎版，個人版以及更強大的專業版。

調試功能是WingIDE的一大亮點，包括多線程調試，線程代碼調試，自動子進程調試，斷點，單步代碼調試，代碼數據檢查等功能，此外還提供了在樹莓派上進行遠程調試的功能。

5.Spyder Python

SpyderPython是一個開源的python集成開發環境，非常適合用來進行科學計算方面的python開發。是一個輕量級的軟體，是用python開發的，遵循MIT協議，可免費使用。

Spyder python的基本功能包括多語言編輯器、互動式控制台、文件查看、variable explorer、文件查找、文件管理等。SpyderIDE也可以運行於windows、Mac或者Linux系統之上。

6.Komodo IDE

Komodo是Activestate公司開發的一個跨平台的集成開發環境，支持多種語言包括python。它是商用產品，但是提供了開源的免費版本叫KomodoEdit，能夠安裝在Mac、Windows和Linux系統上。

和大多數的專業pythonIDE一樣，Komodo也提供了代碼重構，自動補全，調用提示，括弧匹配，代碼瀏覽器，代碼跳轉，圖形化調試，多進程調試，多線程調試，斷點，代碼分析，集成測試單元等功能，並且集成其他的第三方庫，比如pyWin32。

7.PTVS-Best Python IDE for Windows

PTVS集成在Visual Studio中，就像Pydev可以集成在eclipse中一樣。PTVS將Visual
Studio變成了一個強大的、功能豐富的python集成開發環境，並且它是開源的，完全的免費。PTVS發布於2015年，由社區和微軟自己在維護。

8.Eric Python

Eric是一個開源python代碼編輯器和集成開發環境，提供很多高效編程需要的功能。它是純python編寫的，基於QtGUI並集成強大的Scintilla編輯器功能。

Eric由DetlevOffenbach創建，遵循GPL協議，免費使用。經過多年的開發完善Eric已經成為一個常用的、功能豐富的集成開發環境。它提供一個可靠的插件管理系統，可以通過插件來擴展功能。

Eric提供所有的基礎功能，比如調用提示、代碼折疊、代碼高亮、類瀏覽器、代碼覆蓋及分析等等。

9.Sublime Text3

Sublime Text3是目前為止功能最強大的跨平台的、輕量級的代碼編輯器。通過添加插件Sublime Text3可以成一個全功能的pythonIDE。

10.Emacs-Python Editor cum IDE

Emacs有屬於它自己的生態系統，它是一個可擴展的並能高度定製的GNU文本編輯器。它可以配置為一個全功能的免費的python集成開發環境。

Emacs在python開發中很受歡迎，他通過python-mode提供開箱即用的python。Emacs可以通過額外的擴展包來增加更多的高級功能。

C. Stackless Python到底是什麼東東和Python什麼關系

Stackless Python 是Python編程語言的一個增強版本，它使程序員從基於線程的編程方式中獲得好處，並避免傳統線程所帶來的性能與復雜度問題。
CPython是用C語言實現的Python解釋器，也是官方的並且是最廣泛使用的Python解釋器
JPython是一個Python語言在Java中的完全實現，Jython不僅給你提供了Python的庫，同時也提供了所有的Java類
除了CPython，Jython以外，還有用.NET實現的IronPython

D. python(x,y)安裝後打不開

應該是python版本混亂了吧。
如果安裝了兩個python版本，path里只能添加一個，作為默認python使用，另一個只能通過全路徑調用。
如果spyder只支持python2，你可以把python2作為默認的python，也就是把python2.7的路徑添加到path里。而要使用stackless的時候，在cmd中輸入完整的消歲python路徑，比如：
d://python3/bin/python
如果解決頃纖了您的拿乎睜問題請採納！
如果未解決請繼續追問

E. 安裝stackless python for mac以後無法 import stackless

你需要將pydev的python解析器重定向到你的stackless目錄下面。

F. 如何利用Python嗅探數據包

一提到Python獲取數據包的方式，相信很多Python愛好者會利用Linux的libpcap軟體包或利用Windows下的WinPcap可移植版的方式進行抓取數據包，然後再利用dpkt軟體包進行協議分析，我們這里想換一個角度去思考：1.Python版本的pcap存儲內存數據過小，也就是說緩存不夠，在高並發下容易發生丟包現象，其實C版本的也同樣存在這樣的問題，只不過Python版本的緩存實在是過低，讓人很郁悶。2.dpkt協議分析並非必須，如果你對RFC791和RFC793等協議熟悉的話，完全可以使用struct.unpack的方式進行分析。如果你平常習慣使用tcpmp抓取數據包的話，完全可以使用它來代替pcap軟體包，只不過我們需要利用tcpmp將抓取的數據以pcap格式進行保存，說道這里大家一定會想到Wireshark工具，具體命令如下：tcpmpdst10.13.202.116andtcpdstport80-s0-ieth1-w../pcap/tcpmp.pcap-C1k-W5我們首先需要對pcap文件格式有所了解，具體信息大家可以參考其他資料文檔，我這里只說其重要的結構體組成，如下：sturctpcap_file_header{DWORDmagic;WORDversion_major;WORDversion_minor;DWORDthiszone;DWORDsigfigs;DWORDsnaplen;DWORDlinktype;}structpcap_pkthdr{structtimevalts;DWORDcaplen;DWORDlen;}structtimeval{DWORDGMTtime;DWORDmicroTime;}這里需要說明的一點是，因為在Python的世界裡一切都是對象，所以往往Python在處理數據包的時候感覺讓人比較麻煩。Python提供了幾個libpcapbind,這里有一個最簡單的。在windows平台上,你需要先安裝winpcap,如果你已經安裝了Ethereal非常好用。一個規范的抓包過程:importpcapimportdpktpc=pcap.pcap()#注，參數可為網卡名，如eth0pc.setfilter('tcpport80')#設置監聽過濾器forptime,pdatainpc:#ptime為收到時間，pdata為收到數據printptime,pdata#對抓到的乙太網V2數據包(rawpacket)進行解包:p=dpkt.ethernet.Ethernet(pdata)ifp.data.__class__.__name__=='IP':ip='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))ifp.data.data.__class__.__name__=='TCP':ifdata.dport==80:printp.data.data.data一些顯示參數nrecv,ndrop,nifdrop=pc.stats()返回的元組中，第一個參數為接收到的數據包，第二個參數為被核心丟棄的數據包。至於對於如何監控tcpmp生成的pcap文件數據，大家可以通過pyinotify軟體包來實現，如下：classPacker(pyinotify.ProcessEvent):def__init__(self,proct):self.proct=proctself.process=Nonedefprocess_IN_CREATE(self,event):logger.debug("createfile:%sinqueue"%self.process_IF_START_THREAD(event))defprocess_IN_MODIFY(self,event):self.process_IF_START_THREAD(event)logger.debug("modifyfile:%sinqueue"%self.process_IF_START_THREAD(event))defprocess_IN_DELETE(self,event):filename=os.path.join(event.path,event.name)logger.debug("deletefile:%s"%filename)defprocess_IF_START_THREAD(self,event):filename=os.path.join(event.path,event.name)iffilename!=self.process:self.process=filenameself.proct.put(filename)ifself.proct.qsize()>1:try:logger.debug("createconsumerproct.qsize:%s"%self.proct.qsize())consumer=Consumer(self.proct)consumer.start()exceptException,errmsg:logger.error("createconsumerfailed:%s"%errmsg)returnfilenameclassFactory(object):def__init__(self,proct):self.proct=proctself.manager=pyinotify.WatchManager()self.mask=pyinotify.IN_CREATE|pyinotify.IN_DELETE|pyinotify.IN_MODIFYdefwork(self):try:try:notifier=pyinotify.ThreadedNotifier(self.manager,Packer(self.proct))notifier.start()self.manager.add_watch("../pcap",self.mask,rec=True)notifier.join()exceptException,errmsg:logger.error("createnotifierfailed:%s"%errmsg)exceptKeyboardInterrupt,errmsg:logger.error("factoryhasbeenterminated:%s"%errmsg)在獲得要分析的pcap文件數據之後，就要對其分析了，只要你足夠了解pcap文件格式就可以了，對於我們來講只需要獲得TCP數據段的數據即可，如下：classWriter(threading.Thread):def__init__(self,proct,stack):threading.Thread.__init__(self)self.proct=proctself.stack=stackself.pcap_pkthdr={}defrun(self):whileTrue:filename=self.proct.get()try:f=open(filename,"rb")readlines=f.read()f.close()offset=24whilelen(readlines)>offset:self.pcap_pkthdr["len"]=readlines[offset+12:offset+16]try:length=struct.unpack("I",self.pcap_pkthdr["len"])[0]self.stack.put(readlines[offset+16:offset+16+length])offset+=length+16exceptException,errmsg:logger.error("unpackpcap_pkthdrfailed:%s"%errmsg)exceptIOError,errmsg:logger.error("openfilefailed:%s"%errmsg)在獲得TCP數據段的數據包之後，問題就簡單多了，根據大家的具體需求就可以進行相應的分析了，我這里是想分析其HTTP協議數據，同樣也藉助了dpkt軟體包進行分析，如下：defworker(memcache,packet,local_address,remote_address):try:p=dpkt.ethernet.Ethernet(packet)ifp.data.__class__.__name__=="IP":srcip="%d.%d.%d.%d"%tuple(map(ord,list(p.data.src)))dstip="%d.%d.%d.%d"%tuple(map(ord,list(p.data.dst)))ifp.data.data.__class__.__name__=="TCP":tcpacket=p.data.dataiftcpacket.dport==80anddstip==local_address:srcport=tcpacket.sportkey=srcip+":"+str(srcport)iftcpacket.data:ifnotmemcache.has_key(key):memcache[key]={}ifnotmemcache[key].has_key("response"):memcache[key]["response"]=Noneifmemcache[key].has_key("data"):memcache[key]["data"]+=tcpacket.dataelse:memcache[key]["data"]=tcpacket.dataelse:ifmemcache.has_key(key):memcache[key]["response"]=dpkt.http.Request(memcache[key]["data"])try:stackless.tasklet(connection)(memcache[key]["response"],local_address,remote_address)stackless.run()exceptException,errmsg:logger.error("connectremoteremote_addressfailed:%s",errmsg)logger.debug("oldheaders(nonecontent-length):%s",memcache[key]["response"])memcache.pop(key)exceptException,errmsg:logger.error("dpkt.ethernet.Ethernetfailedinworker:%s",errmsg)如果大家只是想單純的獲取IP地址、埠、流量信息，那麼問題就更簡單了，這里只是拋磚引玉。另外再提供一段代碼供參考:importpcap,dpkt,structimportbinasciidefmain():a=pcap.pcap()a.setfilter('udpportrange4000-4050')try:fori,pdataina:p=dpkt.ethernet.Ethernet(pdata)src='%d.%d.%d.%d'%tuple(map(ord,list(p.data.src)))dst='%d.%d.%d.%d'%tuple(map(ord,list(p.data.dst)))sport=p.data.data.sportdport=p.data.data.dport =int(binascii.hexlify(p.data.data.data[7:11]),16)print' :%d,From:%s:%d,To:%s:%d'%( ,src,sport,dst,dport)exceptException,e:print'%s'%en=raw_input()if__name__=='__main__':main()

G. 求助：python樹莓派多線程編程

老實說拆談亮，還沒有開始arino編程。 不過據我了解的情況，它是用C語言的。根本不著python。侍慧 不過在樹莓派里有一個arino的開發環境。

至於多線旅寬程，這個東西是用中斷來實現的。 各種中斷，比如如果利用好時間中斷，可以編寫出類似python中stackless效果的程序結構。

H. 為什麼PyPy是Python的未來

PyPy為優化和進一步的語言開發提供了更好的架構。對於大部分Python已有的問題，PyPy已經提供了解決方案：

先進的runtime和設計，在此文中作了介紹： The Architecture of Open Source Applications.
速度 - PyPy內置的JIT很棒，有時（其實很少）甚至可以與C相提並論。
GIL問題 - PyPy引入了一個很棒的STM實現，在 Armins Rigo的 文章中對此作了介紹。
粘合代碼 - 使用cffi可以簡單的處理C庫，甚至比CPython的ctypes還要快！
非同步編程。這方面，PyPy內置的 greenlet 比CPython的C擴展更適合一些。實際上，非堆棧式的概念（也即greenlet）在PyPy中還在繼續發展（參看https：//ep2012。europython。eu/conference/talks/the-story-of-stackless-python）
沙盒技術
應用在web和移動中。這里有Dusty的一些文章：Pushing Python Past the Present

PyPy已經支持多平台 (x86, 64_x86, ARM)

PyPy同時還包含了一個優秀的現代的架構，在 Jim Huang 的演講 中做了介紹，演講的要點是：

解釋性語言的框架
用於研究和產品的組件組合悉逗扒 (不同的數據模型，垃圾回收 - 這些可以在具體的應用指旅場景進行改變)
構建在基於組件鏈的功能架構之上(翻譯工具鏈)。每一個步驟都會延續/轉換睜昌程序模型、引入特徵、各種後端（JVM, JavaScript, LLVM, GCC IR等等)。來看一下翻譯鏈的例子：python 代碼 -> 位元組碼 -> 函數對象 -> 類型推斷 -> 垃圾收集器 -> JIT
包含大量在架構的不同層次開發的現代的優化技術 (這個任務可以簡化)

相信讓所有軟體支持PyPy需要付出艱巨的努力 - 需要在現有的庫上做很多工作。不過使用新的工具，編寫支持PyPy和CPython的軟體會比採用C擴展的方式更簡單一些（在我們能做什麼一節有介紹）。

I. 如何在windows下安裝pygtk

1.安裝環境
windows xp

2.安裝包版本和下載地址
python-2.5.2.msi 或 python-2.5.2-stackless.msi
http://www.stackless.com/binaries/python-2.5.2-stackless.msi
或
http://www.python.org/ftp/python/2.5.2/python-2.5.2.msi
gtk2-runtime-2.12.1-2007-10-28-ash.exe
http://downloads.sourceforge.net/gtk-win/gtk2-runtime-2.12.1-2007-10-28-ash.exe?modtime=1197422568&big_mirror=0
pygtk-2.12.1-1.win32-py2.5.exe
http://ftp.gnome.org/pub/GNOME/binaries/win32/pygtk/2.12/pygtk-2.12.1-1.win32-py2.5.exe
注意：如果你下載的型扒版本是pygtk-2.12.1-2.win32-py2.5.exe，則import gtk時會報錯。
pygobject-2.12.1-1.win32-py2.5.exe
http://ftp.gnome.org/pub/GNOME/binaries/win32/pygobject/2.12/pygobject-2.12.1-1.win32-py2.5.exe
pycairo-1.4.12-1.win32-py2.5.exe
http://ftp.acc.umu.se/pub/GNOME/binaries/win32/pycairo/1.4/pycairo-1.4.12-1.win32-py2.5.exe

3.安裝友含python
4.安裝好租笑gtk+ runtime
5.安裝pygtk
6.安裝pyobject
7.安裝pycario