摘要

Boost.Python 是一个开源 C++ 库，它为将 C++ 类和函数绑定到 Python 提供了简洁的类 IDL 接口。它充分利用了 C++ 编译时内省的全部功能和最新开发出的元编程技术，完全使用纯 C++ 实现，无需引入新的语法。Boost.Python 丰富的功能集和高级接口使得从头开始将软件包设计为混合系统成为可能，从而使程序员能够轻松且一致地访问 C++ 高效的编译时多态性和 Python 极其方便的运行时多态性。

简介

Python 和 C++ 在许多方面都截然不同：C++ 通常被编译为机器代码，而 Python 是解释执行的。Python 的动态类型系统通常被认为是其灵活性的基础，而 C++ 中的静态类型是其效率的基石。C++ 具有复杂且困难的编译时元语言，而在 Python 中，几乎所有事情都发生在运行时。

然而，对于许多程序员来说，这些差异恰恰意味着 Python 和 C++ 可以完美地互补。Python 程序中的性能瓶颈可以用 C++ 重写以获得最大速度，而强大的 C++ 库的作者选择 Python 作为中间件语言，因为它具有灵活的系统集成能力。此外，表面上的差异掩盖了一些强大的相似之处

• 'C' 系列控制结构 (if, while, for...)
• 支持面向对象、函数式编程和泛型编程（它们都是 *多范式* 编程语言。）
• 全面的运算符重载功能，认识到语法可变性对于可读性和表达性的重要性。
• 高级概念，例如集合和迭代器。
• 高级封装功能（C++：命名空间，Python：模块），以支持可重用库的设计。
• 异常处理，用于有效管理错误情况。
• 常用的 C++ 习惯用法，例如 handle/body 类和引用计数智能指针，反映了 Python 的引用语义。

鉴于 Python 丰富的 'C' 互操作性 API，原则上应该可以将 C++ 类型和函数接口暴露给 Python，并具有类似于其 C++ 对等接口的接口。但是，仅 Python 提供的与 C++ 集成的功能相对不足。与 C++ 和 Python 相比，'C' 只有非常基本的抽象功能，并且完全缺少对异常处理的支持。'C' 扩展模块编写者需要手动管理 Python 引用计数，这既令人厌烦又极易出错。传统的扩展模块也往往包含大量样板代码重复，这使得它们难以维护，尤其是在包装不断发展的 API 时。

这些限制导致了各种包装系统的开发。SWIG 可能是 C/C++ 和 Python 集成最流行的软件包。最近的一个发展是 SIP，它专门为 Python 与 Qt 图形用户界面库的接口而设计。SWIG 和 SIP 都引入了自己专门的语言来定制跨语言绑定。这有一定的优势，但是处理三种不同的语言（Python、C/C++ 和接口语言）也带来了实际和精神上的困难。CXX 软件包展示了一个有趣的替代方案。它表明，Python 'C' API 的至少一部分可以被包装并通过更用户友好的 C++ 接口呈现。然而，与 SWIG 和 SIP 不同，CXX 不包括将 C++ 类包装为新的 Python 类型的支持。

Boost.Python 的功能和目标与许多其他系统显着重叠。也就是说，Boost.Python 试图在不引入单独的包装语言的情况下最大化便利性和灵活性。相反，它为用户提供了一个高级 C++ 接口，用于包装 C++ 类和函数，并通过静态元编程在幕后管理大部分复杂性。Boost.Python 还通过提供以下功能超越了早期系统的范围

• 支持可以在 Python 中重写的 C++ 虚函数。
• 用于低级 C++ 指针和引用的全面的生命周期管理功能。
• 支持将扩展组织为 Python 包，并具有用于跨语言类型转换的中央注册表。
• 一种安全便捷的机制，用于连接到 Python 强大的序列化引擎 (pickle)。
• 与处理 C++ 左值和右值的规则的一致性，这只能来自对 Python 和 C++ 类型系统的深刻理解。

激发 Boost.Python 开发的关键洞察力是，传统扩展模块中的大部分样板代码都可以使用 C++ 编译时内省来消除。包装的 C++ 函数的每个参数都必须使用取决于参数类型的过程从 Python 对象中提取。类似地，函数的返回类型决定了返回值将如何从 C++ 转换为 Python。当然，参数和返回类型是每个函数类型的一部分，而这正是 Boost.Python 推导出大部分所需信息的来源。

