C++扩展和嵌入Python

副标题#e#

Python简介

Python是一种简朴易学，成果强大的表明型编程语言，它有简捷明白的语法，高效率的高层数据布局，可以或许简朴而有效地实现面向工具编程，出格合用于快速应用措施开拓，也可以用来开拓大局限的重要的贸易应用。Python是一个抱负的剧本语言。

Python免费开源，可移植到多种操纵系统，只要制止利用依赖于特定操纵系统的特性，Python措施无需修改就可以在各类平台上面运行。

Python拥有现代编程语言所具有的一切强大成果，Python尺度库十分复杂，可以辅佐开拓者处理惩罚各类事情，如：图形用户界面、文件处理惩罚、多媒体、正则表达式、文档生成、单位测试、线程、数据库、网络通讯、网页欣赏器、CGI、FTP、电子邮件、XML、HTML、WAV文件、暗码系统、Tk和其他与系统有关的操纵。只要安装了Python，这些成果都是可用的除了尺度库以外，尚有很多其他高质量的库，如wxPython、Twisted和Python图形库等等数不胜数。

Python容易扩展和嵌入。Python提供的很多尺度模块支持C可能C++接口。Python和C可以一起事情，它可以嵌入到C可能C++的应用措施傍边，因此可用Python语言为应用措施提供剧本接口，由于支持跨语言开拓，可用Python设计观念化应用措施，并慢慢移植到C，利用前不必用C重写应用措施。(Jython使Python可以和Java一起事情，使开拓者可以在Python内里调Java的包，也可以在Java内里利用Python的工具。尚有更妙的,由于Jython的表明器完全用Java编写，因此可以在支持Java的任何平台上陈设Python措施，甚至WEB欣赏器也可以直接运行Python剧本。)

提出问题

在某个C++应用措施中，我们用一组插件来实现一些具有统一接口的成果，我们利用Python来取代动态链接库形式的插件，这样可以利便地按照需求的变革改写剧本代码，而不是必需从头编译链接二进制的动态链接库。Python强大的成果足以胜任，可是有一些操纵系统特定的成果需要用C++来实现，再由Python挪用。所以，最基内地，我们需要做到：

1. 把Python嵌入到C++应用措施中，在C++措施中挪用Python函数和得到变量的值；

2. 用C++为Python编写扩展模块(动态链接库)，在Python措施中挪用C++开拓的扩展成果函数。

常用的Python/C API先容

下面是例子顶用到的几个Python/C API的扼要先容及示例代码。留意，这并不是这些函数的具体先容，而仅仅是我们所用到的成果简介，更具体内容请参考文档[1]、[2]、[3]、[4]。

打开Microsoft Visual Studio .NET 2003，新建一个节制台措施，#include <Python.h>，并在main函数里插手示例代码。

//先界说一些变量
char *cstr;
PyObject *pstr, *pmod, *pdict;
PyObject *pfunc, *pargs;
1. void Py_Initialize( )

初始化Python表明器，在C++措施中利用其它Python/C API之前，必需挪用此函数，假如挪用失败，将发生一个致命的错误。例：

Py_Initialize();

2. int PyRun_SimpleString( const char *command)

执行一段Python代码，就好象是在__main__ 函数内里执行一样。例：

PyRun_SimpleString("from time import time,ctime\n"
"print ''Today is'',ctime(time())\n");

3. PyObject* PyImport_ImportModule( char *name)

导入一个Python模块，参数name可以是*.py文件的文件名。相当于Python内建函数__import__()。例：

pmod = PyImport_ImportModule("mymod"); //mymod.py

4. PyObject* PyModule_GetDict( PyObject *module)

相当于Python模块工具的__dict__ 属性，获得模块名称空间下的字典工具。例：

pdict = PyModule_GetDict(pmod);

#p#副标题#e#

5. PyObject* PyRun_String( const char *str, int start, PyObject *globals, PyObject *locals)

执行一段Python代码。

pstr = PyRun_String("message", Py_eval_input, pdict, pdict);

6. int PyArg_Parse( PyObject *args, char *format, …)

解构Python数据为C的范例，这样C措施中才可以利用Python里的数据。例：

/* convert to C and print it*/
PyArg_Parse(pstr, "s", &cstr);
printf("%s\n", cstr);

7. PyObject* PyObject_GetAttrString( PyObject *o, char *attr_name)

返回模块工具o中的attr_name 属性或函数，相当于Python中表达式语句：o.attr_name。例：

/* to call mymod.transform(mymod.message) */
pfunc = PyObject_GetAttrString(pmod, "transform");

8. PyObject* Py_BuildValue( char *format, …)

