libcurl for Python

* libcurl is a free and easy-to-use client-side URL transfer library, supporting FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE and LDAP. libcurl supports HTTPS certificates, HTTP POST, HTTP PUT, FTP uploading, kerberos, HTTP form based upload, proxies, cookies, user+password authentication, file transfer resume, http proxy tunneling and more!

* libcurl is highly portable, it builds and works identically on numerous platforms, including Solaris, NetBSD, FreeBSD, OpenBSD, Darwin, HPUX, IRIX, AIX, Tru64, Linux, Windows, Amiga, OS/2, BeOs, Mac OS X, Ultrix, QNX, OpenVMS, RISC OS, Novell NetWare, DOS and more...

* libcurl is free, thread-safe, IPv6 compatible, feature rich, well supported and fast.
http://pycurl.sourceforge.net/

urlgrabber is a pure python package that drastically simplifies the fetching of files. It is designed to be used in programs that need common (but not necessarily simple) url-fetching features. It is extremely simple to drop into an existing program and provides a clean interface to protocol-independant file-access. Best of all, urlgrabber takes care of all those pesky file-fetching details, and lets you focus on whatever it is that your program is written to do!

urlgrabber came into existence as the part of yum that downloads rpms and header files, but it quickly became clear that this is a general problem that many applications must deal with.

urlgrabber

Python文摘，IP地址和数值转换