这种方法导致了*用户引导的包装*：尽可能多地直接从要包装的源代码中提取信息，这在纯 C++ 框架内是可能的，并且一些附加信息由用户显式提供。大多数情况下，指导是机械的，几乎不需要真正的干预。由于接口规范是用与要暴露的代码相同的全功能语言编写的，因此当用户确实需要控制时，她拥有前所未有的权力。

Boost.Python 设计目标

Boost.Python 的主要目标是允许用户仅使用 C++ 编译器将 C++ 类和函数暴露给 Python。从广义上讲，用户体验应该是直接从 Python 操作 C++ 对象。

但是，同样重要的是不要*过于*字面地翻译所有接口：必须尊重每种语言的习惯用法。例如，尽管 C++ 和 Python 都有迭代器概念，但它们的表达方式却截然不同。Boost.Python 必须能够弥合接口差距。

必须能够使 Python 用户免受因轻微误用 C++ 接口（例如访问已删除的对象）而导致的崩溃的影响。同样，该库应使 C++ 用户免受低级 Python 'C' API 的影响，从而替换容易出错的 'C' 接口，例如手动引用计数管理和原始PyObject指针，并提供更健壮的替代方案。

对基于组件的开发的支持至关重要，以便在一个扩展模块中暴露的 C++ 类型可以传递给在另一个扩展模块中暴露的函数，而不会丢失关键信息，例如 C++ 继承关系。

最后，所有包装都必须是*非侵入式*的，无需修改甚至查看原始 C++ 源代码。现有的 C++ 库必须能够被仅有权访问头文件和二进制文件的第三方包装。

你好 Boost.Python 世界

现在预览一下 Boost.Python，以及它如何改进 Python 提供的原始功能。这是一个我们可能想要暴露的函数

char const* greet(unsigned x)
{
   static char const* const msgs[] = { "hello", "Boost.Python", "world!" };

   if (x > 2)
       throw std::range_error("greet: index out of range");

   return msgs[x];
}

要使用 Python 'C' API 在标准 C++ 中包装此函数，我们需要类似这样的代码

extern "C" // all Python interactions use 'C' linkage and calling convention
{
    // Wrapper to handle argument/result conversion and checking
    PyObject* greet_wrap(PyObject* args, PyObject * keywords)
    {
         int x;
         if (PyArg_ParseTuple(args, "i", &x))    // extract/check arguments
         {
             char const* result = greet(x);      // invoke wrapped function
             return PyString_FromString(result); // convert result to Python
         }
         return 0;                               // error occurred
    }

    // Table of wrapped functions to be exposed by the module
    static PyMethodDef methods[] = {
        { "greet", greet_wrap, METH_VARARGS, "return one of 3 parts of a greeting" }
        , { NULL, NULL, 0, NULL } // sentinel
    };

    // module initialization function
    DL_EXPORT init_hello()
    {
        (void) Py_InitModule("hello", methods); // add the methods to the module
    }
}

现在这是我们将使用 Boost.Python 暴露它的包装代码

#include <boost/python.hpp>
using namespace boost::python;
BOOST_PYTHON_MODULE(hello)
{
    def("greet", greet, "return one of 3 parts of a greeting");
}

这是它的实际应用

>>> import hello
>>> for x in range(3):
...     print hello.greet(x)
...
hello
Boost.Python
world!

除了 'C' API 版本更加冗长之外，值得注意的是它无法正确处理的一些事情

• 原始函数接受一个无符号整数，而 Python 'C' API 只为我们提供了一种提取有符号整数的方法。如果我们尝试将负数传递给hello.greet，Boost.Python 版本将引发 Python 异常，但另一个版本将继续执行 C++ 实现将负整数转换为无符号整数时所做的任何操作（通常包装成某个非常大的数字），并将不正确的转换传递给包装的函数。
• 这就引出了第二个问题：如果 C++greet()函数以大于 2 的数字调用，它将抛出异常。通常，如果 C++ 异常通过 'C' 编译器生成的代码跨越边界传播，则会导致崩溃。正如您在第一个版本中看到的，那里没有 C++ 脚手架来防止这种情况发生。由 Boost.Python 包装的函数自动包含一个异常处理层，该层通过将未处理的 C++ 异常转换为相应的 Python 异常来保护 Python 用户。
• 一个稍微更微妙的限制是，Python 'C' API 情况中使用的参数转换只能获取该整数x以*一种方式*。PyArg_ParseTuple 无法转换 Pythonlong对象（任意精度整数），它们恰好适合unsigned int但不适合signed long，也永远不会处理具有用户定义的隐式operator unsigned int()转换的包装 C++ 类。Boost.Python 的动态类型转换注册表允许用户添加任意转换方法。

