Abstract

摘要

Boost.Python is an open source C++ library which provides a conciseIDL-like interface for binding C++ classes and functions toPython. Leveraging the full power of C++ compile-time introspectionand of recently developed metaprogramming techniques, this is achievedentirely in pure C++, without introducing a new syntax.Boost.Python's rich set of features and high-level interface make itpossible to engineer packages from the ground up as hybrid systems,giving programmers easy and coherent access to both the efficientcompile-time polymorphism of C++ and the extremely convenient run-timepolymorphism of Python.

Boost.Python是一個(gè)開(kāi)源C++庫(kù)，它提供了一個(gè)簡(jiǎn)明的IDL式的接口，用于把C++類和函數(shù)綁定到Python。借助C++強(qiáng)大的編譯時(shí)內(nèi)省能力和最近發(fā)展的元編程技術(shù)，綁定工作完全用純C++實(shí)現(xiàn)，而沒(méi)有引入新的語(yǔ)法。Boost.Python豐富的特性和高級(jí)接口，使得完全按混合系統(tǒng)設(shè)計(jì)軟件包成為可能，并讓程序員以輕松連貫的方式，同時(shí)使用C++高效的編譯時(shí)多態(tài)，和Python極端便利的運(yùn)行時(shí)多態(tài)。

Introduction

介紹

Python and C++ are in many ways as different as two languages couldbe: while C++ is usually compiled to machine-code, Python isinterpreted.  Python's dynamic type system is often cited as thefoundation of its flexibility, while in C++ static typing is thecornerstone of its efficiency. C++ has an intricate and difficultcompile-time meta-language, while in Python, practically everythinghappens at runtime.

作為兩種語(yǔ)言，Python和C++存在很多差異。C++一般被編譯為機(jī)器碼，而Python是解釋執(zhí)行的。Python的動(dòng)態(tài)類型系統(tǒng)通常被認(rèn)為是它靈活性的基礎(chǔ)，而C++的靜態(tài)類型系統(tǒng)是C++效率的基石。C++有一種復(fù)雜艱深的編譯時(shí)元語(yǔ)言，而在Python中，幾乎一切都發(fā)生在運(yùn)行時(shí)。

Yet for many programmers, these very differences mean that Python andC++ complement one another perfectly.  Performance bottlenecks inPython programs can be rewritten in C++ for maximal speed, andauthors of powerful C++ libraries choose Python as a middlewarelanguage for its flexible system integration capabilities.Furthermore, the surface differences mask some strong similarities:

然而對(duì)很多程序員來(lái)說(shuō)，這些差異也意味著Python和C++可以完美互補(bǔ)。為了提高運(yùn)行速度，Python程序的性能瓶頸可以用C++重寫(xiě)，而大型C++庫(kù)的作者們，為了獲得靈活的系統(tǒng)集成能力，選擇Python作為中間件語(yǔ)言。此外，在表面差異掩蓋之下，二者有一些非常相似之處：

• 'C'-family control structures (if, while, for...)
• Support for object-orientation, functional programming, and genericprogramming (these are both multi-paradigm programming languages.)
• Comprehensive operator overloading facilities, recognizing theimportance of syntactic variability for readability andexpressivity.
• High-level concepts such as collections and iterators.
• High-level encapsulation facilities (C++: namespaces, Python: modules)to support the design of re-usable libraries.
• Exception-handling for effective management of error conditions.
• C++ idioms in common use, such as handle/body classes andreference-counted smart pointers mirror Python reference semantics.

• 'C'-家族的控制結(jié)構(gòu)（if, while, for...）
• 支持面向?qū)ο蟆⒑瘮?shù)式編程，以及泛型編程（它們都是多范式（multi-paradigm）編程語(yǔ)言。）
• 認(rèn)同語(yǔ)法可變性（syntactic variability）對(duì)于提高代碼可讀性和表達(dá)力的重要作用，提供了對(duì)運(yùn)算符重載的廣泛支持。
• 高級(jí)概念，如集合和迭代器。
• 高級(jí)封裝機(jī)制（C++：名字空間，Python：模塊），以支持可重用庫(kù)的設(shè)計(jì)。
• 異常處理，提供有效的錯(cuò)誤管理。
• 通用的C++慣用法，如handle/body類，和引用計(jì)數(shù)的智能指針，即Python的引用語(yǔ)義。

