问题：从Python调用C / C ++？
构造与C或C ++库的Python绑定的最快方法是什么？
（如果这很重要，我正在使用Windows。）
What would be the quickest way to construct a Python binding to a C or C++ library?
(I am using Windows if this matters.)
回答 0
您应该看看Boost.Python。以下是他们网站上的简短介绍：
Boost Python库是用于连接Python和C ++的框架。它使您可以快速而无缝地将C ++类的函数和对象暴露给Python，反之亦然，而无需使用特殊工具-仅使用C ++编译器即可。它旨在非侵入性地包装C ++接口，因此您不必为了包装而完全更改C ++代码，从而使Boost.Python成为将第三方库公开给Python的理想选择。该库对高级元编程技术的使用简化了用户的语法，因此包装代码具有一种声明性接口定义语言（IDL）的外观。
You should have a look at Boost.Python. Here is the short introduction taken from their website:
The Boost Python Library is a framework for interfacing Python and
C++. It allows you to quickly and seamlessly expose C++ classes
functions and objects to Python, and vice-versa, using no special
tools — just your C++ compiler. It is designed to wrap C++ interfaces
non-intrusively, so that you should not have to change the C++ code at
all in order to wrap it, making Boost.Python ideal for exposing
3rd-party libraries to Python. The library’s use of advanced
metaprogramming techniques simplifies its syntax for users, so that
wrapping code takes on the look of a kind of declarative interface
definition language (IDL).
回答 1
ctypes模块是标准库的一部分，因此比swig更稳定和更易于使用，而swig总是会给我带来麻烦。
使用ctypes时，您需要满足对python的任何编译时依赖性，并且绑定将对任何具有ctypes的python起作用，而不仅仅是针对ctypes的python。
假设您要在一个名为foo.cpp的文件中讨论一个简单的C ++示例类：
#include <iostream>
class Foo{
public:
void bar(){
std::cout << "Hello" << std::endl;
}
};
由于ctypes只能与C函数对话，因此您需要提供将其声明为extern“ C”的那些函数
extern "C" {
Foo* Foo_new(){ return new Foo(); }
void Foo_bar(Foo* foo){ foo->bar(); }
}
接下来，您必须将其编译为共享库
g++ -c -fPIC foo.cpp -o foo.o
g++ -shared -Wl,-soname,libfoo.so -o libfoo.so foo.o
最后，您必须编写python包装器（例如，在fooWrapper.py中）
from ctypes import cdll
lib = cdll.LoadLibrary('./libfoo.so')
class Foo(object):
def __init__(self):
self.obj = lib.Foo_new()
def bar(self):
lib.Foo_bar(self.obj)
一旦有了，您可以像这样称呼它
f = Foo()
f.bar() #and you will see "Hello" on the screen
ctypes module is part of the standard library, and therefore is more stable and widely available than swig, which always tended to give me problems.
With ctypes, you need to satisfy any compile time dependency on python, and your binding will work on any python that has ctypes, not just the one it was compiled against.
Suppose you have a simple C++ example class you want to talk to in a file called foo.cpp:
#include <iostream>
class Foo{
public:
void bar(){
std::cout << "Hello" << std::endl;
}
};
Since ctypes can only talk to C functions, you need to provide those declaring them as extern “C”
extern "C" {
Foo* Foo_new(){ return new Foo(); }
void Foo_bar(Foo* foo){ foo->bar(); }
}
Next you have to compile this to a shared library
g++ -c -fPIC foo.cpp -o foo.o
g++ -shared -Wl,-soname,libfoo.so -o libfoo.so foo.o
And finally you have to write your python wrapper (e.g. in fooWrapper.py)
from ctypes import cdll
lib = cdll.LoadLibrary('./libfoo.so')
class Foo(object):
def __init__(self):
self.obj = lib.Foo_new()
def bar(self):
lib.Foo_bar(self.obj)
Once you have that you can call it like
f = Foo()
f.bar() #and you will see "Hello" on the screen
回答 2
最快的方法是使用SWIG。
来自SWIG 教程的示例：
/* File : example.c */
int fact(int n) {
if (n <= 1) return 1;
else return n*fact(n-1);
}
接口文件：
/* example.i */
%module example
%{
/* Put header files here or function declarations like below */
extern int fact(int n);
%}
extern int fact(int n);
在Unix上构建Python模块：
swig -python example.i
gcc -fPIC -c example.c example_wrap.c -I/usr/local/include/python2.7
gcc -shared example.o example_wrap.o -o _example.so
用法：
>>> import example
>>> example.fact(5)
120
请注意，您必须具有python-dev。同样在某些系统中，python头文件会根据您的安装方式位于/usr/include/python2.7中。
从教程中：
SWIG是一个相当完整的C ++编译器，几乎支持所有语言功能。这包括预处理，指针，类，继承，甚至C ++模板。SWIG还可以用于以目标语言将结构和类打包为代理类，从而以非常自然的方式公开基础功能。
The quickest way to do this is using SWIG.
Example from SWIG tutorial:
/* File : example.c */
int fact(int n) {
if (n <= 1) return 1;
else return n*fact(n-1);
}
Interface file:
/* example.i */
%module example
%{
/* Put header files here or function declarations like below */
extern int fact(int n);
%}
extern int fact(int n);
Building a Python module on Unix:
swig -python example.i
gcc -fPIC -c example.c example_wrap.c -I/usr/local/include/python2.7
gcc -shared example.o example_wrap.o -o _example.so
Usage:
>>> import example
>>> example.fact(5)
120
Note that you have to have python-dev. Also in some systems python header files will be in /usr/include/python2.7 based on the way you have installed it.
From the tutorial:
SWIG is a fairly complete C++ compiler with support for nearly every language feature. This includes preprocessing, pointers, classes, inheritance, and even C++ templates. SWIG can also be used to package structures and classes into proxy classes in the target language — exposing the underlying functionality in a very natural manner.
回答 3
我从这一页的Python <-> C ++绑定开始了我的旅程，目的是链接高级数据类型（带有Python列表的多维STL向量）:-)
尝试过基于ctypes和boost.python的解决方案（并且不是软件工程师），当需要高级数据类型绑定时，我发现它们很复杂，而对于这种情况，我发现SWIG更加简单。
因此，该示例使用了SWIG，并且已经在Linux中进行了测试（但是SWIG可用，并且在Windows中也被广泛使用）。
目的是使C ++函数可用于Python，该函数采用2D STL向量形式的矩阵并返回每一行的平均值（作为1D STL向量）。
C ++中的代码（“ code.cpp”）如下：
#include <vector>
#include "code.h"
using namespace std;
vector<double> average (vector< vector<double> > i_matrix) {
// Compute average of each row..
vector <double> averages;
for (int r = 0; r < i_matrix.size(); r++){
double rsum = 0.0;
double ncols= i_matrix[r].size();
for (int c = 0; c< i_matrix[r].size(); c++){
rsum += i_matrix[r][c];
}
averages.push_back(rsum/ncols);
}
return averages;
}
等效的标头（“ code.h”）为：
#ifndef _code
#define _code
#include <vector>
std::vector<double> average (std::vector< std::vector<double> > i_matrix);
#endif
我们首先编译C ++代码以创建目标文件：
g++ -c -fPIC code.cpp
然后，我们为C ++函数定义一个SWIG接口定义文件（“ code.i”）。
%module code
%{
#include "code.h"
%}
%include "std_vector.i"
namespace std {
/* On a side note, the names VecDouble and VecVecdouble can be changed, but the order of first the inner vector matters! */
%template(VecDouble) vector<double>;
%template(VecVecdouble) vector< vector<double> >;
}
%include "code.h"
使用SWIG，我们从SWIG接口定义文件生成C ++接口源代码。
swig -c++ -python code.i
最后，我们编译生成的C ++接口源文件，并将所有内容链接在一起，以生成可由Python直接导入的共享库（“ _”很重要）：
g++ -c -fPIC code_wrap.cxx -I/usr/include/python2.7 -I/usr/lib/python2.7
g++ -shared -Wl,-soname,_code.so -o _code.so code.o code_wrap.o
现在，我们可以在Python脚本中使用该函数：
#!/usr/bin/env python
import code
a= [[3,5,7],[8,10,12]]
print a
b = code.average(a)
print "Assignment done"
print a
print b
I started my journey in the Python <-> C++ binding from this page, with the objective of linking high level data types (multidimensional STL vectors with Python lists) :-)
Having tried the solutions based on both ctypes and boost.python (and not being a software engineer) I have found them complex when high level datatypes binding is required, while I have found SWIG much more simple for such cases.
This example uses therefore SWIG, and it has been tested in Linux (but SWIG is available and is widely used in Windows too).
The objective is to make a C++ function available to Python that takes a matrix in form of a 2D STL vector and returns an average of each row (as a 1D STL vector).
The code in C++ (“code.cpp”) is as follow:
#include <vector>
#include "code.h"
using namespace std;
vector<double> average (vector< vector<double> > i_matrix) {
// Compute average of each row..
vector <double> averages;
for (int r = 0; r < i_matrix.size(); r++){
double rsum = 0.0;
double ncols= i_matrix[r].size();
for (int c = 0; c< i_matrix[r].size(); c++){
rsum += i_matrix[r][c];
}
averages.push_back(rsum/ncols);
}
return averages;
}
The equivalent header (“code.h”) is:
#ifndef _code
#define _code
#include <vector>
std::vector<double> average (std::vector< std::vector<double> > i_matrix);
#endif
We first compile the C++ code to create an object file:
g++ -c -fPIC code.cpp
We then define a SWIG interface definition file (“code.i”) for our C++ functions.
%module code
%{
#include "code.h"
%}
%include "std_vector.i"
namespace std {
/* On a side note, the names VecDouble and VecVecdouble can be changed, but the order of first the inner vector matters! */
%template(VecDouble) vector<double>;
%template(VecVecdouble) vector< vector<double> >;
}
%include "code.h"
Using SWIG, we generate a C++ interface source code from the SWIG interface definition file..
swig -c++ -python code.i
We finally compile the generated C++ interface source file and link everything together to generate a shared library that is directly importable by Python (the “_” matters):
g++ -c -fPIC code_wrap.cxx -I/usr/include/python2.7 -I/usr/lib/python2.7
g++ -shared -Wl,-soname,_code.so -o _code.so code.o code_wrap.o
We can now use the function in Python scripts:
#!/usr/bin/env python
import code
a= [[3,5,7],[8,10,12]]
print a
b = code.average(a)
print "Assignment done"
print a
print b
回答 4
回答 5
检查出pyrex或Cython。它们是类似于Python的语言，用于C / C ++和Python之间的接口。
Check out pyrex or Cython. They’re Python-like languages for interfacing between C/C++ and Python.
回答 6
对于现代C ++，请使用cppyy：
http
它基于Cling / Clang / LLVM的C ++解释器。绑定是在运行时执行的，不需要其他中间语言。感谢Clang，它支持C ++ 17。
使用pip安装它：
$ pip install cppyy
对于小型项目，只需加载相关的库和您感兴趣的标头。例如，从ctypes示例中获取代码就是该线程，但分为标头和代码部分：
$ cat foo.h
class Foo {
public:
void bar();
};
$ cat foo.cpp
#include "foo.h"
#include <iostream>
void Foo::bar() { std::cout << "Hello" << std::endl; }
编译：
$ g++ -c -fPIC foo.cpp -o foo.o
$ g++ -shared -Wl,-soname,libfoo.so -o libfoo.so foo.o
并使用它：
$ python
>>> import cppyy
>>> cppyy.include("foo.h")
>>> cppyy.load_library("foo")
>>> from cppyy.gbl import Foo
>>> f = Foo()
>>> f.bar()
Hello
>>>
大型项目通过自动加载准备的反射信息和cmake片段来创建它们而受支持，因此安装包的用户可以简单地运行：
$ python
>>> import cppyy
>>> f = cppyy.gbl.Foo()
>>> f.bar()
Hello
>>>
多亏了LLVM，高级功能才得以实现，例如自动模板实例化。继续示例：
>>> v = cppyy.gbl.std.vector[cppyy.gbl.Foo]()
>>> v.push_back(f)
>>> len(v)
1
>>> v[0].bar()
Hello
>>>
注意：我是cppyy的作者。
For modern C++, use cppyy:
http://cppyy.readthedocs.io/en/latest/
It’s based on Cling, the C++ interpreter for Clang/LLVM. Bindings are at run-time and no additional intermediate language is necessary. Thanks to Clang, it supports C++17.
Install it using pip:
$ pip install cppyy
For small projects, simply load the relevant library and the headers that you are interested in. E.g. take the code from the ctypes example is this thread, but split in header and code sections:
$ cat foo.h
class Foo {
public:
void bar();
};
$ cat foo.cpp
#include "foo.h"
#include <iostream>
void Foo::bar() { std::cout << "Hello" << std::endl; }
Compile it:
$ g++ -c -fPIC foo.cpp -o foo.o
$ g++ -shared -Wl,-soname,libfoo.so -o libfoo.so foo.o
and use it:
$ python
>>> import cppyy
>>> cppyy.include("foo.h")
>>> cppyy.load_library("foo")
>>> from cppyy.gbl import Foo
>>> f = Foo()
>>> f.bar()
Hello
>>>
Large projects are supported with auto-loading of prepared reflection information and the cmake fragments to create them, so that users of installed packages can simply run:
$ python
>>> import cppyy
>>> f = cppyy.gbl.Foo()
>>> f.bar()
Hello
>>>
Thanks to LLVM, advanced features are possible, such as automatic template instantiation. To continue the example:
>>> v = cppyy.gbl.std.vector[cppyy.gbl.Foo]()
>>> v.push_back(f)
>>> len(v)
1
>>> v[0].bar()
Hello
>>>
Note: I’m the author of cppyy.
回答 7
回答 8
我从未使用过它，但是我听说过有关ctypes的好东西。如果您要在C ++中使用它，请确保通过来避开名称修饰extern "C"。感谢弗洛里安·博斯（FlorianBösch）的评论。
I’ve never used it but I’ve heard good things about ctypes. If you’re trying to use it with C++, be sure to evade name mangling via extern "C". Thanks for the comment, Florian Bösch.
回答 9
I think cffi for python can be an option.
The goal is to call C code from Python. You should be able to do so
without learning a 3rd language: every alternative requires you to
learn their own language (Cython, SWIG) or API (ctypes). So we tried
to assume that you know Python and C and minimize the extra bits of
API that you need to learn.
http://cffi.readthedocs.org/en/release-0.7/
回答 10
问题是，如果我理解正确的话，如何从Python调用C函数。然后最好的选择是Ctypes（BTW可在所有Python变体中移植）。
>>> from ctypes import *
>>> libc = cdll.msvcrt
>>> print libc.time(None)
1438069008
>>> printf = libc.printf
>>> printf("Hello, %s\n", "World!")
Hello, World!
14
>>> printf("%d bottles of beer\n", 42)
42 bottles of beer
19
有关详细指南，您可能需要参考我的博客文章。
The question is how to call a C function from Python, if I understood correctly. Then the best bet are Ctypes (BTW portable across all variants of Python).
>>> from ctypes import *
>>> libc = cdll.msvcrt
>>> print libc.time(None)
1438069008
>>> printf = libc.printf
>>> printf("Hello, %s\n", "World!")
Hello, World!
14
>>> printf("%d bottles of beer\n", 42)
42 bottles of beer
19
For a detailed guide you may want to refer to my blog article.
回答 11
One of the official Python documents contains details on extending Python using C/C++.
Even without the use of SWIG, it’s quite straightforward and works perfectly well on Windows.
回答 12
除非您期望编写Java包装程序，否则Cython绝对是必经之路，在这种情况下，SWIG可能更可取。
我建议使用 runcython命令行实用程序，它使使用Cython的过程非常容易。如果您需要将结构化数据传递给C ++，请查看Google的protobuf库，它非常方便。
这是我使用这两种工具的最小示例：
https://github.com/nicodjimenez/python2cpp
希望它可以是一个有用的起点。
Cython is definitely the way to go, unless you anticipate writing Java wrappers, in which case SWIG may be preferable.
I recommend using the runcython command line utility, it makes the process of using Cython extremely easy. If you need to pass structured data to C++, take a look at Google’s protobuf library, it’s very convenient.
Here is a minimal examples I made that uses both tools:
https://github.com/nicodjimenez/python2cpp
Hope it can be a useful starting point.
回答 13
首先，您应该确定自己的特定目的。上面提到了有关扩展和嵌入Python解释器的官方Python文档，我可以添加一个很好的二进制扩展概述。用例可分为3类：
- 加速器模块：运行速度比CPython中运行的等效纯Python代码更快。
- 包装模块：将现有的C接口公开给Python代码。
- 低级系统访问：访问CPython运行时，操作系统或底层硬件的低级功能。
为了给其他感兴趣的人提供更广阔的视野，并且由于您的最初问题有点含糊（“对C或C ++库”），我认为此信息可能对您很有趣。在上面的链接上，您可以了解使用二进制扩展名及其替代方法的缺点。
除了建议的其他答案外，如果您需要加速器模块，还可以尝试Numba。它的工作原理是“通过在导入时间，运行时或静态（使用附带的pycc工具）使用LLVM编译器基础结构生成优化的机器代码”。
First you should decide what is your particular purpose. The official Python documentation on extending and embedding the Python interpreter was mentioned above, I can add a good overview of binary extensions. The use cases can be divided into 3 categories:
- accelerator modules: to run faster than the equivalent pure Python code runs in CPython.
- wrapper modules: to expose existing C interfaces to Python code.
- low level system access: to access lower level features of the CPython runtime, the operating system, or the underlying hardware.
In order to give some broader perspective for other interested and since your initial question is a bit vague (“to a C or C++ library”) I think this information might be interesting to you. On the link above you can read on disadvantages of using binary extensions and its alternatives.
Apart from the other answers suggested, if you want an accelerator module, you can try Numba. It works “by generating optimized machine code using the LLVM compiler infrastructure at import time, runtime, or statically (using the included pycc tool)”.
回答 14
我喜欢cppyy，它很容易用C ++代码扩展Python，并在需要时大大提高了性能。
它功能强大且坦率地说非常易于使用，
这是一个示例，说明如何创建numpy数组并将其传递给C ++中的类成员函数。
import cppyy
cppyy.add_include_path("include")
cppyy.include('mylib/Buffer.h')
s = cppyy.gbl.buffer.Buffer()
numpy_array = np.empty(32000, np.float64)
s.get_numpy_array(numpy_array.data, numpy_array.size)
在C ++中：
struct Buffer {
void get_numpy_array(int beam, double *ad, int size) {
// fill the array
}
}
您还可以非常轻松地（使用CMake）创建Python模块，这样您就可以避免一直重新编译C ++代码。
I love cppyy, it makes it very easy to extend Python with C++ code, dramatically increasing performance when needed.
It is powerful and frankly very simple to use,
here it is an example of how you can create a numpy array and pass it to a class member function in C++.
import cppyy
cppyy.add_include_path("include")
cppyy.include('mylib/Buffer.h')
s = cppyy.gbl.buffer.Buffer()
numpy_array = np.empty(32000, np.float64)
s.get_numpy_array(numpy_array.data, numpy_array.size)
in C++ :
struct Buffer {
void get_numpy_array(int beam, double *ad, int size) {
// fill the array
}
}
You can also create a Python module very easily (with CMake), this way you will avoid recompile the C++ code all the times.
回答 15
pybind11最小可运行示例
pybind11之前在https://stackoverflow.com/a/38542539/895245中提到过，但是我想在这里给出一个具体的用法示例以及有关实现的更多讨论。
总而言之，我强烈推荐pybind11，因为它确实很容易使用：您只需包含一个标头，然后pybind11使用模板魔术检查要公开给Python的C ++类并透明地进行。
这种模板魔术的缺点是，它会立即减慢编译速度，从而会给使用pybind11的任何文件增加几秒钟的时间，例如，请参见对此问题进行的调查。PyTorch同意。
这是一个最小的可运行示例，使您了解pybind11的出色程度：
class_test.cpp
#include <string>
#include <pybind11/pybind11.h>
struct ClassTest {
ClassTest(const std::string &name) : name(name) { }
void setName(const std::string &name_) { name = name_; }
const std::string &getName() const { return name; }
std::string name;
};
namespace py = pybind11;
PYBIND11_PLUGIN(class_test) {
py::module m("my_module", "pybind11 example plugin");
py::class_<ClassTest>(m, "ClassTest")
.def(py::init<const std::string &>())
.def("setName", &ClassTest::setName)
.def("getName", &ClassTest::getName)
.def_readwrite("name", &ClassTest::name);
return m.ptr();
}
class_test_main.py
#!/usr/bin/env python3
import class_test
my_class_test = class_test.ClassTest("abc");
print(my_class_test.getName())
my_class_test.setName("012")
print(my_class_test.getName())
assert(my_class_test.getName() == my_class_test.name)
编译并运行：
#!/usr/bin/env bash
set -eux
g++ `python3-config --cflags` -shared -std=c++11 -fPIC class_test.cpp \
-o class_test`python3-config --extension-suffix` `python3-config --libs`
./class_test_main.py
此示例说明pybind11如何使您轻松地将ClassTestC ++类公开给Python！编译会产生一个名为的文件class_test.cpython-36m-x86_64-linux-gnu.so，该文件会class_test_main.py自动作为文件的定义点class_test本地定义的模块。
也许只有在您尝试使用本机Python API手动执行相同操作时，才会意识到它的强大程度，例如，请参见以下示例，该示例包含大约10倍的代码：https : //github.com /cirosantilli/python-cheat/blob/4f676f62e87810582ad53b2fb426b74eae52aad5/py_from_c/pure.c在该示例上，您可以看到C代码如何痛苦地，明确地定义Python类及其所包含的所有信息（成员，方法，其他信息）。元数据…）。也可以看看：
pybind11声称与https://stackoverflow.com/a/145436/895245Boost.Python所提到的相似，但因其摆脱了Boost项目中的膨胀而变得更加微不足道：
pybind11是一个轻量级的仅标头的库，它公开了Python中的C ++类型，反之亦然，主要是创建现有C ++代码的Python绑定。它的目标和语法类似于David Abrahams出色的Boost.Python库：通过使用编译时自省来推断类型信息，从而最大程度地减少了传统扩展模块中的样板代码。
Boost.Python的主要问题以及创建类似项目的原因是Boost。Boost是庞大而复杂的实用程序套件，可与几乎所有现有的C ++编译器一起使用。这种兼容性有其代价：奥秘的模板技巧和变通办法对于支持最早的和最新的编译器标本是必需的。现在，与C ++ 11兼容的编译器已广泛可用，这种繁琐的机制已变得过大且不必要。
可以将此库视为Boost.Python的小型独立版本，其中剥离了与绑定生成无关的所有内容。没有注释，核心头文件仅需要约4K行代码，并依赖于Python（2.7或3.x，或PyPy2.7> = 5.7）和C ++标准库。由于某些新的C ++ 11语言功能（特别是：元组，lambda函数和可变参数模板），因此可以实现这种紧凑的实现。自创建以来，该库在许多方面都超越了Boost.Python，从而在许多常见情况下大大简化了绑定代码。
pybind11还是当前Microsoft Python C绑定文档中突出显示的唯一非本地替代方法，网址为：https ://docs.microsoft.com/zh-cn/visualstudio/python/working-with-c-cpp-python-in- visual-studio？view = vs-2019（存档）。
已在Ubuntu 18.04，pybind11 2.0.1，Python 3.6.8，GCC 7.4.0上进行了测试。
pybind11 minimal runnable example
pybind11 was previously mentioned at https://stackoverflow.com/a/38542539/895245 but I would like to give here a concrete usage example and some further discussion about implementation.
All and all, I highly recommend pybind11 because it is really easy to use: you just include a header and then pybind11 uses template magic to inspect the C++ class you want to expose to Python and does that transparently.
The downside of this template magic is that it slows down compilation immediately adding a few seconds to any file that uses pybind11, see for example the investigation done on this issue. PyTorch agrees.
Here is a minimal runnable example to give you a feel of how awesome pybind11 is:
class_test.cpp
#include <string>
#include <pybind11/pybind11.h>
struct ClassTest {
ClassTest(const std::string &name) : name(name) { }
void setName(const std::string &name_) { name = name_; }
const std::string &getName() const { return name; }
std::string name;
};
namespace py = pybind11;
PYBIND11_PLUGIN(class_test) {
py::module m("my_module", "pybind11 example plugin");
py::class_<ClassTest>(m, "ClassTest")
.def(py::init<const std::string &>())
.def("setName", &ClassTest::setName)
.def("getName", &ClassTest::getName)
.def_readwrite("name", &ClassTest::name);
return m.ptr();
}
class_test_main.py
#!/usr/bin/env python3
import class_test
my_class_test = class_test.ClassTest("abc");
print(my_class_test.getName())
my_class_test.setName("012")
print(my_class_test.getName())
assert(my_class_test.getName() == my_class_test.name)
Compile and run:
#!/usr/bin/env bash
set -eux
g++ `python3-config --cflags` -shared -std=c++11 -fPIC class_test.cpp \
-o class_test`python3-config --extension-suffix` `python3-config --libs`
./class_test_main.py
This example shows how pybind11 allows you to effortlessly expose the ClassTest C++ class to Python! Compilation produces a file named class_test.cpython-36m-x86_64-linux-gnu.so which class_test_main.py automatically picks up as the definition point for the class_test natively defined module.
Perhaps the realization of how awesome this is only sinks in if you try to do the same thing by hand with the native Python API, see for example this example of doing that, which has about 10x more code: https://github.com/cirosantilli/python-cheat/blob/4f676f62e87810582ad53b2fb426b74eae52aad5/py_from_c/pure.c On that example you can see how the C code has to painfully and explicitly define the Python class bit by bit with all the information it contains (members, methods, further metadata…). See also:
pybind11 claims to be similar to Boost.Python which was mentioned at https://stackoverflow.com/a/145436/895245 but more minimal because it is freed from the bloat of being inside the Boost project:
pybind11 is a lightweight header-only library that exposes C++ types in Python and vice versa, mainly to create Python bindings of existing C++ code. Its goals and syntax are similar to the excellent Boost.Python library by David Abrahams: to minimize boilerplate code in traditional extension modules by inferring type information using compile-time introspection.
The main issue with Boost.Python—and the reason for creating such a similar project—is Boost. Boost is an enormously large and complex suite of utility libraries that works with almost every C++ compiler in existence. This compatibility has its cost: arcane template tricks and workarounds are necessary to support the oldest and buggiest of compiler specimens. Now that C++11-compatible compilers are widely available, this heavy machinery has become an excessively large and unnecessary dependency.
Think of this library as a tiny self-contained version of Boost.Python with everything stripped away that isn’t relevant for binding generation. Without comments, the core header files only require ~4K lines of code and depend on Python (2.7 or 3.x, or PyPy2.7 >= 5.7) and the C++ standard library. This compact implementation was possible thanks to some of the new C++11 language features (specifically: tuples, lambda functions and variadic templates). Since its creation, this library has grown beyond Boost.Python in many ways, leading to dramatically simpler binding code in many common situations.
pybind11 is also the only non-native alternative hightlighted by the current Microsoft Python C binding documentation at: https://docs.microsoft.com/en-us/visualstudio/python/working-with-c-cpp-python-in-visual-studio?view=vs-2019 (archive).
Tested on Ubuntu 18.04, pybind11 2.0.1, Python 3.6.8, GCC 7.4.0.
