博客导航

博客日历

«	八月 2008					»
一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

使用P4D 编写Python Extension[使用rst编写]

发表人:1000copy | 发表时间: 2007年四月01日, 13:58

Date:	$Date: 2007年4月1日
Date:	$Date: 2007年4月1日

使用P4D 编写Python Extension

Author:	1000copy
Address:	空无一人不知所致
Contact:	1000copy@gmail.com or http://1000copy.itpub.net
organization:	无党派人士
status:	差不多了:version: 1:copyright: This document has been placed in the public domain. You may do with it as you wish. You may copy, modify, redistribute, reattribute, sell, buy, rent, lease, destroy, or improve it, quote it at length, excerpt, incorporate, collate, fold, staple, or mutilate it, or do anything else to it that your or anyone else's heart desires.
Dedication:	喜欢Python的Delphi的程序员
abstract:	在互联网公共可访问领域内，关于Python/C interface的介绍，手册都是比较多的。Py直接支持C编写扩展，对于Delphi程序员，P4D是一个很好的选择。不幸的是，通过P4D[#]编写PyExtention，并没有一个很好的入门文档，本文试图填写这个空白。本文风格完全模仿Writing Python Extensions[1],希望以例子为本，让大家很快的进入状态。

引言

本文假设你

懂得Python
懂得Delphi
想要通过P4D编写Python Extension
已经安装了Delphi7，P4D，Python2.4以上。

第一个Python Extension

以下的例子是可以直接使用的，只要拷贝如下代码，存放到ExAdd.dpr，直接用Delphi编译，就可以成为一个Python Extension 。我们可以首先看到效果，然后在分析程序。

最小的例子

最小的例子:

{文件名 ExAdd.dpr}
library ExAdd;
uses SysUtils,Classes,PythonEngine;
{$E pyd}
var
 FModule : TPythonModule;
 FEngine:TPythonEngine ;
function Add( Self, Args : PPyObject ) : PPyObject; far; cdecl;
var
  a, b : Integer;
begin
  with GetPythonEngine do
    begin
      if PyArg_ParseTuple( args, 'ii:Add', [@a, @b] ) <> 0 then
        begin
          Result := PyInt_FromLong( a + b );
        end
      else
        Result := nil;
    end;
end;
procedure initExAdd; cdecl;
begin
  FEngine := TPythonEngine.Create(nil);
  FModule := TPythonModule.Create(nil);
  FModule.Engine := FEngine;
  FModule.ModuleName := 'ExAdd';
  FModule.AddMethod( 'exadd', @Add, 'exadd(a,b) -> a+b ' );
  FEngine.LoadDll;
end;
exports
  initExAdd;
var
  OldExitProc: pointer;
procedure MyExitProc;
begin
  FModule.Free;
  FEngine.Free;
  ExitProc := OldExitProc;
end;
begin
  OldExitProc := ExitProc;
  ExitProc := @MyExitProc;
end.
// 测试代码
//from ExAdd import *
//print exadd(1,10)

解说

这是一个最小的例子，只要一个文件ExAdd.dpr ,不需要任何其他的Pas Unit文件就可以了。当我们把他放到py的syspath内，比如<pythonhome>libsite-packages,在pywin内，可以做如下测试:
>>> from ExAdd import *
>>> print exadd(1,10)
11
>>>
可以看到，Python内的程序确实成功的调用了通过Delphi写的扩展。如何做到的？

如何注册一个模块

当Python内执行

from ExAdd import *

时，将会到syspath内寻找ExAdd.pyd,这里的pyd就是一般的dll，只不过还有一些约定。当Py找到这个文件后，就调用引出函数initExAdd,这个函数的命名就是python程序和.pyd模块的的一个约定----函数命名必须为init+module名称。一般来说，在init函数内，就进行引擎的初始化，模块的注册，函数，类型的注册等等工作。这里例子内，我们使用了TPythonEngine， TPythonModule两个P4D提供的类，帮助我们做这些工作。注册模块时，要注意

FModule.ModuleName := 'ExAdd';

内的ModuleName就是在Python内使用的模块完全一致，当然我们可以使用其他的名字，比如ExQuickAdd，只要

from ExAdd import *

内使用的模块名称一致即可。为了方便和一致，我们可以约定dll的名字，python内的module，delphi内的TPythonModule名字完全一致。这在语法上并非必须，不过这样做是一个很好的习惯。

如何注册一个函数

任何一个按照如下原型注册的函数，都可以被注册为PyExtention的函数。

function Add( Self, Args : PPyObject ) : PPyObject; far; cdecl;

其中cdecl说明服从C语言的调用规范，而不是Pascal或者其他。毕竟Python是C语言写就的，当然按照C语言的习惯来。这个函数原型中，参数将会包括Self，Args，返回值得也是一个PPyObject，熟悉Python语言的都知道，任何一个Python函数在被调用时都会传递一个Self 指针进来，并且以Tuple的方式传递参数列表，这个Add函数的实现约定上也就表现出来了，所有的类型都是对象。比如Add(3,4)这个的Python调用，参照Add在Delphi中函数原型，上，那么"3,4"作为一个Tuple对象，伴随Self，也是一个PPyObject,返回值7也是一个PPyObject来表达。要不怎么都说Python慢呢？本来一个加操作可以直接对应汇编中的一个指令，现在又是对象又是指针，当然很难快了。

一旦有了这样的声明，就可以这样注册函数。

FModule.AddMethod( 'exadd', @Add, 'add(a,b) -> a+b ' );

以上语句向Python系统声明，exadd函数的实现在add内，最后参数作为__docstring__。当IDE内使用这个函数时，可以通过codeinsight,或者help来获得函数的使用说明。现在来看add的实现代码。一眼看过去，PyArg_ParseTuple，PyInt_FromLong是两个特别的东西。 PyArg_ParseTuple负责把传进来的args变成简单的Delphi类型，在Ppyobject内存储的3,4，分别存放到a,b:Integer内，就是

PyArg_ParseTuple( args, 'ii:Add', [@a, @b] ) <> 0

其中第二个参数 'ii:Add' ，有些像是Format格式，i指明类型为Integer，两个I指明有两个整数,:add是可选的，当出错的时候，有:add，可以帮助程序员更好的找到错误。这样就把PPyobeject所表达的PythonType转为一般Delphi类型；而PyInt_FromLong这是想法，他把Delphi的Long类型转换为PyObject的Integer；从而可以让结果可以为Python识别。这两个函数尽管是P4d实现的，但是和Python/C interface手册内规定的函数名称一致，因此具体的调用方法也可以看Python/C interface手册。

实际上Python实现内的对象表达采用了一个结构(Struct),很有一些复杂，我们现在可以在很高层的去看，要感谢P4D所做的工作。

实现一个类

第一个例子可以工作，并且能够演示注册模块，函数和一些基本的Python Ext的概念。对于长期使用Delphi这样的OO语言，仅仅公开函数当然不够方便，我们需要的是全OO编程，即使跨越了语言，也不会放弃这样的习惯。我们现在要让Delphi的类可以为Python。

又一个例子

你首先看到的依然是一个例子,我们要把Delphi中的TPoint公开出来，让python可以调用，模块名称为dpoint，最终我们要在pythonIDE内看到的效果:

>>> from dpoint import *
>>> print SmallPoint(222,111)
<SmallPoint at D393C8>
>>> SmallPoint.__doc__
'wrapper for Delphi TPoint typen'

P4D为注册类这样的工作提供了TPyDelphiWrapper类，在这个例子里，我们围绕这TPyDelphiWrapper来分析。

例子代码:

library dpoint;
uses
  Sharemem ,SysUtils,Classes,WrapDelphi,Types,PythonEngine;
{$E pyd}
var
 FModule : TPythonModule;
 FEngine:TPythonEngine ;
 FDelphiWrapper : TPyDelphiWrapper;
procedure initdpoint; cdecl;
begin
  FEngine := TPythonEngine.Create(nil);
  FModule := TPythonModule.Create(nil);
  FModule.Engine := FEngine;
  FModule.ModuleName := 'dpoint';
  FDelphiWrapper := TPyDelphiWrapper.Create(nil);
  FDelphiWrapper.Engine := FEngine;
  FDelphiWrapper.Module := FModule;
  FEngine.LoadDll;
end;
exports
  initdpoint;
var
  OldExitProc: pointer;
procedure MyExitProc;
begin
  FModule.Free;
  FEngine.Free;
  ExitProc := OldExitProc;
end;
type
  TPyDelphiPoint = class(TPyObject)
  private
    fValue: TPoint;
  protected
  public
    constructor CreateWith( APythonType : TPythonType; args : PPyObject ); override;
    class procedure SetupType( PythonType : TPythonType ); override;
  end;
 Type
  TTypesRegistration = class(TRegisteredUnit)
  public
    function Name : String; override;
    procedure RegisterWrappers(APyDelphiWrapper : TPyDelphiWrapper); override;
  end;
function TTypesRegistration.Name: String;
begin
  Result := 'Types';
end;
procedure TTypesRegistration.RegisterWrappers(APyDelphiWrapper: TPyDelphiWrapper);
begin
  inherited;
  APyDelphiWrapper.RegisterHelperType(TPyDelphiPoint);
end;
constructor TPyDelphiPoint.CreateWith(APythonType: TPythonType;
  args: PPyObject);
var
  x, y : Integer;
begin
  inherited;
  if APythonType.Engine.PyArg_ParseTuple( args, 'ii:Create', [@x, @y] ) <> 0 then
  begin
   fValue.X := x;
   fValue.Y := y;
  end
end;
class procedure TPyDelphiPoint.SetupType(PythonType: TPythonType);
begin
  inherited;
  PythonType.TypeName := 'SmallPoint';
  PythonType.TypeFlags := PythonType.TypeFlags + [tpfBaseType];
  PythonType.DocString.Text := '12345';
end;
begin
  RegisteredUnits.Add(TTypesRegistration.Create);
  OldExitProc := ExitProc;
  ExitProc := @MyExitProc;
end.

注册过程

一个类必然要属于某一个模块，注册一个类就涉及到注册一个模块。关于注册模块，在例子中占据了不少带代码，但是它和第二部分完全一样，我们掠过不看。本来注册一个类是有些复杂度的，如果想要知道这个复杂度，可以先看看参考文献1内的描述。不过采用P4D的类型注册框架就简单多了。我们的例子pyd命名为dpoint ,我们准备把TPoint类型公开到Python内。

在initdpoint函数内，TPythonEngine，TPythonModule照样的初始化，比起函数注册来说，不同的地方在于创建了TPyDelphiWrapper的实例gDelphiWrapper，并且指明他所属的PythonEngine，PythonModule:

procedure initdpoint;
begin
    gEngine := TPythonEngine.Create(nil);
    gEngine.AutoFinalize := False;
    gModule := TPythonModule.Create(nil);
    gModule.Engine := gEngine;
    gModule.ModuleName := 'dpoint';
    gDelphiWrapper := TPyDelphiWrapper.Create(nil);
    gDelphiWrapper.Engine := gEngine;
    gDelphiWrapper.Module := gModule;
    gEngine.LoadDll;
end;

gDelphiWrapper将会在RegisteredUnitList寻找RegisteredUnit，并且调用这个类别内的RegisterWrappers方法，通过这个方法或者需要注册的Python类的Delphi包装类。因此，我们要做的事情就是：约定实现两个类，一个是需要公开的类型的Wrapper，这里就是TPyDelphiPoint，一个是注册这个Wrapper的注册类，本例子内就是TTypesRegistration。 TTypesRegistration只要实现两个覆盖基类的方法，从而达到通知TPyDelphiWrapper需要注册的类是TPyDelphiPoint。

function Name : String; override; procedure RegisterWrappers(APyDelphiWrapper : TPyDelphiWrapper); override;

我们更多的注意力，尤其是以后的更多对PythonExtension特性的利用，集中于TPyDelphiPoint上。 TPyDelphiPoint，作为一个PythonType，最少要实现的方法有:

      constructor CreateWith( APythonType : TPythonType; args : PPyObject ); override;
class procedure SetupType( PythonType : TPythonType ); override;

我们可以注意到，CreateWith传递的args依然是PPyObject类型，和前文谈到的add方法对参数和返回值的处理都是一致的。 SetupType将会指明在Python内如何使用这个类型，根据源代码知道，SetupType指明这个类型在Python内的类型为SmallPoint，提供基本服务（fvbase）,类型文档__doc__为 '12345'，测试用例3.1代码如果正常运行，就自然的证实了这一点。

充分利用Python的特性

repr服务

以上例子很简单，但是可以表达主旨，是进一步了解和把握P4D编写扩展的基础。从3.1的测试用例看:

>>> print SmallPoint(222,111)
     <SmallPoint at D393C8>

这样的输出很不友好，我们希望他是这样的:

>>> print SmallPoint(222,111)
      222,111

这样的服务在py内早已存在，它的名字叫做repr，每个对象如果希望打印友好，都应该支持这样的服务。在Delphi编写的Py扩展中，如何做到这样的效果？

例子

一旦框架铺陈完毕，编写具体的功能就很简单了。repr服务只要覆盖一个方法，加上对返回参数的包装就可以了:

function  Repr : PPyObject; override;
..
implementation
..
function TPyDelphiPoint.Repr: PPyObject;
begin
  with GetPythonEngine do
    Result := PyString_FromString(PChar(Format('<Point (%d, %d)>', [Value.X, Value.Y])));
end;

设置属性，需要覆盖RegisterGetSets方法:

class procedure TPyDelphiPoint.RegisterGetSets(PythonType: TPythonType);
begin
  inherited;
  with PythonType do
    begin
      AddGetSet('X', @TPyDelphiPoint.Get_X, @TPyDelphiPoint.Set_X,
        'Provides access to the X coordinate of a point', nil);
      AddGetSet('Y', @TPyDelphiPoint.Get_Y, @TPyDelphiPoint.Set_Y,
        'Provides access to the Y coordinate of a point', nil);
    end;
end;

别忘了在SetupType内加入一行：

PythonType.Services.Basic := PythonType.Services.Basic+[bsGetAttrO, bsSetAttrO];

告诉Python你的服务中有属性的支持。

允许dpoint之间比较大小，需要覆盖Compare方法:

function TPyDelphiPoint.Compare(obj: PPyObject): Integer;
var
  _other : TPyDelphiPoint;
begin
  if IsDelphiObject(obj) and (PythonToDelphi(obj) is TPyDelphiPoint) then
  begin
    _other := TPyDelphiPoint(PythonToDelphi(obj));
    Result := CompareValue(Value.X, _other.Value.X);
    if Result = 0 then
      Result := CompareValue(Value.Y, _other.Value.Y);
  end
  else
    Result := 1;
end;

同样别忘了在SetupType内加入一行:

PythonType.Services.Basic := PythonType.Services.Basic+[bsCompare];

告诉Python你的服务中有bsCompare的支持。

编写扩展后做什么？

P4d的代码值得已读，因为

基于注册的架构，dll直接到类TDynamicDll值得看，了解Python的内部实现，P4d本身就是Python和Delphi结合编程的良好榜样。
可以很好的了解Python类型的内部实现，比如整数的结构里面有那些字段，有那些基本类型服务的方法

使用P4D还可以怎么样？

这个图景在我自己还并不很清楚。但是Python和Delphi的结合的愿望在我却一直很强烈，希望有更多的朋友参与进来，提出更多的想法。

参考

[1] Michael Hudson 's writingPythonExtensions

[2] P4D Python For Delphi的缩写，从它的Change.txt内可以看到，这个P4D从1998年计算有接近10年的历史了。世道沧桑啊。

[3] Using Delphi and Python together pythonDelphiTalk .

很好的教程，可惜对输出类型这里语焉不详，不知道为什么。这也是我要写本文的动因。

Delphi = a great object oriented language, and a fantastic RAD environment and framework. You can build excellent GUI's in Delphi that run very fast and have a small .EXE footprint. Runs on linux too. There is a free version of Delphi, too.

Python = is rapidly rising in popularity due to its pseudo-code-like, syntactically minimalist but straightforward syntax. Like the Delphi community, the Python community of programmers has a nice feel about it, and it is committed to developing rich, high quality, open-source class libraries for Python - without the hype of Java.

This paper will demonstrate how to incorporate Python in any of your Delphi apps! Or conversely, how to use Delphi as a GUI for your python apps.

—Andy　Bulka

摘录： NewEdit/doc/architecture.htm

发表人:1000copy | 发表时间: 2007年三月31日, 08:10

----------------评价

可以达到的一个效果就是：一个changelog的版本修改记录，可以完全确定修改对应的源代码文件。

好与坏还需要权衡。但是仅仅一一点，就让人有尝试的愿望了。

----------------原文

软件开发是一件很痛苦的事情，大量新的需求与现有软件结构之间的冲突是造成软件难以维护的一个主要原因。很多软件在刚开始时可能结构很好，便于扩充，但随着软件功能的丰富，代码的增加，可能会造成结构也变得不再适应新需求的发展。对于编辑器软件来说，这样的问题更为明显。那么NewEdit就是想在如何构造一种灵活的结构方面进行的一种有益地探索，同时它会发展成为一个专业、稳定地编辑器软件。因此，NewEdit的设计核心就是，如何构造一种灵活的架构，使得新功能的增加更为方便和易于维护。

NewEdit使用的软件基础是Python+wxPython。因此，NewEdit可以充分地享受Python的动态特性所带来的好处，同时由于使用了wxPython，还可以实现跨平台的运行。

这样，NewEdit的设计思想就是充分利用Python语言的动态特性，构造易于扩充而又灵活的软件体系。具体的实现技术就是全部采用Mixin和Plugin的设计与开发方法，更为通俗地说法就是分布式类编程技术，或狭义地理解为插件编程 (但分布式类编程与插件编程是不同的，分布类编程包括Mixin和Plugin，而插件编程一般只包括Plugin，因此插件编程的功能扩展是有局限的)。有时为了简单，我会叫分布类编程为Mixin，具体到技术细节时，会细分Mixin和Plugin。

比如，软件刚开始还是一个雏形，可能只有少数的功能。因此，会有一些实现了基础功能的类。当这些基础功能稳定，同时有新的需求时，这时需要对这些类进行扩展。扩展基本分为两种：

新的方法、属性的实现
增加对新方法、属性的调用入口

对于无法通过新的方法、属性实现的可能还需要增加新的类。此时可以对现有的类采用第二种扩展从而实现原有类与新类之间的联系。

知道了扩展方式，那么在哪里去实现呢？对于第1种扩展，我的方法是，基本不动原来的类所在的文件，而是创建一个新的文件，在这个新文件中实现新的方法、属性。然后通过一种机制把新的方法和属性与目标类进行融合，同时这种融合是在运行时才实现的。这样，一个类的功能是随着开发的进行，不停地进行扩展。由于新的扩展并不是直接在原来的文件中进行地修改，并且在一个文件中可以同时对多个类进行扩展，因此相对容易地知道本次扩展都做了哪些工作，对于软件的维护非常方便。这些扩展会通过一种机制，在软件运行时自动与目标类进行融合，不需要做额外的工作。对于这种扩展，我叫它为Mixin扩展。对于第2种扩展，我的方法是，在原来的类中增加相应的调用接口，同时在Mixin扩展中增加对调用接口的具体实现，从而通过调用接口将新增的功能与原类联系起来。对于这种扩展我叫它为Plugin扩展，也可以叫做插件扩展。

因此Mixin扩展的开发主要是对目标类进行功能扩展，如增加新的类方法，修改类方法，增加新的属性等。对于Plugin 扩展主要是在目标类中需要寻找合适的调用位置，定义相应的调用接口。同时实现具体的Plugin实现代码。

这里还存在的一个要考虑的问题是，Plugin扩展要根据具体情况考虑是否需要实现。首先，实现Plugin是因为新增的方法、属性的使用不会自动完成，需要一个调用点。如果你扩展的方法属合某种事件机制的调用规则，那么可以不用实现Plugin接口，否则就要实现相应的Plugin接口。

下面举一个例子，来看一下两种扩展的实现。其中有些具体的细节还没有涉及，后面会讲到:

class MainFrame(wx.Frame):
    def __init__(self, parent, title='Test'):
        wx.Frame.__init__(self, parent, -1, title=title)

上面是一个窗体，这可能就是我们的雏形。现在我们想在上面增加一个按钮，并对按钮事件进行响应。我们可以直接在 MainFrame上修改。如果这个类很简单当然可以，但如果这个类很复杂，并且一次改动不止要改动一个地方，就不是一件容易的事情了。现在我们使用Mixin的方法来做。

如果想使一个类可以实现分布类编程，那么需要使它成为Mixin类，我定义它为Slot类(槽类)，那么它就是一个目标类，将被进行Mixin扩展。改造MainFrame类如下:

import Mixin
import wx

class MainFrame(wx.Frame, Mixin):
    __mixinname__ = 'mainframe'

    def __init__(self, parent, title='Test'):
        self.initmixin()
        wx.Frame.__init__(self, parent, -1, title=title)

改造很简单，使得MainFrame有一个Mixin的基类，定义一个类属性__mixinname__，如: mainframe，在__init__中调用self.initmixin()。这样，我们就把一个MainFame改造成了一个槽类。

创建一个新文件，将用于实现具体的扩展。内容如下:

import Mixin
import wx

def init(win):
    win.ID_CLICK = wx.NewId()
    win.btnClick = wx.Button(win, win.ID_CLICK, 'Click Me')
    wx.EVT_BUTTON(win.btnClick, win.ID_CLICK, win.OnClick)

def OnClick(win, event):
    print 'Click Me'
    win.Close()

可以看出我们在新文件中实现了两个方法，一个用来创建一个按钮，并且设置当单击按钮时，调用OnClick事件处理函数。另一个就是 OnClick事件处理函数。如果我们不使用Mixin扩展，那么这两个函数可能是这样:

import wx

class MainFrame(wx.Frame):

    def __init__(self, parent, title='Test'):
        wx.Frame.__init__(self, parent, -1, title=title)
        self.ID_CLICK = wx.NewId()
        self.btnClick = wx.Button(self, self.ID_CLICK, 'Click Me')
        wx.EVT_BUTTON(self.btnClick, self.ID_CLICK, self.OnClick)

    def OnClick(self, event):
        print 'Click Me'
        self.Close()

可以看出，OnClick其实是MainFrame的成员方法，而init应该位于__init__中，是__init__中的一段处理。如果使用Mixin应该如何写呢？结果是:

import Mixin
import wx

def init(win):
    win.ID_CLICK = wx.NewId()
    win.btnClick = wx.Button(win, win.ID_CLICK, 'Click Me')
    wx.EVT_BUTTON(win.btnClick, win.ID_CLICK, win.OnClick)
Mixin.setPlugin('mainframe', 'init', init)

def OnClick(win, event):
    print 'Click Me'
    win.Close()
Mixin.setMixin('mainframe', 'OnClick', OnClick)

setPlugin是Plugin设置方法，它将把init与槽类('mainframe')的某个调用点相关联，由槽类的实例进行调用。而setMixin是Mixin 设置方法，它将把OnClick插入到槽类中，成为槽类的一个成员函数。

同时我们还需要修改MainFrame，增加一个调用点:

import Mixin
import wx

class MainFrame(wx.Frame, Mixin):
    __mixinname__ = 'mainframe'

    def __init__(self, parent, title='Test'):
        self.initmixin()
        wx.Frame.__init__(self, parent, -1, title=title)
        self.callplugin('init', self)

这样，槽类与Mixin文件都准备好了。如何才能将它们真正关联起来呢？很简单：在启动程序中将Mixin文件作为一个模块导入即可。这样真正的关联会等到运行时，首先通过导入先将所有Plugin和Mixin搜集起来，然后再等到创建实现时，通过self.initmixin()方法真正实现关联。并且这种操作只会执行一次。

因此Mixin与Plugin的区别就是：Mixin实现类的新方法和属性，而Plugin实现调用点的具体处理。更简单地理解：Mixin是对未知的扩展，而 Plugin是对已知的扩展。

使用Delphi 编写Python Extension

发表人:1000copy | 发表时间: 2007年三月25日, 00:58

我说要写，我写了。在电脑上花费了4个小时完成，22：00-00：50.眼是懒汉，手是好汉。查看全文

我想要仿照这个文档做一个p4d的文档。

发表人:1000copy | 发表时间: 2007年三月21日, 21:32

Writing Python Extensions

http://starship.python.net/crew/mwh/toext/toext.html

并且这个文档的风格也不做，看起来比较清晰和专业。好像有一个工具可以生成这个风格的文档。

xml-rpc 远程调用有多简单？

发表人:1000copy | 发表时间: 2007年三月21日, 21:09

基于以例子为本，看一个简单的xml-rpc服务器，客户端调用代码在""""""内：

from SimpleXMLRPCServer import SimpleXMLRPCServer
server = SimpleXMLRPCServer(("localhost", 8000))
def adder_function(x,y):
    return x + y
server.register_function(adder_function, 'add')
class MyFuncs:
    def div(self, x, y): 
        return x // y    
server.register_instance(MyFuncs())
server.serve_forever()
""" client

import xmlrpclib
s = xmlrpclib.Server('http://localhost:8000')
print s.add(2,3) 
print s.div(5,2) 
print s.system.listMethods()

"""

简单介绍：

server.register_function(adder_function, 'add')

只要调用register_function，传入的函数就可以公开给客户端调用。

只要调用register_instance(MyFuncs())，类的实例内的所有方法都可以在Server空间下，公开给客户端调用。

xml-rpc的主要有点就是简单，简单的令人不能置信。

缺点是：

1. 参数不支持传递中文,unicode 都这么多年了，这个能力的确实有些不可想象。

2. 1999年以来就不变了，看来是不想变了

3. 不能把类型传递给客户端，没有类似dcom的tlb，或者webservice的wsdl。调用的时候不能做静态类型检查。

SOAP在这个方面要想当然好得多。

因此xml-rpc对我而言，可以用于做研究和试验用。简单啊。

但是不可以把他用于商业程序。





分类:	(					Python
										) :: 评论 (0) :: 静态链接网址 :: 引用 (0)

当windows向你说道歉的时候。

发表人:1000copy | 发表时间: 2007年三月20日, 21:58

昨日完成的“输出Delphi Class到Python”,今天回来准备把程序搞得漂亮点，就发了文档出来的。

有些令人沮丧的是，写了一个TestPoint的测试程序，简单如下：

import demodll

就会导致这个错误：

python.exe 遇到问题需要关闭。我们对此引起的不便表示抱歉...
下面还有“调试”和“关闭”按钮。当然我不知道如何调试。

为什么那个P4D带的Delphi.pyd就不会？

最后发现如果这样写TestPoint

from Delphi import *

就会有问题。

这样写也是一样：

from Delphi import *
print Point(9,9)
而如果加上一个函数来的话就没有问题，如下：

from Delphi import *
def main():
print Point(9,9)
main()

原因还不清楚，当发现这个问题后，2个小时过去了：）

学习分布式系统的阅读

发表人:1000copy | 发表时间: 2007年三月20日, 10:08

1. xml－rpc 简洁，一目了然，关于中文的处理（Base64）可能是一个有用的指向。http://www.mengyan.org/blog/archives/2005/07/12/30.html

不错的一句话，多少人就是要一个简洁。

"Does distributed computing have to be any harder than this? I don't think so." -- Byte.

2. 有免费的Corba，其实以前也知道，但是因为不支持delphi，就把它忽略了。

http://omniorb.sourceforge.net/omnipy3/omniORBpy/omniORBpy002.html#toc3

使用delphi 为python创建一个新的类型。

发表人:1000copy | 发表时间: 2007年三月18日, 23:09

花费了一个晚上的时间，终于调试通过。时间长的原因是没有直接的文档和例子。时间不早了，紧急记录以下，主要看标注。

procedure initdemodll;
begin
try
gEngine := TPythonEngine.Create(nil);
gEngine.AutoFinalize := False;
gEngine.DllName := 'python24.dll';
gEngine.APIVersion := 1012 ;
//gEngine.LoadDll; 不能在这里，要想Type注册，必须放到AddClient之后
gModule := TPythonModule.Create(nil);
gModule.Engine := gEngine;
gModule.ModuleName := 'demodll';
gModule.AddMethod( 'add', @Add, 'add(a,b) -> a+b fffff' );
// form

PythonType:= TPythonType.Create(nil);
PythonType.Engine := gEngine ;
PythonType.Module := gModule ;
PythonType.TypeName := 'Point3';
PythonType.PyObjectClass := TPyPoint;
// AddClient 就是注册类型，为什么？不知道，最难的就是这里，很不容易猜测到通过这个方式来注册
gModule.AddClient(PythonType);
// 这个没有用处
//gModule.OnInitialization := form10.PythonType1Initialization ;
//gModule.Initialize;
gEngine.LoadDll;
except
end;
end;

一般过程：

输出一个函数很容易，可以看p4d的 demo09 .

这个文档http://starship.python.net/crew/mwh/toext/也写的很到位，尽管是基于C语言的。

输出一个类型就不简单。没有直接的文档。即使间接的也很少。p4dmoduledelphi是可以使用的，不过涉及的东西太多，一时摸不到头绪，C Api的手册就还在说PyObject的格式，更加云里雾里的。

还是源代码管用，看看p4dmoduledelphi,体会到AddClient，以测试果然就比较接近了。

另外dll生成后要改扩展名pyd,并且丢到libsite-package内，就可以import了。

好了，现在还太乱，先写到，怕忘了，等到明天晚上有时间，整理代码，做一个教程。

评论：

------------------

1. 叫做大全的，一点也不全：http://blog.csdn.net/kernelspirit/archive/2006/05/29/760413.aspx

2. 这样的写法非常漂亮，直接，拳拳到肉，值得学习。

http://starship.python.net/crew/mwh/toext/node20.html

3. 这样就太复杂了。

http://starship.python.net/crew/mwh/toext/defining-new-types.html

4. 深入了解PyCApi时可以看看，不错的例子。

http://my.opera.com/yjfuk/blog/show.dml/459374

5. 同4 ,深入了解PyCApi时可以看看，不错的例子。

http://www-128.ibm.com/developerworks/cn/linux/l-pythc/index.html

django vs cake 有感

发表人:1000copy | 发表时间: 2006年八月04日, 21:55

以前有用过php，3天做了一个项目，和一个同伴分别5000元，对比php，python总是那么不容易入手。工具也不如xampp那么继承，习惯上不对。

django被人认为是完美主义，他喜欢的是：这是一个common case ，所以我们会做一个shortcut，或者这个stupid ，redundut（冗余），所以要less code .有些感觉是卖弄，抽象是抽象了，看的不容易懂了。

django的turorial我看了3天，也没有完成一个完整的demo，cake我看了3个小时，就把demo做完了。想起来cake更加象ror，二django的自创太多。

1. urlconf使用了regexp，那么复杂无比

2. 在admin界面中，直接在modal中嵌入了STACK,TABLE,CORE等显示上的组织，非常的不mvc，感觉随意

3. 不是从数据库出发，而是一开始就采用object

4. 不好找一个成熟的bbs应用，php多的是，记得当年用java做oa时，就是从论坛的程序jive开始改，感觉学习和开放的速度很快的。现有的代码基础是很重要的。

5. django的template声称不是发明新的语言，实际上就是一个新的语言，语法怪异，djanggo的py本来就有一个indent的要求，没有那个语言做这样的要求，加上template，regexp，3大怪必然阻碍django的应用

6. 总觉得py在步java后尘，什么都想要做，没有那个做到真的好。

spe - a python IDE

发表人:1000copy | 发表时间: 2006年七月10日, 22:00

spe 一个python IDE

http://pythonide.stani.be/

需要wxpython

http://www.wxpython.org/download.php

然后执行

Python24Libsite-packages_speSPE.py

功能强劲

环境打好了，还是遇到问题

发表人:1000copy | 发表时间: 2006年七月09日, 18:38

TypeError: an integer is required

看得头昏昏的，到网上查了一下，limdou和一个朋友的对话有帮助，把

conn = builder()(user='root', passwd='',host='localhost', db='test')
修改为：

conn = builder()(user='root', passwd='',host='localhost', db='test',port=3306)

即可。

看起来原来的类已经注册的错误是因为这个错误引起的。

还有IDLE这个"IDE"实在有些丢分啊，看看

eclipse支持的如何了？

查看全文

python 的3种打包方式

发表人:1000copy | 发表时间: 2006年七月06日, 13:50

1. 源代码然后拷贝到site-packages中

2. egg 方式,也就是ez_install方式,再cheesyshop中的很多都是这个方式,可以检查相关性并自动安装,比如安装sqlobject 时,他会检查到需要formencode,然后首先安装formencode ,其次安装sqlobject.

当然下载后,根据依赖关系,一个个的ez_install也可以.

3. setup.py bindist,发布包的exe安装程序,比如mysqldb.....exe就是这个方式,简单,但是相对src方式要大些.

egg因为更加自动,越来越流行.

学习 sqlobject

发表人:1000copy | 发表时间: 2006年七月05日, 22:29

1. 安装activepython

2. 安装ez_install

3. 下载 mysqldb 然后测试

import MySQLdb 区别大小写，没有报错就是对的。

3. 下载 formencode.egg 然后 python easy_install formencode.egg

4. 下载 sqlobject.egg 然后 python easy_install sqlobject.egg

import sqlobject 区别大小写，没有报错就是对的。

查看全文

1000copy@gmail.com

博客导航

博客日历

最新发表