Given Python's rich 'C' interoperability API, it should in principlebe possible to expose C++ type and function interfaces to Python withan analogous interface to their C++ counterparts.  However, thefacilities provided by Python alone for integration with C++ arerelatively meager.  Compared to C++ and Python, 'C' has only veryrudimentary abstraction facilities, and support for exception-handlingis completely missing.  'C' extension module writers are required tomanually manage Python reference counts, which is both annoyinglytedious and extremely error-prone. Traditional extension modules alsotend to contain a great deal of boilerplate code repetition whichmakes them difficult to maintain, especially when wrapping an evolvingAPI.

因?yàn)镻ython有著豐富的'C'語(yǔ)言集成API，原則上，向Python導(dǎo)出C++類型和函數(shù)接口應(yīng)該是可行的，并且導(dǎo)出的接口與對(duì)應(yīng)C++的接口應(yīng)該是相似的。然而，Python本身提供的C++集成功能相對(duì)比較弱。和C++，Python相比，'C'只有非常基本的抽象能力，而且完全不支持異常處理。'C'擴(kuò)展模塊的作者必須手工管理Python的引用計(jì)數(shù)，這不僅單調(diào)乏味，令人惱火，而且還極易出錯(cuò)。傳統(tǒng)的擴(kuò)展模塊往往包含大量重復(fù)的樣板代碼，使它們難以維護(hù)，尤其是當(dāng)要封裝的API尚處于發(fā)展之中。

These limitations have lead to the development of a variety of wrappingsystems.  SWIG is probably the most popular package for theintegration of C/C++ and Python. A more recent development is SIP,which was specifically designed for interfacing Python with the Qtgraphical user interface library.  Both SWIG and SIP introduce theirown specialized languages for customizing inter-language bindings.This has certain advantages, but having to deal with three differentlanguages (Python, C/C++ and the interface language) also introducespractical and mental difficulties.  The CXX package demonstrates aninteresting alternative.  It shows that at least some parts ofPython's 'C' API can be wrapped and presented through a much moreuser-friendly C++ interface. However, unlike SWIG and SIP, CXX doesnot include support for wrapping C++ classes as new Python types.

這些限制導(dǎo)致了多種封裝系統(tǒng)的發(fā)展。SWIG可能是最流行的C/C++和Python集成系統(tǒng)。還有最近發(fā)展的SIP，它是專門(mén)為Qt圖形用戶界面庫(kù)設(shè)計(jì)的，用于提供Qt的Python接口。為了定制語(yǔ)言間的綁定，SWIG和SIP都引入了它們自己的專用語(yǔ)言。這有一定的好處，但是你不得不去應(yīng)付三種不同語(yǔ)言（Python、C/C++和接口語(yǔ)言），所以也帶來(lái)了事實(shí)上和心理上的困難。

The features and goals of Boost.Python overlap significantly withmany of these other systems.  That said, Boost.Python attempts tomaximize convenience and flexibility without introducing a separatewrapping language.  Instead, it presents the user with a high-levelC++ interface for wrapping C++ classes and functions, managing much ofthe complexity behind-the-scenes with static metaprogramming.Boost.Python also goes beyond the scope of earlier systems byproviding:

Boost.Python的特性和目標(biāo)與這些系統(tǒng)有很多重疊。Boost.Python努力提高封裝的便利性和靈活性，但不引入單獨(dú)的封裝語(yǔ)言。相反，它通過(guò)靜態(tài)元編程，在幕后管理大量的復(fù)雜性，呈現(xiàn)給用戶一個(gè)高級(jí)C++接口來(lái)封裝C++類和函數(shù)。Boost.Python也在如下領(lǐng)域超越了早期的系統(tǒng)：

• Support for C++ virtual functions that can be overridden in Python.
• Comprehensive lifetime management facilities for low-level C++pointers and references.
• Support for organizing extensions as Python packages,with a central registry for inter-language type conversions.
• A safe and convenient mechanism for tying into Python's powerfulserialization engine (pickle).
• Coherence with the rules for handling C++ lvalues and rvalues thatcan only come from a deep understanding of both the Python and C++type systems.

• 支持C++虛函數(shù)，并能在Python中覆蓋。
• 對(duì)于低級(jí)的C++指針和引用，提供全面的生命期管理機(jī)制。
• 支持按Python包組織擴(kuò)展模塊，通過(guò)中心注冊(cè)表進(jìn)行語(yǔ)言間類型轉(zhuǎn)換。
• 通過(guò)一種安全方便的機(jī)制，引入Python強(qiáng)大的序列化引擎（pickle）。
• 與C++處理左值和右值的規(guī)則相一致，該一致性只能來(lái)自于對(duì)Python和C++類型系統(tǒng)的深入理解。