库概览

本节概述了库的一些主要功能。除非为了避免混淆是必要的，否则省略了库实现的细节。

struct World
{
    void set(std::string msg) { this->msg = msg; }
    std::string greet() { return msg; }
    std::string msg;
};

#include <boost/python.hpp>
BOOST_PYTHON_MODULE(hello)
{
    class_<World>("World")
        .def("greet", &World::greet)
        .def("set", &World::set)
    ;
}

class_<World>("World")

class_<World> w("World");

w.def("greet", &World::greet)

class_<World> w("World");
w.def("greet", &World::greet);
w.def("set", &World::set);

>>> import hello
>>> planet = hello.World()
>>> planet.set('howdy')
>>> planet.greet()
'howdy'

>>> planet = hello.World()

struct World
{
    World(std::string msg); // added constructor
    ...

class_<World>("World", init<std::string>())
    ...

class_<World>("World", init<std::string>())
    .def(init<double, double>())
    ...

class_<World>("World", init<std::string>())
    .def_readonly("msg", &World::msg)
    ...

>>> planet = hello.World('howdy')
>>> planet.msg
'howdy'

class_<World>("World", init<std::string>())
    .add_property("msg", &World::greet, &World::set)
    ...

>>> class World(object):
...     __init__(self, msg):
...         self.__msg = msg
...     def greet(self):
...         return self.__msg
...     def set(self, msg):
...         self.__msg = msg
...     msg = property(greet, set)

class_<rational<int> >("rational_int")
  .def(init<int, int>()) // constructor, e.g. rational_int(3,4)
  .def("numerator", &rational<int>::numerator)
  .def("denominator", &rational<int>::denominator)
  .def(-self)        // __neg__ (unary minus)
  .def(self + self)  // __add__ (homogeneous)
  .def(self * self)  // __mul__
  .def(self + int()) // __add__ (heterogenous)
  .def(int() + self) // __radd__
  ...

class_<Derived, bases<Base1,Base2> >("Derived")
     ...

>>> class L(list):
...      def __init__(self):
...          pass
...
>>> L().reverse()
>>>

>>> class D(SomeBoostPythonClass):
...      def __init__(self):
...          pass
...
>>> D().some_boost_python_method()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: bad argument type for built-in operation

//
// interface to wrap:
//
class Base
{
 public:
    virtual int f(std::string x) { return 42; }
    virtual ~Base();
};

int calls_f(Base const& b, std::string x) { return b.f(x); }

//
// Wrapping Code
//

// Dispatcher class
struct BaseWrap : Base
{
    // Store a pointer to the Python object
    BaseWrap(PyObject* self_) : self(self_) {}
    PyObject* self;