构建一个参数列表，把C范例转换为Python工具，使Python可以利用C范例数据，例：

cstr="this is hjs''s test, to uppercase";
pargs = Py_BuildValue("(s)", cstr);

9. PyEval_CallObject(PyObject* pfunc, PyObject* pargs)

#p#分页标题#e#

此函数有两个参数，都指向Python工具指针，pfunc是要挪用的Python 函数，凡是可用PyObject_GetAttrString()得到；pargs是函数的参数列表，凡是可用Py_BuildValue()构建。例：

pstr = PyEval_CallObject(pfunc, pargs);
PyArg_Parse(pstr, "s", &cstr);
printf("%s\n", cstr);

10. void Py_Finalize( )

封锁Python表明器，释放表明器所占用的资源。例：

Py_Finalize();

Python2.4情况没有提供调试版本的Python24d.lib，所以上述示例在release模式下编译。编译完成后，把可行文件和附2给出的mymod.py文件放在一起，再点击即可运行。为了简化编程，附3 给出了simplepy.h。这样，挪用mymod.transform酿成如下形式：

//#include”simplepy.h”
CSimplepy py;
py.ImportModule("mymod");
std::string str=py.CallObject("transform",
"this is hjs''s test, to uppercase");
printf("%s\n", str.c_str());

#p#副标题#e#

接下来，我们来用C++为Python编写扩展模块(动态链接库)，并在Python措施中挪用C++开拓的扩展成果函数。生成一个取名为pyUtil的Win32 DLL工程，除了pyUtil.cpp文件以外，从工程中移除所有其它文件，并填入如下的代码：

// pyUtil.cpp
#ifdef PYUTIL_EXPORTS
#define PYUTIL_API __declspec(dllexport)
#else
#define PYUTIL_API __declspec(dllimport)
#endif
#include<windows.h>
#include<string>
#include<Python.h>
BOOL APIENTRY DllMain( HANDLE hModule,
　　　　　　　　　　　 DWORD　ul_reason_for_call,
　　　　　　　　　　　 LPVOID lpReserved
　　　　　　　　　　?)
{
　　switch (ul_reason_for_call)
　　{
　　case DLL_PROCESS_ATTACH:
　　case DLL_THREAD_ATTACH:
　　case DLL_THREAD_DETACH:
　　case DLL_PROCESS_DETACH:
　　　　break;
　　}
　　return TRUE;
}
std::string Recognise_Img(const std::string url)
{
　　//返回功效
　　return "从dll中返回的数据... : " +url;
}
static PyObject* Recognise(PyObject *self, PyObject *args)
{
　　const char *url;
　　std::string sts;
　　if (!PyArg_ParseTuple(args, "s", &url))
　　　　return NULL;
　　sts = Recognise_Img(url);
　　return Py_BuildValue("s", sts.c_str() );
}
static PyMethodDef AllMyMethods[] = {
　　{"Recognise",　Recognise, METH_VARARGS},//袒露给Python的函数
　　{NULL,　　　NULL}　　　　/* Sentinel */
};
extern "C" PYUTIL_API void initpyUtil()
{
　　PyObject *m, *d;
　　m = Py_InitModule("pyUtil", AllMyMethods); //初始化本模块，并袒露函数
　　d = PyModule_GetDict(m);
}

#p#副标题#e#

在Python代码中挪用这个动态链接库：

import pyUtil
result = pyUtil.Recognise("input url of specific data")
print "the result is: "+ result

用C++为Python写扩展时，假如您愿意利用Boost.Python库的话，开拓进程会变得更开心J，要编写一个与上述pyUtil同样成果的动态链接库，只需把文件内容替换为下面的代码。虽然，编译需要boost_python.lib支持，运行需要boost_python.dll支持。

#include<string>
#include <boost/python.hpp>
using namespace boost::python;
#pragma comment(lib, "boost_python.lib")
std::string strtmp;
char const* Recognise(const char* url)
{
　　strtmp ="从dll中返回的数据... : ";
　　strtmp+=url;
　　return strtmp.c_str();
}
BOOST_PYTHON_MODULE(pyUtil)
{
　　def("Recognise", Recognise);
}

所有示例都在Microsoft Windows XP Professional + Microsoft Visual Studio .NET 2003 + Python2.4情况下测试通过，本文所用的Boost库为1.33版本。

参考资料

[1] Python Documentation Release 2.4.1. 2005.3.30，假如您以默认方法安装了Python2.4，那么该文档的位置在C:\Program Files\Python24\Doc\Python24.chm；

[2] Michael Dawson. Python Programming for the Absolute Beginner. Premier Press. 2003；