The key insight that sparked the development of Boost.Python is thatmuch of the boilerplate code in traditional extension modules could beeliminated using C++ compile-time introspection.  Each argument of awrapped C++ function must be extracted from a Python object using aprocedure that depends on the argument type.  Similarly the function'sreturn type determines how the return value will be converted from C++to Python.  Of course argument and return types are part of eachfunction's type, and this is exactly the source from whichBoost.Python deduces most of the information required.

一個(gè)關(guān)鍵性的發(fā)現(xiàn)啟動(dòng)了Boost.Python的開(kāi)發(fā)，即利用C++的編譯時(shí)內(nèi)省，可以消除傳統(tǒng)擴(kuò)展模塊中的大量樣板代碼。如每個(gè)封裝的C++函數(shù)的參數(shù)都是從Python對(duì)象提取的，提取時(shí)必須根據(jù)參數(shù)類型調(diào)用相應(yīng)的過(guò)程。類似地，函數(shù)返回值從C++轉(zhuǎn)換成Python時(shí)，返回值的類型決定了如何轉(zhuǎn)換。因?yàn)閰?shù)和返回值的類型是每個(gè)函數(shù)類型的一部分，所以Boost.Python可以從函數(shù)類型推導(dǎo)出大部分所需的信息。

This approach leads to user guided wrapping: as much information isextracted directly from the source code to be wrapped as is possiblewithin the framework of pure C++, and some additional information issupplied explicitly by the user.  Mostly the guidance is mechanicaland little real intervention is required.  Because the interfacespecification is written in the same full-featured language as thecode being exposed, the user has unprecedented power available whenshe does need to take control.

這種方法導(dǎo)致了“用戶指導(dǎo)的封裝（user guided wrapping）”：在純C++的框架內(nèi)，從待封裝的源代碼中直接提取盡可能多的信息，而一些額外的信息由用戶顯式提供。通常這種指導(dǎo)是自動(dòng)的，很少需要真正的干涉。因?yàn)榻涌谝?guī)范和導(dǎo)出代碼是用同一門(mén)全功能的語(yǔ)言寫(xiě)的，當(dāng)用戶確實(shí)需要取得控制時(shí)，他所擁有的權(quán)力是空前強(qiáng)大的。

Boost.Python Design Goals

Boost.Python的設(shè)計(jì)目標(biāo)

The primary goal of Boost.Python is to allow users to expose C++classes and functions to Python using nothing more than a C++compiler.  In broad strokes, the user experience should be one ofdirectly manipulating C++ objects from Python.

Boost.Python的首要目標(biāo)是，讓用戶只用C++編譯器就能向Python導(dǎo)出C++類和函數(shù)。大體來(lái)講，用戶的體驗(yàn)應(yīng)該是，能夠從Python直接操作C++對(duì)象。

However, it's also important not to translate all interfaces tooliterally: the idioms of each language must be respected.  Forexample, though C++ and Python both have an iterator concept, they areexpressed very differently.  Boost.Python has to be able to bridge theinterface gap.

然而，有一點(diǎn)也很重要，那就是不要過(guò)于按字面翻譯所有接口：必須考慮每種語(yǔ)言的慣用法。例如，雖然C++和Python都有迭代器的概念，表達(dá)方式卻很不一樣。Boost.Python必須能夠消除這種接口的差異。

It must be possible to insulate Python users from crashes resultingfrom trivial misuses of C++ interfaces, such as accessingalready-deleted objects.  By the same token the library shouldinsulate C++ users from low-level Python 'C' API, replacingerror-prone 'C' interfaces like manual reference-count management andraw PyObject pointers with more-robust alternatives.

Python用戶可能會(huì)誤用C++接口，因此，Boost.Python必須能夠隔離因輕微的誤用而造成的崩潰，例如訪問(wèn)已刪除的對(duì)象。同樣的，Boost.Python庫(kù)應(yīng)該把C++用戶從低級(jí)的Python 'C' API中解放出來(lái)，將容易出錯(cuò)的'C'接口，如手工引用計(jì)數(shù)管理、原始的PyObject指針，替換為更健壯的接口。

Support for component-based development is crucial, so that C++ typesexposed in one extension module can be passed to functions exposed inanother without loss of crucial information like C++ inheritancerelationships.

