使用python嵌入和扩展python（python2和python3）摘要:

常用于服务器编程python脚本技术。Python它是最受欢迎的脚本之一python有很好的定义C API界面，同时有丰富的文档C  组合非常合适。通常使用C  使用封装机制python脚本实现策略或控制。python和C  结合技术具有以下优点：

使用主体系统C  实现并保持系统高效。控制部件的使用python，提高开发效率，python丰富的内存垃圾回收和类库使C  开发者受益匪浅。Python脚本可以在运行期重载，控制部分可以不断更新。

python当使用时，编程范式非常不同python C API调用python时，python中间的一些特殊机制会给出C  开发者带来了很多困惑。python C API注意以下几点：

Python 使用引用计数管理内存python C API需要根据文件仔细确认返回值要根据文件仔细确认。否则会出现内存泄漏，程序会崩溃。Python数据结构和C  差别很大。Python常用的有tuple，list，dict。而c  常用的事vector，list， ** p，并且c  强类型。当c  与python互动时，C  层希望操作python数据结构就像操作c   STL同样方便，而在python脚本层，希望c  传入的参数或返回值均为原生python数据C  嵌入常用指针传输对象时python时，需要把c  对象传递到python中。 ffpython是专门方便C  嵌入python基于开发的类库ffpython一方面可以轻松的将就python集成到C  另一方面，系统，C  对象或接口也可以很容易受python使用，总之ffpython简化了c  与python交互操作。嵌入python

使用最简单python的方式是把python以脚本为配置，如获取脚本中的字符串变量。Python脚本文件将被接受python虚拟机import为module，和python的标准库的module实际上是相似的概念。ffpython封装了获取python module操作中的变量。