>>> socket.inet_ntoa(struct.pack('I',socket.htonl(16909060)))
'1.2.3.4'
>>> socket.ntohl(struct.unpack("I",socket.inet_aton('1.2.3.4'))[0])
16909060
再加几个：
>>> struct.unpack("I",socket.inet_aton('1.2.3.4')) (67305985L,)
>>> socket.ntohl(67305985)16909060>>> socket.htonl(16909060)67305985>>> struct.unpack('i',socket.inet_aton('1.2.3.4'))(67305985,)
>>> struct.pack('i',16909060)
'\x04\x03\x02\x01'
>>> struct.pack('i',67305985)
'\x01\x02\x03\x04'
>>> socket.inet_ntoa(struct.pack('I',socket.ntohl(16909060)))
'1.2.3.4'
>>> socket.htonl(struct.unpack("I",socket.inet_aton('1.2.3.4'))[0])
16909060
这样很好玩吧~
（1）. inet_aton 将ip地址的4段地址分别进行2进制转化，输出用16进制表示：
1.2.3.4 ——inet_aton——> 0000 0001,0000 0010,0000 0011,0000 0100
（2）.unpack的处理是按16进制（4bit）将2进制字符，从后向前读入的，低位入，处理成：
00000100 00000011 00000010 00000001
也就是 4 3 2 1
pack也一样，从后向前读入字符，所以——
用16进制表示的1 2 3 4（16909060）打包成 4 3 2 1 的顺序；
用16进制表示的4 3 2 1（67305985）打包成 1 2 3 4 的顺序；
（3） ntohl, htonl 表示的是网络地址和主机地址之间的转换（network byte host byte）
由于unpack/pack的解/打包的颠倒顺序，必须通过htonl 或者 ntohl 进行处理。
（4） network byte, host byte
这2个名词折腾半天，host byte 由于处理器的方式不同 little-endian或者big-endian，将ip地址转换的最终输出是不一样的，参考(http://www.informit.com /articles/article.aspx?p=169505&seqNum=4 )
(http://www.netrino.com/Embedded-Systems/How-To/Big-Endian-Little-Endian)
big-endian: 最高位在左边（内存存储空间的最低位）
little-endian: 最高位在右边（内存存储空间的最低位）
i386-unknown-freebsd4.8: little-endian
powerpc-apple-darwin6.6: big-endian
sparc64-unknown-freebsd5.1: big-endian
powerpc-ibm-aix5.1.0.0: big-endian
hppa1.1-hp-hpux11.11: big-endian
i586-pc-linux-gnu: little-endian
sparc-sun-solaris2.9: big-endian
而为了统一这种传输标准（打个补丁，再创造一个名词函数），又有network byte，这个其实就是标准的big-endian；
由于x86本身的处理属于little-endian，所以上述应该按照标准的network byte 进行处理，这样可避免cpu造成的不同：
socket.htonl(struct.unpack("I",socket.inet_aton('1.2.3.4'))[0])
socket.inet_ntoa(struct.pack('I',socket.htonl(16909060)))
###############################################################################
（1个64位amd+32位windows， 1个32位intel+linux， 出来的数值是一样的：
>>> socket.ntohl(struct.unpack("I",socket.inet_aton('220.194.61.32'))[0])
-591250144
>>> socket.inet_ntoa(struct.pack('I',socket.htonl(-591250144)))
'220.194.61.32'
但是64位amd+64位linux，是这样：
>>> socket.ntohl(struct.unpack("I",socket.inet_aton('220.194.61.32'))[0])
3703717152
>>> socket.inet_ntoa(struct.pack('I',socket.htonl(-591250144)))
'220.194.61.32'
>>> socket.inet_ntoa(struct.pack('I',socket.htonl(3703717152)))
'220.194.61.32'
unpack/pack和cpu，os无关；
socket.ntohl/htonl的输出结果int型 对32 os，处理成signed 类型，首位1被处理成负数；
对 64位 os，则是unsigned类型；
（晕了半天，那个值才明白是位数，和cpu不相干）
###############################################################################
（5）mysql里面的函数是inet_aton, inet_ntoa 和python的socket不同，直接实现ip string到network byte的转换，python里面只能实现ip地址到network byte的2进制转换：
mysql> select inet_aton('1.2.3.4');
-> 16909060
mysql> select inet_ntoa(16909060);
-> 1.2.3.4

http://bbs.chinaunix.net/thread-1163546-1-7.html

struct.unpack("!I", ...) 可以产生无符号数

一点有用的东西

Jabber server written in Python
http://code.google.com/p/pretzel/

Twisted 太重要了。写的非常好。
http://twistedmatrix.com/

Jabbers and others important

Jabber servers:

OpenFire
http://www.igniterealtime.org/projects/openfire/index.jsp

JabberIn
http://www.jabbin.com/index.html

OpenZoep: An Open Source VoIP Engine

http://www.voipster.com/

VOIP Jingle library
http://www.xmpp.org/extensions/xep-0166.html

XPCOM
http://www.mozilla.org/projects/xpcom/

http://xmpppy.sourceforge.net/

用Python操作MS Access数据库

首先,你应安装了python和Python for Windows extensions。
1、建立数据库连接
import win32com.client
conn = win32com.client.Dispatch(r'ADODB.Connection')
DSN = 'PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=C:/MyDB.mdb;'
conn.Open(DSN)
2、打开一个记录集
rs = win32com.client.Dispatch(r'ADODB.Recordset')
rs_name = 'MyRecordset'#表名
rs.Open('[' + rs_name + ']', conn, 1, 3)
3、对记录集操作
rs.AddNew()
rs.Fields.Item(1).Value = 'data'
rs.Update()
4、用SQL来插入或更新数据
conn = win32com.client.Dispatch(r'ADODB.Connection')
DSN = 'PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=C:/MyDB.mdb;'
sql_statement = "Insert INTO [Table_Name] ([Field_1], [Field_2]) VALUES ('data1', 'data2')"
conn.Open(DSN)
conn.Execute(sql_statement)
conn.Close()
5、遍历记录
rs.MoveFirst()
count = 0
while 1:
if rs.EOF:
break
else:
count = count + 1
rs.MoveNext()

注意：如果一个记录是空的，那么将指针移动到第一个记录将导致一个错误，因为此时recordcount是无效的。解决的方法是：打开一个记录集之前，先将Cursorlocation设置为3，然后再打开记录集，此时recordcount将是有效的。
例如：
rs.Cursorlocation = 3 # don't use parenthesis here
rs.Open('Select * FROM [Table_Name]', conn) # be sure conn is open
rs.RecordCount # no parenthesis here either

http://www.pythontik.com/blog/article.asp?id=23

关于urllib2中的Keep-Alive

http://www.nabble.com/-CPyUG:41451--%E5%85%B3%E4%BA%8Eurllib2%E4%B8%AD%E7%9A%84Keep-Alive%E5%8F%8A%E8%AF%B7%E6%95%99%E5%A5%BD%E7%94%A8%E7%9A%84http%E5%AE%A2%E6%88%B7%E7%AB%AF%E5%8C%85-td15706978.html

TGFusionCharts

TGFusionCharts is a TurboGears widget which lets you easily add FusionCharts Flash Charts to your application. TGFusionCharts is licensed under MIT License; FusionCharts has a commercial license, but offers a free trial.

http://www.thesamet.com/TGFusionCharts/
http://www.fusioncharts.com/Demos/SalesDashboard/Contents/Visits.html

py2exe使用方法

一、简介

py2exe是一个将python脚本转换成windows上的可独立执行的可执行程序(*.exe)的工具，这样，你就可以不用装python而在windows系统上运行这个可执行程序。

py2exe已经被用于创建wxPython,Tkinter,Pmw,PyGTK,pygame,win32com client和server,和其它的独立程序。py2exe是发布在开源许可证下的。

二、安装py2exe

从 http://prdownloads.sourceforge.net/py2exe下载并运行与你所安装的Python对应的py2exe版本的 installer，这将安装py2exe和相应的例子；这些例子被安装在lib\site-packages\py2exe\samples目录下。

三、py2exe的用法

如果你有一个名为helloworld.py的python脚本，你想把它转换为运行在 windows上的可执行程序，并运行在没有安装python的windows系统上，那么首先你应写一个用于发布程序的设置脚本例如 mysetup.py，在其中的setup函数前插入语句import py2exe 。
mysetup.py示例如下:
# mysetup.py
from distutils.core import setup
import py2exe

setup(console=["helloworld.py"])

http://www.diybl.com/course/1_web/webjs/2007111/81629.html

孟岩《来自巴西的Lua语言新星让我脸红》及网友评论

一种自由软件的脚本语言 Lua ，由于在游戏界日益成为主流脚本语言（得到著名的卢卡斯艺术公司两款游戏采用，并在GameDev.net的调查中高居脚本语言榜首），最近引起了业界的广泛关注。
Lua （葡萄牙语，义为月亮）是一种轻量级的强大的扩展语言，用纯ANSI C编写，最初版本只有6000行代码，却实现了垃圾收集、反射、面向对象等机制。Lua 是由巴西里约热内卢天主教大学计算机系的Roberto Ierusalimschy 等人于1993年开发的。
最近，Roberto Ierusalimschy 撰写的《Programming in Lua》一书也已经出版
---tangl_99

Python是荷兰人写的，Ruby是日本人写的，Lua是巴西人写的，我这个中国人只能在这里脸红。
---孟岩

不必人人制轮胎，难道你不想躺在轮胎做的吊床上休息？
---牡蛎

只选对的，不选贵的。
---路人甲

转载自tangl_99的blog和孟岩的blog

Python是荷兰人写的，Ruby是日本人写的，Lua是巴西人写的，我这个中国人只能在这里脸红。
Lua是所有动态语言中间平均效率最高的一个。它最初是以Library的形式存在，纯粹只是用作C/C++的一个扩展。现在不仅发展出了解释器，还发展 出了编译器。游戏开发里Lua是使用最广泛的脚本语言。当世界上第一本Lua图书上市销售的时候，一位读者评价道："Lua is a real gem."
（牡蛎到没有听过Lua、Python或者Ruby的编译器——.NET的冒牌货除外）

Lua很棒，Lua是巴西人发明的，这些都令我不爽，但是还不至于脸红，最多眼红。
让我脸红的是Lua的源代码，百分之一百的ANSI C，一点都不掺杂。在任何支持ANSI C编译器的平台上都可以轻松编译通过。我试过，真是一点废话都没有。
我1996年就学会了C，1997年就跑去研究Win32 API，后来是C++，STL，Java... 直到2002年看到C Interfaces and Implementations，才知道仅仅用ANSI C就可以实现一个强大的优美的library，直到2004年看到Lua的源代码才知道仅仅用ANSI C就可以实现一个非常快的虚拟机、非常棒的解释器/编译器和非常漂亮的语言实现。
这8年我都干什么去了？
---孟岩

http://www.chinaitpower.com/2005September/2005-09-13/204728.html

使用xrc的一点心得

这篇文章老早就想引过来了。写得不错。

首先向大家说明，我学python才一个多月，写了一个程序主 要是为了练习python和wxPython，如果有什么不对的地方还请大家指出。我也没怎么查是否有人写过类似的说明，就当给大家一个参考。我原来写过 c++/gtk/gtkmm的程序，觉得wxPython的图形程序写起来还是很容易的，不过偶得一个同事说我的python程序写 的比较像C++程序，现在正在深入的研究python中。

我要讲的是如何在程序中使用wxPython库，其中包括各种widget的获得，动态的切换widget，也有很多资料的，我就把我使用过程中觉得需要注意的总结一下，其中也说明了整个gui的构建框架

我把程序分成了三个文件
一个 main.py
一个 ui.py
一个 common.py

Main.py 是这样写的

import ui

if __name__ == '__main__':
application = ui.Application(0)
application.MainLoop()
else:
print "Can't import Buildipsl main module,it shoud be run alone!"

也就是在主程序中运行起来图形界面，进入事件循环，比较简单。

Ui.py程序比较长，大概有1000行，就不贴在这了，我主要说明的就是这个部分。

Common.py是一些常用的公共函数，定义的一些存放数据的底层的类，ui界面的数据交互最终都是通过和底层类对象数据交换来实现的，这样层次比较分明，也容易独立修改。

下面看一下ui.py文件中的Application类，也就是main.py中调用的那个类

class Application(wx.App):
def OnInit(self):
self.conf = common.HandleConfig('fic.conf')
self.connection_pool = common.ConnectionPool()
self.resource = xrc.XmlResource('../resource/IPSLBuild.xrc')
self.frame = MainFrame(None, self.resource,self.conf,self.connection_pool)
self.frame.Show()
return True

这个类在构造函数中实列化了一个’配置文件’类对象，一个’连接缓冲池’类对象，并且初始化了一个xrc资源文件类对象，传入MainFrame这个主窗体类。


MainFrame类 ，主窗体的实现类:
先看一下前几行
class MainFrame(wx.Frame):
def __init__(self, parent, resource,setting,pool):
self.res = resource
self.setting = setting
self.connection_pool=pool
self.PostCreate(self.res.LoadFrame(parent, 'MainWindow'))

self.PostCreate(self.res.LoadFrame(parent, 'MainWindow'))
这一行利用xrc资源对象，把在xml文件中定义的窗体load进来，设置本窗体类。

主窗体load进来了，接着就load窗体上的widget
一般的widget都可以使用像下面这样的函数：
self.text_ctrl_build_dir = xrc.XRCCTRL(self,'text_ctrl_build_dir')
也就是使用xrc,XRCCTRL,第一个参数是parent,这里是self，也就是我们load进来的主窗体，后面加的是包含在主窗体里的 widget的XML id 值，这样widget就进来了，由前面的self.text_ctrl_build_dir来引用着。使用和用代码构建出来的widget没什么区别。
但是，这里有例外，xrc.XRCCTRL只能使用在由wxWindow继承出来的widget上，如果widget不是由wxWindow 继承而来的，就获得不到对象引用，比如menu 和 toolbar。Menuitem和toolbar button要使用下面的方式：

Menubar:
self.menubar = self.res.LoadMenuBar('MainWindow_MenuBar')
这里的menubar在XML文件中是个顶层的widget，也就是说这个menubar不是包含在主窗体里的，结构上是和主窗体平级的

一个小提示：
XML文件中顶层的widget都是用LoadXXXX 来获得,非顶层的才使用XRCCTRL,并且XRCCTRL中第一个参数要是以LoadXXXX获得的widget做为直接或间接的父widget.
比如一个panel,如果在XML文件的最顶层,就要使用LoadPanel,如果在一个Frame中,那就要使用XRCCTRL(Frame的引用,’panel xml id’)

Menubar获得了,就把menubar设置在主窗体上
self.SetMenuBar(self.menubar)

获得子菜单用
self.menu_add = self.menubar.FindItemById(xrc.XRCID('menu_item_node_add'))

toolbar可以在主窗体上获得
self.toolbar = xrc.XRCCTRL(self,'MainWdinow_ToolBar')

在使用上,我获得toolbar button主要是要改变其可用和不可用的状态:
self.toolbar.EnableTool(xrc.XRCID("tool_button_node_add"),True)
想要toolbar button不能使用就用False
回调函数我下面再说.

到现在获得widget大家应该都没什么疑惑了吧,再说回调函数
回调函数一般是这样
self.config_panel.Bind(wx.EVT_BUTTON,self.OnConfSearch,id=xrc.XRCID('button_search_node_conf'))

self.Bind(wx.EVT_MENU, self.OnAdd,id=xrc.XRCID('menu_item_node_add'))
self.Bind(wx.EVT_TOOL, self.OnAdd,id=xrc.XRCID('tool_button_node_add'))

第一个是正常的Buttton
第二个是menuitem
第三个是toolbar button
其实都是一样的
父widget.Bind(事件类型,函数名,xml id)
再次说一下上面的menuitem 和toolbar button,其实如果不要像我这样要设置他们的可用和不可用的状态,不用获得他们的对象引用,可以直接绑定的,因为他们用的是xml id来查找的,没有bind在他们对象的引用上.

下面说一个我使用中的需求:
我窗体左边有一个treeview,需要在点左边不同的treeview item的时候,右边可以根据不同的情况变化.
我不想给右边通过代码来实现,因为可能有如下问题
1. 右边可能是个比较复杂的panel,代码量比较大,而且手写代码不容易后来的修改
2. 每次切换都要destory和Create一堆东西,资源的占用比较大
我喜欢完全的界面代码分离,好处多多,所以还是想用xrc的方式来做.
下面是实现步骤

右面我们要操作的实际上是一个splitter window的panel,叫splitter_right_panel

定义一个BoxSizer,用来向里面添东西
self.splitter_right_box_for_guest_panel=wx.BoxSizer(wx.VERTICAL)

初始化的时候先放上一个空panel
self.splitter_right_box_for_guest_panel.Add(wx.Panel(self),1, wx.EXPAND, 0)

设置布局
self.splitter_right_panel.SetAutoLayout(True)

设置容器
self.splitter_right_panel.SetSizer(self.splitter_right_box_for_guest_panel)

调整widget间的布局关系
self.splitter_right_box_for_guest_panel.Fit(self.splitter_right_panel)

把两个要加的panel都变成右边splitter_right_panel的子widget
self.config_panel.Reparent(self.splitter_right_panel)
self.connection_panel.Reparent(self.splitter_right_panel
这一步比较重要,一定要让panel的父widget是他的直接panel,如果是主窗体,显示有问题.
还有这两个panel是xml文件中顶层的panel,要使用LoadPanel加载进来.

初始化基本上就完成了,在切换中的代码是写在treeview中的select changed回调函数中.

self.main_frame.splitter_right_box_for_guest_panel.Detach(0)
self.main_frame.config_panel.Hide()
self.main_frame.connection_panel.Hide()

if ……:
self.main_frame.config_panel.Show()
self.main_frame.splitter_right_box_for_guest_panel.Add(self.main_frame.config_panel,1,wx.EXPAND,0)
else:
self.main_frame.connection_panel.Show()
self.main_frame.splitter_right_box_for_guest_panel.Add(self.main_frame.connection_panel,1,wx.EXPAND,0)


1. 任何时候都先把BoxSizer中的panel分离
2. 两个面板都hide
3. 根据判断加载不同的panel,show出来
这里用到的是Detach(),不要用Destory,panel对象是在xrc 资源文件中的,destory有问题,而且我们就是不想让它被destory,这样最开始得到的panel内部的widget的对象的引用一直都是可用的.

基本的原理我就说完了,写了两个common文件的类在这,是实现ssh连接的,我测试是可用的,还没写好, python异常我还没看,不好意思
使用的是paramiko模块,不过我用起来发现有问题,put和get函数有问题,没办法我自己写的put和get.
远程执行命令的时候不等执行完就退出了,命令在后台执行,这个不是我想要的,不过肯定有方法,只是我还不知道.我还没写完,让大家见笑了,呵呵

class Connection:
def __init__(self,ip,account,pwd):
self.trans = paramiko.Transport((ip, 22))
self.trans.connect(username=account, password=pwd)
def put(self,localfile,remotefile):
sftp=paramiko.SFTPClient.from_transport(self.trans)
data = open(localfile, 'r').read()
print 'remotefile is %s' % remotefile
sftp.open(remotefile, 'w').write(data)
def get(self,remotefile,localfile):
sftp=paramiko.SFTPClient.from_transport(self.trans)
data = sftp.open(remotefile, 'r').read()
open(localfile, 'w').write(data)
def execmd(self,cmd):
chan = self.trans.open_session()
chan.exec_command(cmd)
def active(self):
return self.trans.is_active()
def __del__(self):
self.trans.close()

class ConnectionPool:
def __init__(self):
self.pool={}
self.filelist=['bg','pnp','sub','fp','ep']
self.genscript='fic.pexpect'
def add_connection(self,name,ip,account,pwd):
if self.pool.has_key(name):
return False
try:
con=Connection(ip,account,pwd)
except Exception:
return False
self.pool[name]=con
return True
def del_connection(self,name):
if not self.pool.has_key(name):
return False
else:
del self.pool[name]
def connected(self,name):
if self.pool.has_key(name):
return True
else:
return False
def gen_config(self,name,path):
if not self.pool.has_key(name):
return False
try:
self.pool[name].execmd(r'rm -rf /tmp/%s' % self.genscript)
self.pool[name].put(get_path(self.genscript),'/tmp/%s' % self.genscript)
self.pool[name].execmd('python /tmp/%s' % self.genscript)
self.pool[name].execmd(r'rm -rf /tmp/%s' % self.genscript)
time.sleep(600)
for i in self.filelist:
print os.path.join(path,i)
self.pool[name].get("/tmp/fic/%s" % i,os.path.join(path,i))
except:
return False
return True

http://bbs.chinaunix.net/viewthread.php?tid=858243

中文关键字提取

最近整的是中文分词与关键字提取，用python写的原型，算是复杂度比较可观的应用了；
分词的资料不太好找，只有KaiFu Lee在MSRA带着Guo姓小弟做的一些列paper和中科院I3S组的分词程序。
关键字提取是无先验信息的，篇幅也很短效，但是功能还是满意了。基本流程是聚类后，算条件概率，思想来自某大学的Paper。
起初的实现的模型，大概在1000汉字每秒的处理能力；
折腾了一天，提升到12000汉子每秒。
http://entelechie.ycool.com/post.2763166.html

基于Sphinx+MySQL的千万级数据全文检索（搜索引擎）架构设计

http://blog.s135.com/read.php/360.htm

[文章作者：张宴 本文版本：v1.0 最后修改：2008.07.27 转载请注明原文链接：http://blog.s135.com/read.php/360.htm]

　　前言：本文阐述的是一款经过生产环境检验的千万级数据全文检索（搜索引擎）架构。本文只列出前几章的内容节选，不提供全文内容。

　 　在DELL PowerEdge 6850服务器（四颗64 位Inter Xeon MP 7110N处理器 / 8GB内存）、RedHat AS4 Linux操作系统、MySQL 5.1.26、MyISAM存储引擎、key_buffer=1024M环境下实测，单表1000万条记录的数据量（这张MySQL表拥有int、 datetime、varchar、text等类型的10多个字段，只有主键，无其它索引），用主键（PRIMARY KEY）作为WHERE条件进行SQL查询，速度非常之快，只耗费0.01秒。

　　出自俄罗斯的开源全文搜索引擎软件Sphinx， 单一索引最大可包含1亿条记录，在1千万条记录情况下的查询速度为0.x秒（毫秒级）。Sphinx创建索引的速度为：创建100万条记录的索引只需 3～4分钟，创建1000万条记录的索引可以在50分钟内完成，而只包含最新10万条记录的增量索引，重建一次只需几十秒。

　　基于以上 几点，我设计出了这套搜索引擎架构。在生产环境运行了一周，效果非常不错。有时间我会专为配合Sphinx搜索引擎，开发一个逻辑简单、速度快、占用内存 低、非表锁的MySQL存储引擎插件，用来代替MyISAM引擎，以解决MyISAM存储引擎在频繁更新操作时的锁表延迟问题。另外，分布式搜索技术上已 无任何问题。

全部内容请点击上面链接

有用的Python中文分词链接

python中文分词模块

http://www.zeuux.org/pipermail/zeuux-python/2007-June/039597.html

分词后续, SCWS(简体中文分词)第4版出来了 :-)

http://www.chmhome.com/knowledge/php/20070624/50559.html

中文分词
http://nzinfo.spaces.live.com/?_c11_BlogPart_BlogPart=blogview&_c=BlogPart&partqs=cat%3D%25e4%25b8%25ad%25e6%2596%2587%25e5%2588%2586%25e8%25af%258d

中文分词
http://www.162cm.com/archives/tag/%E4%B8%AD%E6%96%87%E5%88%86%E8%AF%8D

中文分词Python相关

中文搜索／分词

• 庖丁分词

• IKAnalyzer和庖丁分词性能对比

• Lucene中文分词器组件

• IKAnalyzerNet发布

http://wiki.woodpecker.org.cn/moin/PyInChinese

Google App Engine 提供5G Python空间

Google App Engine是Google推出的免费虚拟主机空间，其实这比一般虚拟主机强悍的多，你可以利用Google App Engine工具来开发网站或制作网络应用程序，Google会在自己的庞大服务器集群上为你提供空间、带宽、资源等。目前Google App Engine为每个用户提供10个Application（简称App），每个App有500M免费空间，每个App限制1000个文件，单个文件1M以 内，每天流量20G。每个App提供免费二级域名1个，同时也可绑米。目前还仅支持Python一种语言脚本，不支持PHP、Perl、ASP等。

注意：这是Google面向程序开发人员提供的一项免费服务，如果你对Python不了解也不感兴趣建议不要申请，虽然很强悍但使用起来比任何一个免费空间都麻烦。

网址：http://appengine.google.com

如果你使用Google Apps，可以用“http://appengine.google.com/a/你的域名/”这个地址来申请，如果你要绑定域名，仅能绑定申请了 Google Apps服务的域名。另外，申请的时候需要填写手机号码，会给你发送确认码来确认申请，目前Google在中国仅支持中国联通，所以要用联通手机申请才能 收到确认码，如果你用的不是联通手机，那就无缘Google App Engine了，且一个手机只能申请一个帐户。

官方入门指南：http://code.google.com/appengine/docs/gettingstarted

入门指南中文翻译版：http://hi.baidu.com/…/772eb07e43ff613d0cd7daa6.html

目前官方仅有英文版入门指南，所以在网上找了个网友翻译的中文版给大家做参考，有兴趣仔细看看吧。

配额限制：http://code.google.com/appengine/articles/quotas.html

Google App Engine详细配额限制，很全面。你的程序上传运行后，在Google App Engine的管理面板中可以看到配额使用情况。

Python运行限制：http://code.google.com/appengine/docs/python

Google App Engine中的Python是运行在一个受限的环境中，例如：对操作系统的底层调用、网络操作以及一些文件系统操作都是不允许的，尝试这些操作时会引起错误。

演示：http://free8.appspot.com

费了好大劲才弄好了一个页面，对于Python不太了解的新手来说，建议不要申请使用。
另外给大家两个用Google App Engine做的在线代理网站演示：

http://w3w.appspot.com

http://go2.appspot.com

原文：http://www.chinaz.com/Webbiz/Free/0PS4Z02008.html

XRC方式载入的wxPython对象访问方式

res = xrc.XmlResource(’resource.xrc’)
res.LoadPanel(self, ‘MyPanel’)

self.Bind(wx.EVT_BUTTON, self.OnClose, id=xrc.XRCID(’CloseButton’))
self.Center()

wxPython之XRC加载流水账.2

用下面的代码，执行结果是正确的。不知道为什么，如果有StatusBar，总会少一点，resize之后正常。

#-*- coding: utf-8 -*-

import wx
import wx.xrc as xrc

class MyApp(wx.App):
def OnInit(self):
self.res = xrc.XmlResource(r'./cr01.xrc')
self.frame_1 = self.res.LoadFrame(None, 'MyFrame2')
self.frame_1.Show(True)
return 1

if '__main__' == __name__:
app = MyApp()
app.MainLoop()

重要的参考文件 ：
wxPython中XRC文件i18n示例

wxPython之XRC加载流水账

按图索骥一番，用以下代码测试一下：

#!/usr/bin/python
#-*- coding: utf-8 -*-

import wx
import wx.xrc as xrc

class XML(wx.Frame):
def __init__(self, parent, id, title):
wx.Frame.__init__(self, parent, id, title)

res = xrc.XmlResource('cr01.xrc')
res.LoadFrame(self, 'MyFrame2')

self.Center()
self.Show(True)

def OnClose(self, event):
self.Close()

app = wx.App()
XML(None, -1, 'xml resource test')
app.MainLoop()

cr01.xrc里定义了数个组件，发现载入进来的只是一个空框架。

参考文件 ：http://privacybrowse.info/index.php?hl=f5&q=uggc%3A%2F%2Fzejyjna.jbeqcerff.pbz%2F2008%2F05%2F03%2Fjkclguba%25RS%25OP%259Nkep%2F

Python in Action中文翻译

项目地址：
http://www.mangbar.com/task/doclist/5d023b211427315f01142a6590000324

竽充数：Python抓网页内容的两个sample程序

Python是Google公司最重要的三大开发语言之一(C++, Java, Python)

用Python语言写搜索引擎蜘蛛的脚本非常简单、轻松。给大家分享两种抓网页内容的方法

一、用urllib2/sgmllib包，将目标网页的所有URL列出。

import urllib2

from sgmllib import SGMLParser

class URLLister(SGMLParser):
def reset(self):
SGMLParser.reset(self)
self.urls = []

def start_a(self, attrs):
href = [v for k, v in attrs if k=='href']
if href:
self.urls.extend(href)

f = urllib2.urlopen("http://www.donews.com")

if f.code == 200:
parser = URLLister()
parser.feed(f.read())
f.close()
for url in parser.urls: print url

二、用python调用IE抓取目标网页（Require win32com, pythoncom）的所有图像的url和大小

import win32com.client, pythoncom
import time

ie = win32com.client.DispatchEx('InternetExplorer.Application.1')
ie.Visible = 1
ie.Navigate("http://news.sina.com.cn")
while ie.Busy:
time.sleep(0.05)

doc = ie.Document
for i in doc.images:
print i.src, i.width, i.height

这种方法可以利用IE本身的Javascript. DHTML的支持，来做自动提交Form,和处理Javascript。
有关样例可以参考http://win32com.de

http://blog.donews.com/dengyu/archive/2005/11/09/620119.aspx

用python解析html

http://rurutia.is-programmer.com/show/100.html

[Python]用 Python 实现的线程池

为了提高程序的效率，经常要用到多线程，尤其是IO等需要等待外部响应的部分。线程的创建、销毁和调度本身是有代价的，如果一个线程的任务相对简 单，那这些时间和空间开销就不容忽视了，此时用线程池就是更好的选择，即创建一些线程然后反复利用它们，而不是在完成单个任务后就结束。

下面是用Python实现的通用的线程池代码：

undefinedview plaincopy to clipboardprint?

1. import Queue, threading, sys
2. from threading import Thread
3. import time,urllib
5. # working thread
6. class Worker(Thread):
7. worker_count = 0
8. def __init__( self, workQueue, resultQueue, timeout = 0, **kwds):
9. Thread.__init__( self, **kwds )
10. self.id = Worker.worker_count
11. Worker.worker_count += 1
12. self.setDaemon( True )
13. self.workQueue = workQueue
14. self.resultQueue = resultQueue
15. self.timeout = timeout
17. def run( self ):
18. ''' the get-some-work, do-some-work main loop of worker threads '''
19. while True:
20. try:
21. callable, args, kwds = self.workQueue.get(timeout=self.timeout)
22. res = callable(*args, **kwds)
23. print "worker[%2d]: %s" % (self.id, str(res) )
24. self.resultQueue.put( res )
25. except Queue.Empty:
26. break
27. except :
28. print 'worker[%2d]' % self.id, sys.exc_info()[:2]
30. class WorkerManager:
31. def __init__( self, num_of_workers=10, timeout = 1):
32. self.workQueue = Queue.Queue()
33. self.resultQueue = Queue.Queue()
34. self.workers = []
35. self.timeout = timeout
36. self._recruitThreads( num_of_workers )
38. def _recruitThreads( self, num_of_workers ):
39. for i in range( num_of_workers ):
40. worker = Worker( self.workQueue, self.resultQueue, self.timeout )
41. self.workers.append(worker)
43. def start(self):
44. for w in self.workers:
45. w.start()
47. def wait_for_complete( self):
48. # ...then, wait for each of them to terminate:
49. while len(self.workers):
50. worker = self.workers.pop()
51. worker.join( )
52. if worker.isAlive() and not self.workQueue.empty():
53. self.workers.append( worker )
54. print "All jobs are are completed."
56. def add_job( self, callable, *args, **kwds ):
57. self.workQueue.put( (callable, args, kwds) )
59. def get_result( self, *args, **kwds ):
60. return self.resultQueue.get( *args, **kwds )

import Queue, threading, sys from threading import Thread import time,urllib # working thread class Worker(Thread): worker_count = 0 def __init__( self, workQueue, resultQueue, timeout = 0, **kwds): Thread.__init__( self, **kwds ) self.id = Worker.worker_count Worker.worker_count += 1 self.setDaemon( True ) self.workQueue = workQueue self.resultQueue = resultQueue self.timeout = timeout def run( self ): ''' the get-some-work, do-some-work main loop of worker threads ''' while True: try: callable, args, kwds = self.workQueue.get(timeout=self.timeout) res = callable(*args, **kwds) print "worker[%2d]: %s" % (self.id, str(res) ) self.resultQueue.put( res ) except Queue.Empty: break except : print 'worker[%2d]' % self.id, sys.exc_info()[:2] class WorkerManager: def __init__( self, num_of_workers=10, timeout = 1): self.workQueue = Queue.Queue() self.resultQueue = Queue.Queue() self.workers = [] self.timeout = timeout self._recruitThreads( num_of_workers ) def _recruitThreads( self, num_of_workers ): for i in range( num_of_workers ): worker = Worker( self.workQueue, self.resultQueue, self.timeout ) self.workers.append(worker) def start(self): for w in self.workers: w.start() def wait_for_complete( self): # ...then, wait for each of them to terminate: while len(self.workers): worker = self.workers.pop() worker.join( ) if worker.isAlive() and not self.workQueue.empty(): self.workers.append( worker ) print "All jobs are are completed." def add_job( self, callable, *args, **kwds ): self.workQueue.put( (callable, args, kwds) ) def get_result( self, *args, **kwds ): return self.resultQueue.get( *args, **kwds )

Worker类是一个工作线程，不断地从workQueue队列中获取需要执行的任务，执行之，并将结果写入到resultQueue中，这里的 workQueue和resultQueue都是现成安全的，其内部对各个线程的操作做了互斥。当从workQueue中获取任务超时，则线程结束。

WorkerManager负责初始化Worker线程，提供将任务加入队列和获取结果的接口，并能等待所有任务完成。

一个典型的测试例子如下，它用10个线程去下载一个固定页面的内容，实际应用时应该是执行不同的任务。

undefinedview plaincopy to clipboardprint?

1. def test_job(id, sleep = 0.001 ):
2. try:
3. urllib.urlopen('https://www.gmail.com/').read()
4. except:
5. print '[%4d]' % id, sys.exc_info()[:2]
6. return id
8. def test():
9. import socket
10. socket.setdefaulttimeout(10)
11. print 'start testing'
12. wm = WorkerManager(10)
13. for i in range(500):
14. wm.add_job( test_job, i, i*0.001 )
15. wm.start()
16. wm.wait_for_complete()
17. print 'end testing'

def test_job(id, sleep = 0.001 ): try: urllib.urlopen('https://www.gmail.com/').read() except: print '[%4d]' % id, sys.exc_info()[:2] return id def test(): import socket socket.setdefaulttimeout(10) print 'start testing' wm = WorkerManager(10) for i in range(500): wm.add_job( test_job, i, i*0.001 ) wm.start() wm.wait_for_complete() print 'end testing'

完成的程序可以在这里下载。

http://blogger.org.cn/blog/more.asp?name=lhwork&id=22262

如何使用wxPython设计gui

wxPython介绍+一个实用的例子

1. wxPython简介

wxPython是wxWidget的库的一个python的封装。提供了一些库和一些工具。

这样wxPython即有python语言的优点：
语法强悍，少写了不少代码:）

也有wxWidget图形库的优点：
直接拉控件到大概位置就行了，不需要去调整控件的对齐，也不需要关心gui界面是否支持各种分辨率的桌面。而且界面都是可以运行时切换，只要写很少的切换代码。跨平台的图形库...

后悔，我怎么以前会用vb开发gui的 -_-!。

缺点，网上资料还比较少。而且在线文档都是英文的。不过如果英文好的话，到真的无所谓，因为wxPython的安装包本身提供的工具和资料也足够多，足够好了。

2. 开发入门
我使用ultraedit作为编辑器，wxPython自带的XRCed作为编辑xrc文件（一种xml格式的资源文件，类似于VC6中的RC文件）。

文档主要参考wxPython自带的在线文档和demo代码。不过关于如何使用xrc文件设计gui，wxPython自带的资料似乎还不够详细，这也是我写本文的原因。

通常情况下google"cvs def wxpython相关的关键字"可以快速找到开源的源代码参考。

如果这些例子还不够的话，就参考我的程序吧，这是一个商用程序的原型，我相信该程序的内容已经足够丰富了，应该比网上的一些wxPython教程中的hello world程序更有借鉴意义。

3. 源代码
两个文件，main.py是主程序，main.xrc是资源文件。只要安装了了python和wxpython，然后将这两个文件放在同一个目录中，运行main.py就可以了。

http://www.builder.com.cn/2008/0527/887121.shtml

很重要，此文的实现基于.xrc文件。

wxpython:sizer学习

使用sizer后,mainFrame的大小由sizer的孩子决定

grid sizer:

最简单的一个种sizer,各个栅的大小相同,栅的最大大小取决以栅中最大孩子的尺寸(当一个sizer被创建时，它根据它的孩子的综合的最小尺寸（最小的宽度和最小的高度）隐含地创建一个最小尺寸。),如果一个栅没有孩子,不会占有效空间的.gridsizer不会限制孩子的个数的,即使在开始声明也是一样

=========================

flex grid sizer

默认情况下，当尺寸调整时，它不改变它的单元格的尺寸。

可以指定某方向上的行为(以行或列为其它单位,gridsizer是以整体为单位),每个栅的宽度是该列中宽度最大的项目的宽度，它们的高度是该行中宽度最高的项目的宽度。显式地告诉该sizer该行或列是可扩展的：

当窗体大小变化时,需要显式地告诉该sizer该行或列是可扩展的：
AddGrowableCol(idx, proportion=0)
AddGrowableRow(idx, proportion=0)

SetFlexibleDirection(direction)

SetNonFlexibleGrowMode(mode)

=========================
grid bag sizer

1、能够将一个窗口部件添加到一个特定的单元格。(如果一个栅没有孩子,会占有效空间的)
2、能够使一个窗口部件跨越几个单元格（就像HTML表单中的表格所能做的一样）。

注意这里的Add()方法与以前的看起来有点不同 :

1 Add(window, pos, span=wx.DefaultSpan, flag=0, border=0, userData=None)

2 Add(sizer, pos, span=wx.DefaultSpan, flag=0, border=0, userData=None)

3 Add(size, pos, span=wx.DefaultSpan, flag=0, border=0, userData=None)

4 AddItem(item)
比其它sizer多了一个位置参数:因为它为孩子预留了空间

============== 下面是通用方法 ================

sizer对象的构造方法有两个比较重要的参数:

flag:窗体风格,对齐方式,边框位置

proportion:如果使用窗体大小变化时的空间使用,为一个比例值

孩子指定一个最小的尺寸

窗口的方法

SetMinSize(width, height)

SetSizeHints(minW, minH, maxW, maxH)

使用sizer的SetItemMinSize()方法。它也有三个形式：

SetItemMinSize(window, size)
SetItemMinSize(sizer, size)
SetItemMinSize(index, size)

对sizer添加或移除孩子:

Add(window, proportion=0, flag=0, border=0, userData=None)
Add(sizer, proportion=0, flag=0, border=0, userData=None)
Add(size, proportion=0, flag=0, border=0, userData=None)

Insert(index, window, proportion=0, flag=0, border=0, userData=None)
Insert(index, sizer, proportion=0, flag=0, border=0, userData=None)
Insert(index, size, proportion=0, flag=0, border=0, userData=None)

Prepend(window, proportion=0, flag=0, border=0, userData=None)
Prepend(sizer, proportion=0, flag=0, border=0, userData=None)
Prepend(size, proportion=0, flag=0, border=0, userData=None)

Detach(window)
Detach(sizer)
Detach(index)

管理它的孩子的尺寸和对齐的

调整grid sizer的大小时，每个部件之间的间隙将随之改变，但是默认情况下，窗口部件的尺寸不会变，并且始终按左上角依次排列

添加一个窗口部件到sizer时，可以通过给flag参数一个特定值来调整该窗口部件的尺寸改变行为。
wx.ALIGN_BOTTOM：按照窗口部件被分配的空间（格子）的底部对齐。

wx.ALIGN_CENTER：放置窗口部件，使窗口部件的中心处于其所分配的空间的中心。

wx.ALIGN_CENTER_HORIZONTAL：在它所处的格子中，水平居中。

wx.ALIGN_CENTER_VERTICAL ：在它所处的格子中，垂直居中。

wx.ALIGN_LEFT：靠着它所处的格子左边缘。这是默认行为。

wx.ALIGN_TOP：靠着它所处的格子的上边缘。这是默认的行为。

wx.EXPAND：填满它所处的格子空间。

wx.FIXED_MINSIZE：保持固定项的最小尺寸。

wx.GROW：与wx.EXPAND相同。但比之少两个字符，节约了时间。

wx.SHAPED：窗口部件的尺寸改变时，只在一个方向上填满格子，另一个方向上按窗口部件原先的形状尺寸的比列填充。什么方向的sizer就向什么方向增长

管理每个孩子的边框

边框是连续数量的空白空间,方向有:wx.BOTTOM, wx.LEFT, wx.RIGHT, wx.TOP

传递了边框信息到flags参数后，也需要传递边框宽度的像素值给border参数 ,为边框的大小

http://sellroad.w58.ws86.com/jessinio/?p=512

Python中向MySQL保存Blob

Python code

import MySQLdb, cPickle
# Connect to a DB, e.g., the test DB on your localhost, and get a cursor
connection = MySQLdb.connect(db="test")
cursor = connection.cursor( )
# Make a new table for experimentation
cursor.execute("CREATE TABLE justatest (name TEXT, ablob BLOB)")
try:
   # Prepare some BLOBs to insert in the table
    names = 'aramis', 'athos', 'porthos'
   data = {  }
   for name in names:
       datum = list(name)
       datum.sort( )
       data[name] = cPickle.dumps(datum, 2)
   # Perform the insertions
    sql = "INSERT INTO justatest VALUES(%s, %s)"
   for name in names:
       cursor.execute(sql, (name, MySQLdb.escape_string(data[name])) )
   # Recover the data so you can check back
    sql = "SELECT name, ablob FROM justatest ORDER BY name"
   cursor.execute(sql)
   for name, blob in cursor.fetchall( ):
       print name, cPickle.loads(blob), cPickle.loads(data[name])
finally:
   # Done. Remove the table and close the connection.
    cursor.execute("DROP TABLE justatest")
   connection.close( )

http://topic.csdn.net/u/20080319/11/814acdd6-a064-4419-ae52-930cdc97ca45.html

A PYTHON APPLICATION WHERE THREADS WOULD HELP

Let's say that you want to check the availability of many computers on a network ... you'll use ping. But there's a problem - if you "ping" a host that's not running it takes a while to timeout, so that when you check through a whole lot of systems that aren't responding - the very time a quick response is probably needed - it can take an age.

Here's a Python program that "ping"s 10 hosts in sequence.

import os
import re
import time
import sys

lifeline = re.compile(r"(\d) received")
report = ("No response","Partial Response","Alive")

print time.ctime()

for host in range(60,70):
ip = "192.168.200."+str(host)
pingaling = os.popen("ping -q -c2 "+ip,"r")
print "Testing ",ip,
sys.stdout.flush()
while 1:
line = pingaling.readline()
if not line: break
igot = re.findall(lifeline,line)
if igot:
print report[int(igot[0])]

print time.ctime()

Running that program, it works but it's a bit slow:

[trainee@buttercup trainee]$ python alive
Mon May 9 05:22:51 2005
Testing 192.168.200.60 No response
Testing 192.168.200.61 No response
Testing 192.168.200.62 No response
Testing 192.168.200.63 No response
Testing 192.168.200.64 No response
Testing 192.168.200.65 No response
Testing 192.168.200.66 Alive
Testing 192.168.200.67 No response
Testing 192.168.200.68 No response
Testing 192.168.200.69 No response
Mon May 9 05:23:19 2005
[trainee@buttercup trainee]$

That was 28 seconds - in other words, an extra 3 seconds per unavailable host.

THE SAME APPLICATION, WRITTEN USING PYTHON THREADS

I'll write the application and test it first ... then add a few notes at the bottom.

import os
import re
import time
import sys
from threading import Thread

class testit(Thread):
def __init__ (self,ip):
Thread.__init__(self)
self.ip = ip
self.status = -1
def run(self):
pingaling = os.popen("ping -q -c2 "+self.ip,"r")
while 1:
line = pingaling.readline()
if not line: break
igot = re.findall(testit.lifeline,line)
if igot:
self.status = int(igot[0])

testit.lifeline = re.compile(r"(\d) received")
report = ("No response","Partial Response","Alive")

print time.ctime()

pinglist = []

for host in range(60,70):
ip = "192.168.200."+str(host)
current = testit(ip)
pinglist.append(current)
current.start()

for pingle in pinglist:
pingle.join()
print "Status from ",pingle.ip,"is",report[pingle.status]

print time.ctime()

And running:

[trainee@buttercup trainee]$ python kicking
Mon May 9 05:23:36 2005
Status from 192.168.200.60 is No response
Status from 192.168.200.61 is No response
Status from 192.168.200.62 is No response
Status from 192.168.200.63 is No response
Status from 192.168.200.64 is No response
Status from 192.168.200.65 is No response
Status from 192.168.200.66 is Alive
Status from 192.168.200.67 is No response
Status from 192.168.200.68 is No response
Status from 192.168.200.69 is No response
Mon May 9 05:23:39 2005
[trainee@buttercup trainee]$

3 seconds - much more acceptable than the 28 seconds that we got when we pinged the hosts one by one and waited on each.

http://www.wellho.net/solutions/python-python-threads-a-first-example.html

python中的编码转换

ASCII 是一种字符集,包括大小写的英文字母、数字、控制字符等，它用一个字节表示，范围是 0-127

Unicode分为UTF-8和UTF-16。UTF-8变长度的，最多 6 个字节，小于 127 的字符用一个字节表示，与 ASCII 字符集的结果一样，ASCII 编码下的英语文本不需要修改就可以当作 UTF-8 编码进行处理。

Python 从 2.2 开始支持 Unicode ，函数 decode( char_set )可以实现 其它编码到 Unicode 的转换，函数 encode( char_set )实现 Unicode 到其它编码方式的转换。

比如 ("你好").decode( "GB2312") 将得到 u'\u4f60\u597d'，即 "你"和“好"的 Unicode 码分别是 0x4f60 和 0x597d
再用 (u'\u4f60\u597d').encode("UTF-8") 将得到 '\xe4\xbd\xa0\xe5\xa5\xbd'，它是 “你好”的UTF-8编码结果。


python中使用 unicode的关键：unicode是一个类，函数unicode(str,"utf8")从utf8编码（当然也可以是别的编码）的字符串str生成 unicode类的对象，而函数unc.encode("utf8")将unicode类的对象unc转换为（编码为）utf8编码（当然也可以是别的编码）的字符串。于是，编写unicode相关程序，需要做的事情是

* 获取数据（字符串）时，用unicode(str, "utf8")生成unicode对象
* 在程序中仅使用unicode对象，对程序中出现的字符串常量都以u"字符串"的形式书写
* 输出时，可将unicode对象转换为任意编码输出，使用str.encode("some_encoding")

>>> unicode("你好", "utf8")
u'\u4f60\u597d'
>>> x = _
>>> type(x)

>>> type("你好")

>>> x.encode("utf8")
'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> x.encode("gbk")
'\xc4\xe3\xba\xc3'
>>> x.encode("gb2312")
'\xc4\xe3\xba\xc3'
>>> print x
你好
>>> print x.encode("utf8")
你好
>>> print x.encode("gbk")
???

以上是测试结果（Ubuntu 6.06，locale为utf8），注意type(x)和type("你好")的区别。从编码上可以看出utf8编码与gbk不同。在utf8的 locale设置下，打印x按该环境变量编码（我猜我猜我猜猜猜），而打印x.encode("gbk")则是乱码。
http://guanjh.javaeye.com/blog/131185

Python扩展方法及工具比较

一、普通扩展方法
扩展Python包括三个步骤：
1. 创建源程序(C, C++, java, ...)；
2. 为源程序写wrap代码；
包括四个步骤：
Ø include "Python.h";
Ø 为每个模块函数写wrap，即：PyObject* Module_func()；
Ø 为每个模块函数写函数定义，即：PyMethodDef ModuleMethods[]对应表；
Ø 写模块的初始化函数：void initModule()部分。
3. 编译连接；
有两种方法：
(1)使用distutils包。步骤如下：
Ø 修改distutils包中的setup.py文件；
Ø 根据需要运行$ python setup.py build或$ python setup.py install命令，生成扩展模块的共享库文件。
(2)直接使用gcc命令将模块编译成共享库。命令如下：
$ gcc -fpic -c -I/usr/include/python2.2 -I/usr/lib/python2.2/config foo.c wrap_foo.c
$ gcc -shared -o foo.so foo.o wrap_foo.o
这样便生成了python可用的foo模块。
4. 使用扩展内容
进入python环境，通过import foo，使用foo模块中的函数。如用foo.func()调用foo模块中的func()函数。

http://hi.baidu.com/minyuanyang/blog/item/1222c5c831075a137e3e6f0a.html

Compiling Python Code

Python source code is automatically compiled into Python byte code by the CPython interpreter. Compiled code is usually stored in PYC (or PYO) files, and is regenerated when the source is updated, or when otherwise necessary.

To distribute a program to people who already have Python installed, you can ship either the PY files or the PYC files. In recent versions, you can also create a ZIP archive containing PY or PYC files, and use a small “bootstrap script” to add that ZIP archive to the path.

To “compile” a Python program into an executable, use a bundling tool, such as Gordon McMillan’s installer (alternative download) (cross-platform), Thomas Heller’s py2exe (Windows), Anthony Tuininga’s cx_Freeze (cross-platform), or Bob Ippolito’s py2app (Mac). These tools puts your modules and data files in some kind of archive file, and creates an executable that automatically sets things up so that modules are imported from that archive. Some tools can embed the archive in the executable itself.

If all you need is to wrap up a couple of Python scripts and modules into a single file, Squeeze might be what you need. For Windows, my ExeMaker tool can also be quite useful (on its own, or in combination with squeeze).

Compiling Python modules to byte code #

Python automatically compiles Python source code when you import a module, so the easiest way to create a PYC file is to import it. If you have a module mymodule.py, just do:

>>> import mymodule

to create a mymodule.pyc file in the same directory. A drawback is that it doesn’t only compile the module, it also executes it, which may not be what you want. (however, it does compile the entire script even if it fails to execute the script).

To do this programmatically, and without executing the code, you can use the py_compile module:

import py_compile

py_compile.compile("mymodule.py")

There’s also a compileall module which can be used to compile all modules in an entire directory tree.

import compileall

compileall.compile_dir("mylib", force=1)

More on byte code #

Python’s byte code is portable between platforms, but not necessarily between Python releases. The imp.get_magic() function returns a 4-byte string identifying the byte code format used by the current interpreter.

You can use the compile function and the marshal module to compile Python code into code objects, and convert such code objects to binary strings. To reverse this process, use marshal to convert from strings to code, and use exec to execute code.

Examples to be added.

http://effbot.org/zone/python-compile.htm

在pyLucene中使用中文分词器（在pyLucene中引用Jar包）

（刚刚解决的一个问题，在中文里面没有搜索到相关内容（英文里其实也没搜到...），发一篇在这里备人索引，关键字：pyLucene, JCC,
Lucene, Importing JAR）

在Lucene里面引用别人写好的中文分词器很简单，加个CLASSPATH就好。但是在pyLucene（JCC版）里，由于python所能够引用
到的Jar包都是用JCC这个编译器（姑且认为是个编译器吧）预先编译了python调用接口的。（反过来说，就是没有经JCC编译的Jar包是休想在
python里面直接访问的）

所以，在pyLucene中使用Jar包形式的中文分词器不得不重新编译。分隔线以下是OSFoundation某热心人关于如何修改Makefile
让Jar包可以和pyLucene打包到一起的回复。

-------------------------------------热心人回复的分隔
线-------------------------------------
Andi Vajda:
To access your class(es) by name from Python, you must have JCC
generate wrappers for it (them). This is what is done line 177 and on
in PyLucene's Makefile. The easiest way for you to add your own Java
classes to PyLucene is to create another jar file with your own
analyzer classes and code and add it to the JCC invocation there.

For example, the Makefile snippet in question currently says:

GENERATE=$(JCC) $(foreach jar,$(JARS),--jar $(jar)) \
--package java.lang java.lang.System \
java.lang.Runtime \
--package java.util \
java.text.SimpleDateFormat \
--package java.io java.io.StringReader \
java.io.InputStreamReader \
java.io.FileInputStream \
--exclude org.apache.lucene.queryParser.Token \
--exclude org.apache.lucene.queryParser.TokenMgrError \
--exclude
org.apache.lucene.queryParser.QueryParserTokenManager \
--exclude org.apache.lucene.queryParser.ParseException \
--python lucene \
--mapping org.apache.lucene.document.Document 'get:(Ljava/
lang/String;)Ljava/lang/String;' \
--mapping java.util.Properties 'getProperty:(Ljava/lang/
String;)Ljava/lang/String;' \
--sequence org.apache.lucene.search.Hits 'length:()I' 'doc:
(I)Lorg/apache/lucene/document/Document;' \
--version $(LUCENE_VER) \
--files $(NUM_FILES)

change the first line to say:

GENERATE=$(JCC) $(foreach jar,$(JARS),--jar $(jar)) --jar myjar.jar \
...

and rebuild PyLucene. That should be all you need to do. Your jar file
is going to be installed along with lucene's in the lucene egg and it
is going to be put on lucene.CLASSPATH which you use with
lucene.initVM().

Your classes can be declared in any Java package you want. Just make
sure that their names don't clash with other Lucene class names that
you also need to use as the class namespace is flattened in PyLucene.

For more information about JCC and its command line a