支持基于組件的開(kāi)發(fā)是至關(guān)重要的，這樣，一個(gè)擴(kuò)展模塊導(dǎo)出的C++類型，可以傳遞給另一個(gè)模塊導(dǎo)出的函數(shù)，而不丟失重要的信息，比如C++的繼承關(guān)系。

Finally, all wrapping must be non-intrusive, without modifying oreven seeing the original C++ source code.  Existing C++ libraries haveto be wrappable by third parties who only have access to header filesand binaries.

最后，所有的封裝必須是非侵入性的（non-intrusive），不能修改最初的C++源碼，甚至不必看到源碼。第三方必須能夠封裝現(xiàn)有的C++庫(kù)，即使他只有頭文件和二進(jìn)制庫(kù)。

Hello Boost.Python World

Hello Boost.Python World

And now for a preview of Boost.Python, and how it improves on the rawfacilities offered by Python. Here's a function we might want toexpose:

現(xiàn)在來(lái)預(yù)覽一下Boost.Python，看看它是如何改進(jìn)Python原有的封裝機(jī)制的。下面是我們想導(dǎo)出的函數(shù):

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];
}

To wrap this function in standard C++ using the Python 'C' API, we'dneed something like this:

在標(biāo)準(zhǔn)C++中，用Python 'C' API來(lái)封裝這個(gè)函數(shù)，我們需要像這樣做:

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
    }
}

Now here's the wrapping code we'd use to expose it with Boost.Python:

而這是用Boost.Python來(lái)導(dǎo)出函數(shù)的封裝代碼：

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

and here it is in action:

這是運(yùn)行結(jié)果：

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

Aside from the fact that the 'C' API version is much more verbose,it's worth noting a few things that it doesn't handle correctly:

使用'C' API的版本要冗長(zhǎng)的多，此外，還需要注意，有些東西它沒(méi)有正確處理：

• The original function accepts an unsigned integer, and the Python'C' API only gives us a way of extracting signed integers. TheBoost.Python version will raise a Python exception if we try to passa negative number to hello.greet, but the other one will proceedto do whatever the C++ implementation does when converting annegative integer to unsigned (usually wrapping to some very largenumber), and pass the incorrect translation on to the wrappedfunction.

  原來(lái)的函數(shù)接受一個(gè)無(wú)符號(hào)整數(shù)，然而Python 'C' API只能提取有符號(hào)整數(shù)。如果我們?cè)噲D向hello.greet傳遞一個(gè)負(fù)數(shù)，Boost.Python版會(huì)引發(fā)Python異常，而另一個(gè)則會(huì)繼續(xù)：執(zhí)行C++代碼，將負(fù)數(shù)轉(zhuǎn)換為無(wú)符號(hào)數(shù)（通常會(huì)變成一個(gè)很大的數(shù)），然后把不正確的轉(zhuǎn)換結(jié)果傳遞給被封裝的函數(shù)。

• That brings us to the second problem: if the C++ greet()function is called with a number greater than 2, it will throw anexception.  Typically, if a C++ exception propagates across theboundary with code generated by a 'C' compiler, it will cause acrash.  As you can see in the first version, there's no C++scaffolding there to prevent this from happening.  Functions wrappedby Boost.Python automatically include an exception-handling layerwhich protects Python users by translating unhandled C++ exceptionsinto a corresponding Python exception.

  這引起了第二個(gè)問(wèn)題：如果輸入一個(gè)大于2的參數(shù)，C++ greet()函數(shù)會(huì)拋出異常。典型的，如果C++異常傳播時(shí)，跨越了'C'編譯器生成的代碼的邊界，就會(huì)導(dǎo)致崩潰。正如你在第一個(gè)版本中所見(jiàn)，那兒沒(méi)有防止崩潰的C++機(jī)制。而B(niǎo)oost.Python封裝的函數(shù)自動(dòng)包含了異常處理層，它把未處理的C++異常翻譯成相應(yīng)的Python異常，從而保護(hù)了Python用戶。

