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