boost.python入门教程 ----python 嵌入c++
Python语言简介
Python是一种脚本语言。以开放的开发接口和独特的语法著称。尽管Python在国内引起注意只有几年的时间，但实际上Python出现于上世纪90年代（据www.python.org介绍，这个时间可以上溯至1990年），已经有十几年的时间，它的流行也有很久，在嵌入脚本、互联网应用、系统管理和维护等领域，Python使用的非常广泛。
Python的语法与我们常见的C系语法有很大不同，对于Python，书写格式也是语法的部分。主要表现在，每一个子语句段都要比它的父级缩进一层。例如：
- >>> a, b = 0, 1
- >>> while b < 1000:
- ... print b,
- ... a, b = b, a+b
- ...
以上是一段求Fibonacci数列的程序，>>>和…都是Python控制台的交互提示符。我们可以看到，while循环的循环体不是通过括号或者end之类的关键字标示，而是用缩进与上一级区分开。在Python中，每级代码之间的缩进距离不做要求，但是在同一个文件中必须保持一致，最常见的写法是缩进四个空格。
理解这一点后，Python代码的可读性非常高。在强制性的书写规范下，更容易写出规范的代码。
Python支持通用的各种语法结构，包括if、while/for循环、函数、类、异常处理以及模块（module）和包（Package）。以下是一些常见的语法示例：
（展示Python代码）
时间所限，我们不可能在这里详细了解Python语言，对于交互式开发人员，有几点值得注意，在这里简单介绍下：
Python采用命名—对象实体机制。任何Python中的元素都可以看作是一种对象。包括所有的数据类型和定义。对变量的定义和赋值，实际上是将一个命名绑定到托管环境中的一个对象上。这个过程不涉及对象本身的运算，也不进行类型检查，所以在程序运行过程中可以任意对某个命名赋值并改变其类型。
Python对象在运行期可以动态的添加和删除成员，不受类型限制（当然，也可以设计出静态类型的数据结构）。
Python支持运算符重载。
Python C API
Python虚拟机开放了大量的API，几乎所有的语法内容，和虚拟机功能，都可以通过C-API从外部调用实现。加上整个虚拟机开放源码，用C语言操作Python虚拟机非常方便，从某种意义上说，Python可以作为一个C语言的运行时环境存在。同时，C语言也可以作为Python的底层扩展使用。
Python C API的引用头文件是python.h，在Python安装目录的include子目录可以找到。静态连接库pythonxx.lib（xx=主版本号+一级子版本号，如python2.4对应python24.lib）在libs目录下。
扩展Python系统
扩展Python，即编写可供Python加载的模块，由Python程序进行调用。简单来讲，主要有以下几个步骤：
编写符合Python封装约定的函数和结构定义。对于函数而言，要求参数均为PyObject*
或其“子”类型。当然，C语言中没有这样的语法，这个继承关系是Python语法意义的。而对于自定义的对象，Python有一套完备的约定，我们在Python的文档中可以看到若干示例。（展示代码）。
对于需要开放的函数，要编写方法定义表，这是一个UNION，按照固定格式填写数据。（展示代码）。对于类型对象，则是通过PyModule_AddObject方法引入。
要引入函数定义的话，还需要执行模块初始化函数。
将项目编译为动态链接库，放在Python的DLLs路径即可。
嵌入Python解释器
在C程序中嵌入Python解释器并不复杂，基本的流程如下：
调用Py_Initialize()函数，初始化虚拟机。
编写操作虚拟机的命令。
调用Py_Finalize()函数释放虚拟机资源。
Python虚拟机提供了丰富的API以供操作，基本上用Python脚本可以实现的功能，通过API都可以实现。当然通常不会完全使用API，而是以API和内嵌脚本结合使用，在Python文档中提供了一个简单的例子，演示了常用的模块和对象引入、执行可回调对象，变量提取等功能（展示代码）。
综合技术——扩展式嵌入
我们可以将Python虚拟机嵌入C/C++程序的同时，通过扩展代码，将我们需要的内容引入Python虚拟机，这样，就可以在虚拟机中通过Python脚本访问C++环境中提供的扩展内容，在掌握了扩展和嵌入技术后，这个应用十分自然和简便，在Python文档中，有一个实例说明了这中应用方式。（展示代码）
Boost.Python
Python虚拟机本身以标准C编写，它的API也均为C型式，直接应用在C++程序中略有不便。通常我们会使用一些第三方的程序库来实现，这里重点介绍BOOST.Python的使用。
Boost是一个久负盛名的C++代码库，关于它的具体情况在网上有很多介绍，具体到BOOST.Python，这是BOOST开发组专门为C++/Python直接的互操作而开发的类库，也是Boost中唯一一个解释语言支持模块。Boost.Python除了提供Python C API的C++兼容封装，也使得整个扩展/嵌入过程更加方便。
BOOST的预编译
BOOST中的部分模块需要预编译才能使用，Boost.Python也在此列。在Boost的文档中，有详细的编译方式说明，具体到我们使用的VC6/7.1，windows 2000+，Python2.4，编译过程可以简化为以下几步：
1、 生成Boost编译工具BJam。这个工具的源码在Boost目录的tools/build/jam_src 目录下，正常情况下，直接执行build.bat即可生成。执行完毕后，到bin.ntx86子目录找到bjam.exe文件，复制到Boost根目录即可。
2、 配置编译环境，编译Boost时，要提供编译器种类和路径，子模块还可能有自己的配置要求，如Python子模块要求提供Python的目录和版本号。
3、 执行Bjam。此时要向Bjam提供使用的编译器种类，以及附带的编译参数。
4、 以下是我编译Boost使用的bat文件，大家需要编译Boost的话，可以将其中的VC和Python路径改为本机路径，即可使用。
|
bjam_vc71.bat |
|
set PYTHON_ROOT=D:/Python24 set vc-7_1=D:/Microsoft Visual Studio .NET 2003/Vc7 set ICU_PATH=D:/icu3.4 set VC71_ROOT=D:/Microsoft Visual Studio .NET 2003/Vc7 bjam -sTOOLS=vc-7_1 -sICU_PATH=D:/icu3.4 stage |
|
bjam_vc60.bat |
|
set PYTHON_ROOT=D:/Python24 set ICU_PATH=D:/icu3.4 set MSVC_ROOT=D:/Microsoft Visual Studio/VC98 bjam -sTOOLS=msvc -sICU_PATH=D:/icu3.4 stage |
这里的ICU是一个国际化代码库，Boost使用这个第三方代码库为自己的正则表达式模块提供Unicode支持，如果只使用Python模块，可以去掉这方面的配置。
Stage参数指示编译工具将生成的lib文件统一放置于stage子目录。
Boost.Python的引用头文件是<boost/python.hpp>，命名空间是boost::python。
扩展Python系统
首先，对于Python基于对象的体系结构，Boost提供了一组封装对象给予支持。这其中除了基本的PyObject（Boost中封装为Boost::Python::object） 对象，还包括了序列容器组。Boost.Python文档的“Obejct Wrapper”部分（/libs/python/doc/v2/ObjectWrapper.html#ObjectWrapper-concept）对此有详细讲解。如果我们的扩展代码中需要调用这些对象，可以直接引用。
另一方面，对于函数和对象封装，Boost提供了一套更为友好的方式。例如，如果在函数声明的参数列表中出现可以与Python类型直接对应的char *、int、float等，不需要手动进行与PyOjbect*的转化，Boost可以识别这些类型。
下面我们看一个简单的函数封装示例：
首先，在VC中建立一个空的DLL项目，然后定义函数：
|
Cppcode.h |
|
#include <string>
int Add(int, int);
int Sub(int, int);
std::string Concat(std::string, std::string);
|
|
Cppcode.cpp |
|
#include "CppCode.h"
int Add(int x, int y) { return x + y; }
int Sub(int x, int y) { return x - y; }
std::string Concat(std::string x, std::string y) { return x + y; }
|
然后编写封装代码：
|
Wrapper.cpp |
|
#include <boost/python.hpp> #include "CppCode.h"
using namespace boost::python;
BOOST_PYTHON_MODULE(FunTest) { def("Add", Add); def("Sub", Sub); def("Concat", Concat); }
|
编译生成DLL文件（需要注意的是生成的文件名必须与BOOST_PYTHON_MOUDLE宏的参数一致），放在Python/DLLs目录下即可。（演示）
由于Python使用动态类型，对于Python代码，函数重载没有语法依据（但是可以定义默认参数值和动态参数列表）。但我们在C++代码中可能会需要重载多个函数定义，Boost.Python对此也有支持。（展示代码）
下面我们再看一个C++类型的封装代码：
|
Wrapper.cpp |
|
/////////////////////////////////////////////////////////// //MultiBoolean类的Python封装，使用boost::python技术 //作者：刘鑫 ///////////////////////////////////////////////////////////
//引用boost库 #include <boost/python.hpp> //引用多值逻辑定义 #include "MultiBoolean.h" //引用与或运算的Python封装接口 #include "pyMultiBoolean.h"
//引用相关的命名空间
using namespace boost::python;
using namespace MarchLibrary;
//模块定义 BOOST_PYTHON_MODULE(MarchLibrary) { //类封装，这里用no_init表示没有可用的构造函数 class_<MultiBoolean>("MultiBoolean", no_init) //可选的逻辑值接口 .def_readonly("True", &MultiBoolean::True) .def_readonly("False", &MultiBoolean::False) .def_readonly("Unknown", &MultiBoolean::Unknown) .def_readonly("Undefine", &MultiBoolean::Undefine) .def_readonly("Nil", &MultiBoolean::Nil)
//兼容C++版定义的字符串处理接口 .def("ToString", &MultiBoolean::ToString) .def("FullName", &MultiBoolean::FullName) .def("Parse", &MultiBoolean::Parse)
//逻辑值判定 .def("IsTrue", &MultiBoolean::IsTrue) .def("IsFalse", &MultiBoolean::IsFalse) .def("IsUnknown", &MultiBoolean::IsUnknown) .def("IsUndefine", &MultiBoolean::IsUndefine) .def("IsNil", &MultiBoolean::IsNil)
//运算符重载接口 .def(!self) .def(self &= self) .def(self &= bool()) .def(self |= self) .def(self |= bool()) .def(self ^= self) .def(self ^= bool()) .def(self == self) .def(self == bool()) .def(bool() == self) .def(self != self) .def(self != bool()) .def(bool() != self) .def(self & self) .def(self & bool()) .def(bool() & self) .def(self | self) .def(self | bool()) .def(bool() | self) .def(self ^ self) .def(self ^ bool()) .def(bool() ^ self)
//提供给Python解释器的标准字符串输出接口 .def("__str__", &MultiBoolean::ToString) .def("__repr__", &MultiBoolean::FullName) ; } |
MultiBoolean本身是一个多值逻辑类型，它的实现比较长，就不在这里放出了。（直接在IDE展示）这里主要给大家演示下class封装的基本功能，包括方法、属性和运算符重载。
下面我们讨论下继承的封装。我们知道C语言没有虚函数的概念，而Python的方法默认都是虚方法。为了实现这一功能，Python API中运用了一些复杂的方法。在Boost中，这个过程被尽可能的封装起来，向自然的C++代码靠拢。
|
VirtualTest.h |
|
#include <boost/python.hpp>
using namespace boost::python;
//Override struct Base { virtual ~Base(){}; virtual char const* Hello() { return "Hello. I'm Base."; }; };
struct Derived : Base { char const* Hello() { return "Hello. I'm Derived."; }; };
struct BaseWrapper : Base, wrapper<Base> { char const* Hello() { if (override Hello = this->get_override("Hello")) #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // Workaround for vc6/vc7 return call<char *>(Hello.ptr()); #else return Hello(); #endif return Base::Hello(); }
char const* default_Hello() { return this->Base::Hello(); } };
|
|
Wrapper.cpp |
|
#include <boost/python.hpp> #include "ClassTest.h" #include "VirtualTest.h" #include <string>
using namespace boost::python;
BOOST_PYTHON_MODULE(ClassTest) { class_<Foo>("Foo") .def("Add", &Foo::Add) .def("Sub", &Foo::Sub) .def("Concat", &Foo::Concat) ;
class_<ConFoo>("ConFoo") .def(init<char *>()) .def("GetValue", &ConFoo::GetValue) .def("SetValue", &ConFoo::SetValue) ;
class_<BaseWrapper, boost::noncopyable>("Base") .def("Hello", &Base::Hello, &BaseWrapper::default_Hello) ;
class_<Derived>("Derived") .def("Hello", &Derived::Hello) ; }
|
这里我们要关注的是用于虚函数定义的辅助类BaseWrapper，以及BOOST_PYTHON_MODULE内部的封装代码。
以上两个示例也展示了构造函数的封装方法，包括禁用构造函数的用法。
嵌入Python解释器
最简单的Boost嵌入与Python C API并无任何不同，例如以下的代码：
|
#include "boost/python.hpp"
int main(int argc, char *argv[]) { Py_Initialize();
FILE * fp = fopen("test.py", "r");
if (fp == NULL) { return 1; }
PyRun_SimpleFile(fp, "test.py");
Py_Finalize();
return 0; } |
从以上可以看出，Boost沿用了C API的嵌入流程。但是，Boost在具体的虚拟机功能调用方面提供了完备的封装，以下这个示例展示了模块和对象引用，以及类型转换方面的使用。
|
#include <boost/python.hpp>
using namespace boost::python;
int main() { Py_Initialize();
object main_module(( handle<>(borrowed(PyImport_AddModule("__main__")))));
object main_namespace = main_module.attr("__dict__");
handle<> ignored((PyRun_String(
"hello = file('hello.txt', 'w')/n" "hello.write('Hello world!')/n" "hello.close()"
, Py_file_input , main_namespace.ptr() , main_namespace.ptr()) ));
Py_Finalize(); }
|
对于其他功能，例如方法调用、成员访问等，Boost也提供了相应的功能。下面我们看一下Boost文档中的示例。（展示文档）
综合技术——扩展式嵌入
和C API一样，在掌握了扩展和嵌入代码后，扩展式嵌入技术就成为一件水到渠成的事，下面这个简单的示例，利用前面提到的MultiBoolean，演示了最简单的扩展式嵌入。
|
#include <iostream> #include <cstdlib> #include <string> #include <boost/python.hpp>
#include "main.h"
using namespace boost::python;
int main() { std::string dictstr; Py_Initialize(); try { initMarchLibrary();
object main_module(( handle<>(borrowed(PyImport_AddModule("__main__")))));
object main_namespace = main_module.attr("__dict__");
PyRun_SimpleString("import MarchLibrary"); object result(( handle<>( PyRun_String( "str(dir(MarchLibrary))", Py_eval_input, main_namespace.ptr(), main_namespace.ptr())) ));
dictstr = extract<char *>(result); std::cout<<dictstr<<std::endl; } catch(error_already_set) { PyErr_Print(); }
std::system("Pause"); Py_Finalize(); return 0; }
|
注意引入MarchLibrary库的init函数，它于C API中使用的相同。程序运行时，我们可以看到dir函数打印出了该模块的内部成员，如同它是一个标准的Python内置模块。