• A slightly more-subtle limitation is that the argument conversionused in the Python 'C' API case can only get that integer x inone way.  PyArg_ParseTuple can't convert Python long objects(arbitrary-precision integers) which happen to fit in an unsignedint but not in a signed long, nor will it ever handle awrapped C++ class with a user-defined implicit operator unsignedint() conversion. Boost.Python's dynamic type conversionregistry allows users to add arbitrary conversion methods.

  一個(gè)更微妙的限制是，Python 'C' API的參數(shù)轉(zhuǎn)換只能以“一種”方式取得整數(shù)x。如果有一個(gè)Python long對(duì)象（任意精度整數(shù)），它的大小正好屬于unsigned int，但不屬于signed long，PyArg_ParseTuple就不能對(duì)其進(jìn)行轉(zhuǎn)換。對(duì)于一個(gè)定義了operator unsigned int()，即用戶自定義隱式轉(zhuǎn)換的C++封裝類，它同樣無(wú)法處理。而B(niǎo)oost.Python的動(dòng)態(tài)類型轉(zhuǎn)換注冊(cè)表允許用戶添加任意的轉(zhuǎn)換方法。

Library Overview

庫(kù)概覽

This section outlines some of the library's major features.  Except asneccessary to avoid confusion, details of library implementation areomitted.

本節(jié)簡(jiǎn)述了庫(kù)的一些主要特性。在不影響理解的情況下，省略了庫(kù)的實(shí)現(xiàn)細(xì)節(jié)。

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();

Thinking hybrid

混合地思考

Because of the practical and mental difficulties of combiningprogramming languages, it is common to settle a single language at theoutset of any development effort.  For many applications, performanceconsiderations dictate the use of a compiled language for the corealgorithms.  Unfortunately, due to the complexity of the static typesystem, the price we pay for runtime performance is often asignificant increase in development time.  Experience shows thatwriting maintainable C++ code usually takes longer and requires farmore hard-earned working experience than developing comparable Pythoncode.  Even when developers are comfortable working exclusively incompiled languages, they often augment their systems by some type ofad hoc scripting layer for the benefit of their users without everavailing themselves of the same advantages.

因?yàn)榛旌险Z(yǔ)言編程具有事實(shí)上和心理上的困難，所以普通的做法是，在任何開(kāi)發(fā)活動(dòng)開(kāi)始時(shí)，先確定一種單一語(yǔ)言。對(duì)很多應(yīng)用來(lái)說(shuō)，性能上的考慮決定了核心算法要用編譯性語(yǔ)言實(shí)現(xiàn)。不幸的是，由于靜態(tài)類型系統(tǒng)的復(fù)雜性，為了運(yùn)行時(shí)的性能，我們所付出的代價(jià)常常是，開(kāi)發(fā)時(shí)間大大增加。經(jīng)驗(yàn)表明，和開(kāi)發(fā)同等的Python代碼相比，編寫(xiě)可維護(hù)的C++代碼通常需要更長(zhǎng)的時(shí)間，并且要求多得多的來(lái)之不易的工作經(jīng)驗(yàn)。即使開(kāi)發(fā)者覺(jué)得只用一門(mén)編譯性語(yǔ)言挺好，為了用戶的利益，他們也經(jīng)常給他們的系統(tǒng)增加某種專門(mén)的腳本層，但是他們自己卻從沒(méi)利用這種好處。

Boost.Python enables us to think hybrid.  Python can be used forrapidly prototyping a new application; its ease of use and the largepool of standard libraries give us a head start on the way to aworking system.  If necessary, the working code can be used todiscover rate-limiting hotspots.  To maximize performance these canbe reimplemented in C++, together with the Boost.Python bindingsneeded to tie them back into the existing higher-level procedure.

Boost.Python讓我們可以混合地思考（think hybrid）。Python可以為一個(gè)新應(yīng)用快速搭建原型；在建立一個(gè)可運(yùn)行的系統(tǒng)時(shí)，它的易用性和一大堆標(biāo)準(zhǔn)庫(kù)讓我們處于領(lǐng)先。如果有必要，可以用運(yùn)行的代碼來(lái)揭示限制速度的熱點(diǎn)。為了提高性能，這些熱點(diǎn)可以用C++來(lái)重新實(shí)現(xiàn)，然后用Boost.Python綁定，并提供給現(xiàn)有的高級(jí)過(guò)程調(diào)用。

Of course, this top-down approach is less attractive if it is clearfrom the start that many algorithms will eventually have to beimplemented in C++.  Fortunately Boost.Python also enables us topursue a bottom-up approach.  We have used this approach verysuccessfully in the development of a toolbox for scientificapplications.  The toolbox started out mainly as a library of C++classes with Boost.Python bindings, and for a while the growth wasmainly concentrated on the C++ parts.  However, as the toolbox isbecoming more complete, more and more newly added functionality can beimplemented in Python.