    // Default implementation, for when f is not overridden
    int f_default(std::string x) { return this->Base::f(x); }
    // Dispatch implementation
    int f(std::string x) { return call_method<int>(self, "f", x); }
};

...
    def("calls_f", calls_f);
    class_<Base, BaseWrap>("Base")
        .def("f", &Base::f, &BaseWrap::f_default)
        ;

>>> class Derived(Base):
...     def f(self, s):
...          return len(s)
...
>>> calls_f(Base(), 'foo')
42
>>> calls_f(Derived(), 'forty-two')
9

#include <string>

struct World
{
    World(std::string a_msg) : msg(a_msg) {}
    std::string greet() const { return msg; }
    std::string msg;
};

#include <boost/python.hpp>
using namespace boost::python;

struct World_picklers : pickle_suite
{
  static tuple
  getinitargs(World const& w) { return make_tuple(w.greet()); }
};

BOOST_PYTHON_MODULE(hello)
{
    class_<World>("World", init<std::string>())
        .def("greet", &World::greet)
        .def_pickle(World_picklers())
    ;
}

>>> import hello
>>> import pickle
>>> a_world = hello.World("howdy")
>>> pickle.dump(a_world, open("my_world", "w"))

>>> import pickle
>>> resurrected_world = pickle.load(open("my_world", "r"))
>>> resurrected_world.greet()
'howdy'

object s("hello, world");  // s manages a Python string

object ten_Os = 10 * s[4]; // -> "oooooooooo"

double x = extract<double>(o);

dict d;
d["some"] = "thing";
d["lucky_number"] = 13;
list l = d.keys();

混合式思考

tuple

等等，尽可能多。这使得从 C++ 方便地操作这些高级类型成为可能

这几乎看起来和工作起来都像常规 Python 代码，但它是纯 C++。当然，我们可以包装接受或返回 `object` 实例的 C++ 函数。

由于组合编程语言的实际和精神困难，通常在任何开发工作的开始就确定一种语言。对于许多应用程序，性能考虑因素决定了核心算法使用编译语言。不幸的是，由于静态类型系统的复杂性，我们为运行时性能付出的代价通常是开发时间的显着增加。经验表明，编写可维护的 C++ 代码通常比开发可比的 Python 代码花费更长的时间，并且需要*更多*来之不易的工作经验。即使开发人员习惯于专门使用编译语言工作，他们也经常通过某种类型的临时脚本层来增强他们的系统，以造福他们的用户，而从未利用相同的优势。

开发历史

Boost.Python 使我们能够*混合式思考*。Python 可用于快速原型化新应用程序；它的易用性和大量的标准库使我们在通往工作系统的道路上抢占了先机。如有必要，可以使用工作代码来发现限速热点。为了最大限度地提高性能，这些可以用 C++ 重新实现，以及将它们绑定回现有更高级别过程所需的 Boost.Python 绑定。

这个早期版本的目标与我们在本文中描述的许多基本目标相同，最明显的不同之处在于它有一个稍微繁琐的语法，并且缺乏对运算符重载、序列化（pickling）和基于组件的开发的支持。Ullrich Koethe 和 Ralf Grosse-Kunstleve³ 很快添加了后三个特性，其他热情的贡献者也加入了进来，贡献了诸如对嵌套模块和静态成员函数的支持等增强功能。

到 2001 年初，开发已经稳定下来，新功能也鲜有增加，然而，一个令人不安的新事实浮出水面：Ralf 已经开始在使用 EDG 前端的编译器预发布版本上测试 Boost.Python，而 Boost.Python 核心中负责处理 Python 和 C++ 类型之间转换的机制编译失败。事实证明，我们一直在利用我们测试过的所有 C++ 编译器实现中一个非常常见的错误。我们知道，随着 C++ 编译器迅速变得更加符合标准，该库将开始在更多平台上失效。不幸的是，由于该机制对于库的运行至关重要，修复这个问题看起来非常困难。

幸运的是，那年晚些时候，劳伦斯伯克利国家实验室和后来的劳伦斯利弗莫尔国家实验室与 Boost Consulting 签订了合同，以获得对 Boost.Python 的支持和开发，这为解决根本问题并确保该库的未来提供了新的机会。一项重新设计工作从底层类型转换架构开始，构建了符合标准且支持基于组件的开发（与版本 1 形成对比，在版本 1 中，转换必须在模块边界之间显式导入和导出）。对 Python 和 C++ 对象之间关系的新分析也已完成，从而为 C++ 左值和右值提供了更直观的处理。

Python 2.2 中强大的新类型系统的出现，使得是否保持与 Python 1.5.2 的兼容性变得容易选择：仅仅是抛弃大量用于模拟经典 Python 类的复杂代码的机会就太好了，不容错过。此外，Python 迭代器和描述符为表示类似的 C++ 构造提供了至关重要且优雅的工具。通用化的发展object接口使我们能够进一步保护 C++ 程序员免受 Python 'C' API 的危险和语法负担。在此期间，还添加了许多其他功能，包括 C++ 异常转换、改进的对重载函数的支持，以及最重要的，用于处理指针和引用的 CallPolicies。

2002 年 10 月，Boost.Python 的版本 2 发布。此后的开发集中在改进对 C++ 运行时多态和智能指针的支持上。Peter Dimov 精巧的boost::shared_ptr设计尤其使我们能够为混合开发者提供一致的接口，以便在跨语言边界来回移动对象而不会丢失信息。起初，我们担心 Boost.Python v2 实现的复杂性和复杂性可能会使贡献者望而却步，但 Pyste 的出现以及其他几项重要的功能贡献已经消除了这些担忧。Python C++-sig 上的日常问题和大量期望的改进表明该库正在被使用。对我们来说，未来一片光明。

结论

Boost.Python 实现了两种丰富且互补的语言环境之间的无缝互操作性。因为它利用模板元编程来内省类型和函数，所以用户永远不必学习第三种语法：接口定义是用简洁且可维护的 C++ 编写的。此外，包装系统不必解析 C++ 头文件或表示类型系统：编译器为我们完成了这项工作。

计算密集型任务发挥了 C++ 的优势，并且通常不可能在纯 Python 中高效地实现，而像序列化这样在 Python 中微不足道的工作在纯 C++ 中可能非常困难。考虑到从头开始构建混合软件系统的优势，我们可以以新的信心和力量来对待设计。

引用

脚注