[3] Mark Lutz. Programming Python, 2nd Edition. O”Reilly. 2001.3 ；

[4] Mark Hammond, Andy Robinson. Python Programming on Win32. O”Reilly. 2000.1 ；

Python主页：http://www.python.org；

Boost库主面：www.boost.org；

附1 text.txt

this is test text in text.txt.

#p#副标题#e#

附2 mymod.py

import string
message = ''original string''
message =message+message
msg_error=""
try:
　　　 text_file = open("text.txt", "r")
　　　 whole_thing = text_file.read()
　　　 print whole_thing
　　　 text_file.close()
except IOError, (errno, strerror):
　　　 print "I/O error(%s): %s" % (errno, strerror)
def transform(input):
　　#input = string.replace(input, ''life'', ''Python'')
　　return string.upper(input)
def change_msg(nul):　
　　global message #假如没有此行，message是函数里头的局部变量
　　message=''string changed''
　　return message
def r_file(nul):
　　return whole_thing
def get_msg(nul):
return message

附3 simplepy.h

#p#分页标题#e#

#ifndef _SIMPLEPY_H_
#define _SIMPLEPY_H_
// simplepy.h v1.0
// Purpose: facilities for Embedded Python.
// by hujinshan @2005年9月2日9:13:02
#include
using std::string;
#include
//--------------------------------------------------------------------
// Purpose: ease the job to embed Python into C++ applications
// by hujinshan @2005年9月2日9:13:18
//--------------------------------------------------------------------
class CSimplepy // : private noncopyable
{
public:
　　///constructor
　　CSimplepy()
　　{
　　　　Py_Initialize();
　　　　pstr=NULL, pmod=NULL, pdict=NULL;
　　　　pfunc=NULL, pargs=NULL;
　　}
　　///destructor
　　virtual ~CSimplepy()　　
　　{　
　　　　Py_Finalize();
　　}
　　///import the user module
　　bool ImportModule(const char* mod_name)
　　{
　　　　try{
　　　　　　pmod　= PyImport_ImportModule(const_cast(mod_name));
　　　　　　if(pmod==NULL)
　　　　　　　　return false;
　　　　　　pdict = PyModule_GetDict(pmod);
　　　　}
　　　　catch(...)
　　　　{
　　　　　　return false;
　　　　}
　　　　if(pmod!=NULL && pdict!=NULL)
　　　　　　return true;
　　　　else
　　　　　　return false;
　　}
　　///Executes the Python source code from command in the __main__ module.
　　///If __main__ does not already exist, it is created.
　　///Returns 0 on success or -1 if an exception was raised.
　　///If there was an error, there is no way to get the exception information.
　　int Run_SimpleString(const char* str)
　　{
　　　　return PyRun_SimpleString(const_cast(str) );
　　}
　　///PyRun_String("message", Py_eval_input, pdict, pdict);
　　///Execute Python source code from str in the context specified by the dictionaries globals.
　　///The parameter start specifies the start token that should be used to parse the source code.
　　///Returns the result of executing the code as a Python object, or NULL if an exception was raised.
　　string Run_String(const char* str)
　　{
　　　　char *cstr;
　　　　pstr　= PyRun_String(str, Py_eval_input, pdict, pdict);
　　　　if(pstr==NULL)
　　　　　　throw ("when Run_String, there is an exception was raised by Python environment.");
　　　　PyArg_Parse(pstr, "s", &cstr);
　　　　return string(cstr);
　　}
　　///support olny one parameter for python function, I think it''s just enough.
　　string CallObject(const char* func_name, const char* parameter)
　　{
　　　　pfunc=NULL;
　　　　pfunc = PyObject_GetAttrString(pmod, const_cast(func_name));
　　　　if(pfunc==NULL)
　　　　　　throw (string("do not found in Python module for: ")
+func_name).c_str();
　　　　char* cstr;
　　　　pargs = Py_BuildValue("(s)", const_cast(parameter));
　　　　pstr　= PyEval_CallObject(pfunc, pargs);
　　　　if(pstr==NULL)
　　　　　　throw ("when PyEval_CallObject, there is an exception was raised by Python environment");
　　　　PyArg_Parse(pstr, "s", &cstr);
　　　　return string(cstr);
　　}
　　//PyObject *args;
　　//args = Py_BuildValue("(si)", label, count);　 /* make arg-list */
　　//pres = PyEval_CallObject(Handler, args);
protected:
　　PyObject *pstr, *pmod, *pdict;
　　PyObject *pfunc, *pargs;
};
#endif // _SIMPLEPY_H_
// end of file