當(dāng)然，如果從一開(kāi)始就清楚，有許多算法將最終不得不用C++實(shí)現(xiàn)，這個(gè)自上而下（top-down）的方法就不是那么吸引人了。幸運(yùn)的是，Boost.Python讓我們也可以采用自下而上（bottom-up）的方法。我們?cè)?jīng)非常成功地應(yīng)用這種方法，開(kāi)發(fā)一個(gè)科學(xué)軟件工具箱。開(kāi)始的時(shí)候，這個(gè)工具箱主要是一個(gè)C++類庫(kù)，并帶有Boost.Python綁定，并且有一段時(shí)間，其成長(zhǎng)主要集中在C++的部分。然而，當(dāng)工具箱越來(lái)越完善，越來(lái)越多的新增功能可以用Python實(shí)現(xiàn)。

This figure shows the estimated ratio of newly added C++ and Pythoncode over time as new algorithms are implemented.  We expect thisratio to level out near 70% Python.  Being able to solve new problemsmostly in Python rather than a more difficult statically typedlanguage is the return on our investment in Boost.Python.  The abilityto access all of our code from Python allows a broader group ofdevelopers to use it in the rapid development of new applications.

該圖顯示，實(shí)現(xiàn)新的算法時(shí)，估計(jì)新增C++和Python代碼的比率隨時(shí)間的變化。我們預(yù)計(jì)這個(gè)比率會(huì)在接近70%的Python處變平。能夠主要地用Python來(lái)解決新問(wèn)題，而不是用更困難的靜態(tài)類型語(yǔ)言，這是我們?cè)贐oost.Python上投入的回報(bào)。我們的所有代碼都能從Python訪問(wèn)，這使得更多的開(kāi)發(fā)者可以用它來(lái)快速開(kāi)發(fā)新的應(yīng)用。

Development history

開(kāi)發(fā)歷史

The first version of Boost.Python was developed in 2000 by DaveAbrahams at Dragon Systems, where he was privileged to have Tim Petersas a guide to "The Zen of Python".  One of Dave's jobs was to developa Python-based natural language processing system.  Since it waseventually going to be targeting embedded hardware, it was alwaysassumed that the compute-intensive core would be rewritten in C++ tooptimize speed and memory footprint ¹.  The project also wanted totest all of its C++ code using Python test scripts ².  The onlytool we knew of for binding C++ and Python was SWIG, and at the timeits handling of C++ was weak.  It would be false to claim any deepinsight into the possible advantages of Boost.Python's approach atthis point.  Dave's interest and expertise in fancy C++ templatetricks had just reached the point where he could do some real damage,and Boost.Python emerged as it did because it filled a need andbecause it seemed like a cool thing to try.

Boost.Python的第一版是由Dragon Systems的Dave Abrahams在2000年開(kāi)發(fā)的，在Dragon Systems，Dave有幸由Tim Peters引導(dǎo)，接受了“Python之禪（The Zen of Python）”。Dave的工作之一是，開(kāi)發(fā)基于Python的自然語(yǔ)言處理系統(tǒng)（NLP，natural language processing）。由于最終要用于嵌入式硬件，所以總是假設(shè)，計(jì)算密集的內(nèi)核將會(huì)用C++來(lái)重寫(xiě)，以優(yōu)化速度和內(nèi)存占用¹。這個(gè)項(xiàng)目也想用Python測(cè)試腳本來(lái)測(cè)試所有的C++代碼²。當(dāng)時(shí)，我們所知的綁定C++和Python的唯一工具是SWIG，但那時(shí)它處理C++的能力比較弱。如果說(shuō)在那時(shí)就有什么深知卓見(jiàn)，說(shuō)Boost.Python的方法會(huì)有何等優(yōu)越性，那是騙人的。那時(shí)，Dave正好對(duì)花俏的C++模板技巧感興趣，并且嫻熟到剛好能真正做點(diǎn)東西，Boost.Python就那樣出現(xiàn)了，因?yàn)樗鼭M足了需求，因?yàn)樗雌饋?lái)挺酷，值得一試。

This early version was aimed at many of the same basic goals we'vedescribed in this paper, differing most-noticeably by having aslightly more cumbersome syntax and by lack of special support foroperator overloading, pickling, and component-based development.These last three features were quickly added by Ullrich Koethe andRalf Grosse-Kunstleve ³, and other enthusiastic contributors arrivedon the scene to contribute enhancements like support for nestedmodules and static member functions.

