在C++軟件中嵌入python解釋器

時間 2019-11-06

原文原文鏈接

Python簡介

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腳本。)windows

提出問題 瀏覽器

在某個C++應用程序中，咱們用一組插件來實現一些具備統一接口的功能，咱們使用Python來代替動態連接庫形式的插件，這樣能夠方便地根據需求的變化改寫腳本代碼，而不是必須從新編譯連接二進制的動態連接庫。Python強大的功能足以勝任，可是有一些操做系統特定的功能須要用C++來實現，再由 Python調用。因此，最基礎地，咱們須要作到：網絡

1. 把Python嵌入到C++應用程序中，在C++程序中調用Python函數和得到變量的值；數據結構

2. 用C++爲Python編寫擴展模塊(動態連接庫)，在Python程序中調用C++開發的擴展功能函數。app

經常使用的Python/C API

下面是例子中用到的幾個Python/C API的簡要介紹及示例代碼。注意，這並非這些函數的詳細介紹，而僅僅是咱們所用到的功能簡介，更詳細內容請參考文檔[1]、[2]、[3]、[4]。編程語言

打開Microsoft Visual Studio .NET 2003，新建一個控制檯程序，#include ，並在main函數里加入示例代碼。函數

//先定義一些變量
char *cstr;2.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);

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)

此函數有兩個參數，都指向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());

接下來，咱們來用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);
}

在Python代碼中調用這個動態連接庫：

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

用C++爲Python寫擴展時，若是您願意使用Boost.Python庫的話，開發過程會變得更開心，要編寫一個與上述pyUtil一樣功能的動態連接庫，只需把文件內容替換爲下面的代碼。固然，編譯須要boost_python.lib支持，運行須要boost_python.dll支持。

01.#include< string >
02.#include < boost/python.hpp >
03.using namespace boost::python;
04.#pragma comment(lib, "boost_python.lib")
05.std::string strtmp;
06.char const* Recognise(const char* url)
07.{
08.strtmp ="從dll中返回的數據... : ";
09.strtmp+=url;
10.return strtmp.c_str();
11.}
12.BOOST_PYTHON_MODULE(pyUtil)
13.{
14.def("Recognise", Recognise);
15.}

全部示例都在Microsoft Windows XP Professional + Microsoft Visual Studio .NET 2003 + Python2.4環境下測試經過，本文所用的Boost庫爲1.33版本。

附1 text.txt

附1 text.txt
this is test text in text.txt.

附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

#附3 simplepy.h
#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