printf("sys.version=%s

", ffpython.get_global_var("sys", "version").c_str());

获取上述代码python标准库中sys的version变量值，ffpython自动通过模板函数python的str自动适配类型c  的string类型。get_global_var设置变量的借口是获取变量的接口get_global_var：

ffpython.get_global_var("fftest", "global_var", "OhNice");

printf("fftest.global_var=%s

", ffpython.get_global_var("fftest", "global_var").c_str());

调用python函数是嵌入python操作非常常用，ffpython中提供了call调用接口python中的module的函数：

printf("time.asctime=%s

", ffpython.call("time", "asctime").c_str());

调用上述代码time模块的asctime我们也可以使用方法call接口调用我们自己编写的函数：

int a1 = 100; float a2 = 3.14f; string a3 = "OhWell";

ffpython.call("fftest", "test_base", a1, a2, a3);

Call被定义为模板函数，输入的参数将自动适应python相应类型。相应的python函数为：

def test_base(a1, a2, a3):

print('test_base', a1, a2, a3)

return 0

上面的python函数接受三个参数，c  实际上，三种标准类型的参数被引入了call接口最多支持9个泛参数，常用stl 支持参数：

void test_stl(ffpython_t& ffpython)

{

vectora1;a1.push_back(100);a1.push_back(200);

lista2; a2.push_back("Oh");a2.push_back("Nice");

vector<list> a3;a3.push_back(a2);

ffpython.call("fftest", "test_stl", a1, a2, a3);

}

对应调用的python函数为：

def test_stl(a1, a2, a3):

print('test_stl', a1, a2, a3)

return True

不但STL支持泛型，类似于嵌套定义vector > 支持结构，vector和list都会转换成python的list结构，而 ** p则转换为dict结构。

调用call接收的返回值类型必须指定，可以使用void除了使用标准类型外，忽略返回值，stl也可以使用接口，python中的tuple和list可以转换成vector和list，dict可转换成 ** p。需要注意的是，如果类型不匹配，call函数会抛出异常。用户可以catch标准异常，what接口返回的字符串包含异常traceback方便信息排查错误。示例如下：

try{

...

}

catch(exception& e)

{

printf("exception traceback %s

", e.what());

}扩展python

ffpython 可以注册static函数到python中球C风格static定义函数和类别static函数可以注册python示例如下：

static int print_val(int a1, float a2, const string& a3, const vector& a4)

{

printf("%s[%d,%f,%s,%d]

", __FUNCTION__, a1, a2, a3.c_str(), a4.size());

return 0;

}

struct ops_t

{

static listreturn_stl()

{

listret;ret.push_back(1024);

printf("%s

", __FUNCTION__);

return ret;

}

};

std::string test_reg_function(ffpython_t& ffpython)

{

ffpython.reg(&print_val, "print_val")

.reg(&ops_t::return_stl, "return_stl");

ffpython.reg_class("foo_t")

.reg(&foo_t::get_value, "get_value")

.reg(&foo_t::set_value, "set_value")

.reg(&foo_t::test_stl, "test_stl")

.reg_property(&foo_t::m_value, "m_value");

ffpython.reg_class("dumy_t", "dumy_t class inherit foo_t ctor", "foo_t")

.reg(&dumy_t::dump, "dump");

ffpython.reg(obj_test, "obj_test");

return "cppext";

}

上述代码注册了两个接口python，然后调用fftest文件中的test_reg_function测试两个接口，fftest.py测试代码中定义：

def test_reg_function():

import ext1

ext1.print_val(123, 45.6 , "----789---", [3.14])

ret = ext1.return_stl()

print('test_reg_function', ret)

虽然这两个虽然简单，但说明了ffpython注册界面支持多个参数，参数类型可以是标准C  类型，也可以STL泛型。返回值的类型也是如此。

使用ffpython 注册C  对象也很容易，ffpython支持注册c  构造函数、成员变量、成员方法python，示例代码如下：

class foo_t

{

public:

foo_t(int v_):m_value(v_)

{

printf("%s

", __FUNCTION__);

}

virtual ~foo_t()

{

printf("%s

", __FUNCTION__);

}

int get_value() const { return m_value; }

void set_value(int v_) { m_value = v_; }

void test_stl( ** p<string, list>& v_)

{

printf("%s

", __FUNCTION__);

}

int m_value;

};

class dumy_t: public foo_t

{

public:

dumy_t(int v_):foo_t(v_)

{

printf("%s

", __FUNCTION__);

}

~dumy_t()

{

printf("%s

", __FUNCTION__);

}

void dump()

{

printf("%s

", __FUNCTION__);

}

};

static foo_t* obj_test(dumy_t* p)

{

printf("%s

", __FUNCTION__);

return p;

}

当c++类型被注册到python中后，python中使用该类型就像python内建的类型一样方便，需要注意的是，如果python中动态的创建了c++对象，那么他是被python的GC管理生命周期的，所以当变量不在被引用时，c++对象的析构函数被调用。对应的fftest.py中测试的脚本代码为：

def test_register_base_class():

import ext2

foo = ext2.foo_t(20130426)

print("test_register_base_class get_val:", foo.get_value())

foo.set_value(778899)

print("test_register_base_class get_val:", foo.get_value(), foo.m_value)

foo.test_stl({"key": [11,22,33] })

print('test_register_base_class test_register_base_class', foo)

同前边所诉的原则相同，支持C++ 标准内建类型和STL 泛型。当这个python函数返回时，foo_t的析构函数会被调用。

dumy_t是foo_t的子类。使用ffpython可以方便表示两个类型的关系。如果基类已经定义的接口，子类不需要重复定义，比如要注册子类：

ffpython.reg_class("dumy_t", "dumy_t class inherit foo_t ctor", "foo_t")

.reg(&dumy_t::dump, "dump");

void test_register_inherit_class(ffpython_t& ffpython)

{

ffpython.call("fftest", "test_register_inherit_class");

};

只需要单独注册一下子类特有的接口，其他接口自动从foo_t基类中继承而来，相应的测试python脚本代码为：

def test_register_inherit_class():

import ext2

dumy = ext2.dumy_t(20130426)

print("test_register_inherit_class get_val:", dumy.get_value())

dumy.set_value(778899)

print("test_register_inherit_class get_val:", dumy.get_value(), dumy.m_value)

dumy.test_stl({"key": [11,22,33] })

dumy.dump()

print('test_register_inherit_class', dumy)

ffpython中一个非常用用的特性是，c++创建的对象可以传递到python中，而python使用起来就像正常的python对象一样，另外python创建的c++对象也可以传递到c++中，简单示例代码：

ffpython.reg(obj_test, "obj_test");

void test_cpp_obj_to_py(ffpython_t& ffpython)

{

foo_t tmp_foo(2013);

ffpython.call("fftest", "test_cpp_obj_to_py", &tmp_foo);

}

void test_cpp_obj_py_obj(ffpython_t& ffpython)

{

dumy_t tmp_foo(2013);

foo_t* p = ffpython.call("fftest", "test_cpp_obj_py_obj", &tmp_foo);

}

相应的fftest.py中的测试脚本代码为：

def test_cpp_obj_to_py(foo):

import ext2

print("test_cpp_obj_to_py get_val:", foo.get_value())

foo.set_value(778899)

print("test_cpp_obj_to_py get_val:", foo.get_value(), foo.m_value)

foo.test_stl({"key": [11,22,33] })

print('test_cpp_obj_to_py test_register_base_class', foo)

def test_cpp_obj_py_obj(dumy):

import ext2

print("test_cpp_obj_py_obj get_val:", dumy.get_value())

dumy.set_value(778899)

print("test_cpp_obj_py_obj get_val:", dumy.get_value(), dumy.m_value)

dumy.test_stl({"key": [11,22,33] })

dumy.dump()

ext2.obj_test(dumy)

print('test_cpp_obj_py_obj', dumy)

return dumy

总结：ffpython 支持c++调用python函数，获取和设置模块内的变量ffpython call接口最多支持9个泛型参数，支持的类型包括c++内建的类型和STL 泛型。以及已经被注册的c++类的指针类型。返回值的类型约束同样如此。c++ STL中的vector和list对应于python的tuple和list， ** p类型则对应于dict。ffpython支持将c++的静态函数注册到python中。ffpython支持c++类的注册，并且支持继承。Python中操作c++对象就像操作原生python对象一样。ffpython注册的c++类在python中被创建后，将会由python GC负责回收内存。ffpython 类库只有一个文件，并且不依赖其他第三方库，非常容易集成到项目中。而且ffpython遵从开源协议。ffpython使用c++模板技术，封装了python C API的使用细节，保持精巧和简洁，效率和完全的python C API编写的代码几乎相同。ffpython的实现可以作为非常好的python C API的示例。Github项目地址：https://github.com/fanchy/ffpython  更多文章 http://h2cloud.org