這個(gè)早期版本針對(duì)的目標(biāo)，與我們?cè)诒疚乃龅脑S多基本目標(biāo)相同，最顯著的區(qū)別在于，語(yǔ)法要稍微麻煩一點(diǎn)，并且，對(duì)運(yùn)算符重載、pickling，和基于組件的開(kāi)發(fā)缺乏專門(mén)的支持。后面這三個(gè)特性很快就由Ullrich Koethe和Ralf Grosse-Kunstleve加上了³，并且，其他熱心的貢獻(xiàn)者也出現(xiàn)了，并作了一些改進(jìn)，如對(duì)嵌套模塊和靜態(tài)成員函數(shù)的支持等。

By early 2001 development had stabilized and few new features werebeing added, however a disturbing new fact came to light: Ralf hadbegun testing Boost.Python on pre-release versions of a compiler usingthe EDG front-end, and the mechanism at the core of Boost.Pythonresponsible for handling conversions between Python and C++ types wasfailing to compile.  As it turned out, we had been exploiting a verycommon bug in the implementation of all the C++ compilers we hadtested.  We knew that as C++ compilers rapidly became morestandards-compliant, the library would begin failing on moreplatforms.  Unfortunately, because the mechanism was so central to thefunctioning of the library, fixing the problem looked very difficult.

到2001年初，開(kāi)發(fā)已經(jīng)穩(wěn)定下來(lái)了，很少有新增特性了，然而，這時(shí)出現(xiàn)了一件新的麻煩事：Ralf在一個(gè)使用EDG前端的編譯器的預(yù)發(fā)布版上測(cè)試Boost.Python，他發(fā)現(xiàn)，Boost.Python內(nèi)核中，Python和C++類型轉(zhuǎn)換機(jī)制無(wú)法通過(guò)編譯。結(jié)果表明，我們一直是在利用一個(gè)錯(cuò)誤，這是一個(gè)非常普遍的錯(cuò)誤，存在于所有我們已經(jīng)測(cè)試過(guò)的C++編譯器的實(shí)現(xiàn)中。我們知道，隨著C++編譯器變得更加符合標(biāo)準(zhǔn)，很快，庫(kù)將開(kāi)始在更多的平臺(tái)上失敗。很不幸，因?yàn)檫@套機(jī)制是Boost.Python庫(kù)功能的中樞，解決問(wèn)題看起來(lái)非常困難。

Fortunately, later that year Lawrence Berkeley and later LawrenceLivermore National labs contracted with Boost Consulting for supportand development of Boost.Python, and there was a new opportunity toaddress fundamental issues and ensure a future for the library.  Aredesign effort began with the low level type conversion architecture,building in standards-compliance and support for component-baseddevelopment (in contrast to version 1 where conversions had to beexplicitly imported and exported across module boundaries).  A newanalysis of the relationship between the Python and C++ objects wasdone, resulting in more intuitive handling for C++ lvalues andrvalues.

幸運(yùn)的是，那一年末，Lawrence Berkeley，后來(lái)建立了Lawrence Livermore National labs，與Boost Consulting簽訂了合同，來(lái)支持和發(fā)展Boost.Python，這樣就有了一個(gè)新的機(jī)會(huì)來(lái)處理庫(kù)的基本問(wèn)題，從而確保了庫(kù)未來(lái)的發(fā)展。庫(kù)進(jìn)行了重新設(shè)計(jì)，開(kāi)始于底層的類型轉(zhuǎn)換架構(gòu)，使它內(nèi)置具有標(biāo)準(zhǔn)兼容性，并支持基于組件的開(kāi)發(fā)（第1版中，轉(zhuǎn)換必須顯式地在模塊間導(dǎo)入和導(dǎo)出）。對(duì)Python和C++對(duì)象的關(guān)系進(jìn)行了新的分析，從而能更直觀地處理C++左值和右值。

The emergence of a powerful new type system in Python 2.2 made thechoice of whether to maintain compatibility with Python 1.5.2 easy:the opportunity to throw away a great deal of elaborate code foremulating classic Python classes alone was too good to pass up.  Inaddition, Python iterators and descriptors provided crucial andelegant tools for representing similar C++ constructs.  Thedevelopment of the generalized object interface allowed us tofurther shield C++ programmers from the dangers and syntactic burdensof the Python 'C' API.  A great number of other features including C++exception translation, improved support for overloaded functions, andmost significantly, CallPolicies for handling pointers andreferences, were added during this period.

關(guān)于是否維護(hù)對(duì)Python 1.5.2的兼容性，因?yàn)镻ython 2.2里出現(xiàn)了一個(gè)強(qiáng)大的新的類型系統(tǒng)，選擇變得容易了：這個(gè)機(jī)會(huì)好的令人無(wú)法拒絕，籍此可以拋棄大量復(fù)雜精細(xì)的代碼，而這些代碼僅僅是用來(lái)模擬傳統(tǒng)的Python類。另外，Python的迭代器（iterator）和描述符（descriptor）提供了重要且優(yōu)雅的工具，用來(lái)表示類似的C++構(gòu)造。通用的object接口的開(kāi)發(fā)進(jìn)一步方便了C++程序員，免除了Python 'C' API的危險(xiǎn)性和語(yǔ)法負(fù)擔(dān)。這一階段，還添加了大量其他特性，包括C++異常翻譯，對(duì)函數(shù)重載的更好的支持，還有最重要的，用來(lái)處理指針和引用的CallPolicies。

In October 2002, version 2 of Boost.Python was released.  Developmentsince then has concentrated on improved support for C++ runtimepolymorphism and smart pointers.  Peter Dimov's ingeniousboost::shared_ptr design in particular has allowed us to give thehybrid developer a consistent interface for moving objects back andforth across the language barrier without loss of information.  Atfirst, we were concerned that the sophistication and complexity of theBoost.Python v2 implementation might discourage contributors, but theemergence of Pyste and several other significant featurecontributions have laid those fears to rest.  Daily questions on thePython C++-sig and a backlog of desired improvements show that thelibrary is getting used.  To us, the future looks bright.

2002年十月，Boost.Python第2版發(fā)布了。從那以后，開(kāi)發(fā)集中于更好地支持C++運(yùn)行時(shí)多態(tài)性和智能指針。特別是Peter Dimov巧妙的boost::shared_ptr 的設(shè)計(jì)，使我們能給混和系統(tǒng)開(kāi)發(fā)者提供一個(gè)一致的接口，用于跨越語(yǔ)言屏障來(lái)回移動(dòng)對(duì)象而不丟失信息。剛開(kāi)始，我們擔(dān)心Boost.Python v2實(shí)現(xiàn)的詭秘與復(fù)雜會(huì)阻礙貢獻(xiàn)者，但Pyste的出現(xiàn)，和其他幾個(gè)重要特性的貢獻(xiàn)，證明那些擔(dān)心是多余的。在Python C++-sig上每天的提問(wèn)，和積壓的改進(jìn)請(qǐng)求表明了庫(kù)正在被使用。對(duì)我們來(lái)說(shuō)，未來(lái)是光明的。

Conclusions

結(jié)論

Boost.Python achieves seamless interoperability between two rich andcomplimentary language environments.  Because it leverages templatemetaprogramming to introspect about types and functions, the usernever has to learn a third syntax: the interface definitions arewritten in concise and maintainable C++.  Also, the wrapping systemdoesn't have to parse C++ headers or represent the type system: thecompiler does that work for us.

Boost.Python在兩種功能豐富并且互補(bǔ)的語(yǔ)言環(huán)境間實(shí)現(xiàn)了無(wú)縫協(xié)作。因?yàn)樗媚０逶幊虒?duì)類型和函數(shù)進(jìn)行內(nèi)省，用戶不必去學(xué)習(xí)第三種語(yǔ)言：接口定義是用簡(jiǎn)潔和可維護(hù)的C++寫(xiě)的。同時(shí)，封裝系統(tǒng)不必解析C++頭文件或者描述類型系統(tǒng)：編譯器都給我們做了。

Computationally intensive tasks play to the strengths of C++ and areoften impossible to implement efficiently in pure Python, while jobslike serialization that are trivial in Python can be very difficult inpure C++.  Given the luxury of building a hybrid software system fromthe ground up, we can approach design with new confidence and power.

計(jì)算密集型任務(wù)是C++的強(qiáng)項(xiàng)，一般不可能用純Python高效實(shí)現(xiàn)，然而像序列化這樣的工作，用Python很簡(jiǎn)單，用純C++就非常困難。如果我們能構(gòu)建完全的混合軟件系統(tǒng)，我們就能以新的信心和力量來(lái)進(jìn)行設(shè)計(jì)。

Citations

引用

Footnotes

腳注