Flo*_*sch 627
ctypes是标准库的一部分,因此比swig更稳定和广泛可用,它总是给我带来问题.
使用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
Ral*_*lph 160
你应该看一下Boost.Python.以下是他们网站的简短介绍:
Boost Python Library是一个用于连接Python和C++的框架.它允许您快速无缝地将C++类函数和对象公开给Python,反之亦然,不使用特殊工具 - 只需使用C++编译器.它旨在非侵入性地包装C++接口,因此您不必更改C++代码以包装它,使Boost.Python成为将第三方库公开给Python的理想选择.该库使用高级元编程技术简化了用户的语法,因此包装代码具有一种声明性接口定义语言(IDL)的外观.
Ben*_*ein 53
最快的方法是使用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还可用于将结构和类打包到目标语言的代理类中 - 以非常自然的方式公开底层功能.
Ant*_*llo 48
我从这个页面开始我的Python < - > C++绑定之旅,目的是链接高级数据类型(多维STL向量和Python列表):-)
在尝试了基于ctypes和boost.python(而不是软件工程师)的解决方案后,我发现当需要高级数据类型绑定时它们很复杂,而我发现SWIG对于这种情况更加简单.
这个例子因此使用了SWIG,并且已经在Linux中进行了测试(但是SWIG可用并且在Windows中也被广泛使用).
目标是使Python可以使用C++函数,该函数采用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
Tom*_*ers 28
还有pybind11,就像Boost.Python的轻量级版本,兼容所有现代C++编译器:
https://pybind11.readthedocs.io/en/latest/
Wim*_*sen 17
对于现代C++,请使用cppyy:http://cppyy.readthedocs.io/en/latest/
它基于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的作者.
mrg*_*oom 13
我认为python的cffi可以是一个选项.
目标是从Python调用C代码.你应该能够在不学习第三语言的情况下这样做:每个选择都要求你学习他们自己的语言(Cython,SWIG)或API(ctypes).因此,我们尝试假设您了解Python和C,并最大限度地减少您需要学习的额外API.
http://cffi.readthedocs.org/en/release-0.7/
Cir*_*四事件 10
pybind11 最小可运行示例
pybind11 之前在/sf/answers/2697977761/ 中提到过，但我想在这里给出一个具体的使用示例和一些关于实现的进一步讨论。
总而言之，我强烈推荐 pybind11，因为它真的很容易使用：你只需要包含一个头文件，然后 pybind11 使用模板魔术来检查你想要公开给 Python 的 C++ 类，并透明地进行。
这个模板魔术的缺点是它会立即减慢编译速度，为使用 pybind11 的任何文件增加几秒钟，例如参见对这个问题所做的调查。PyTorch 同意。已在以下位置提出修复此问题的建议：https : //github.com/pybind/pybind11/pull/2445
这是一个最小的可运行示例，让您了解 pybind11 是多么棒：
class_test.cpp
#include <string>
#include <pybind11/pybind11.h>
struct ClassTest {
ClassTest(const std::string &name, int i) : name(name), i(i) { }
void setName(const std::string &name_) { name = name_; }
const std::string getName() const { return name + "z"; }
void setI(const int i) { this->i = i; }
const int getI() const { return i + 1; }
std::string name;
int i;
};
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 &, int>())
.def("setName", &ClassTest::setName)
.def("getName", &ClassTest::getName)
.def_readwrite("name", &ClassTest::name)
.def("setI", &ClassTest::setI)
.def("getI", &ClassTest::getI)
.def_readwrite("i", &ClassTest::i);
return m.ptr();
}
class_test_main.py
#!/usr/bin/env python3
import class_test
my_class_test = class_test.ClassTest("abc", 1);
print(my_class_test.getName())
print(my_class_test.getI())
my_class_test.setName("012")
my_class_test.setI(2)
print(my_class_test.getName())
print(my_class_test.getI())
assert(my_class_test.getName() == "012z")
assert(my_class_test.getI() == 3)
编译并运行：
#!/usr/bin/env bash
set -eux
sudo apt install pybind11-dev
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
标准输出：
abcz
2
012z
3
如果我们尝试使用错误的类型，例如：
my_class_test.setI("abc")
它按预期爆炸：
Traceback (most recent call last):
File "/home/ciro/test/./class_test_main.py", line 9, in <module>
my_class_test.setI("abc")
TypeError: setI(): incompatible function arguments. The following argument types are supported:
1. (self: my_module.ClassTest, arg0: int) -> None
Invoked with: <my_module.ClassTest object at 0x7f2980254fb0>, 'abc'
这个例子展示了 pybind11 如何让你毫不费力地将ClassTestC++ 类暴露给 Python！
值得注意的是，Pybind11 自动从 C++ 代码中理解name为std::string，因此应该映射到 Pythonstr对象。
编译生成一个名为的文件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 声称与/sf/answers/10180551/Boost.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/en-us/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 上测试。
问题是，如果我理解正确的话，如何从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
有关详细指南，您可能需要参考我的博客文章。
小智 6
我喜欢 cppyy，它使用 C++ 代码扩展 Python 变得非常容易，在需要时显着提高性能。
它功能强大，坦率地说，使用起来非常简单，
这是一个如何创建 numpy 数组并将其传递给 C++ 中的类成员函数的示例。
cppyy_test.py
import cppyy
import numpy as np
cppyy.include('Buffer.h')
s = cppyy.gbl.Buffer()
numpy_array = np.empty(32000, np.float64)
s.get_numpy_array(numpy_array.data, numpy_array.size)
print(numpy_array[:20])
缓冲区.h
struct Buffer {
void get_numpy_array(double *ad, int size) {
for( long i=0; i < size; i++)
ad[i]=i;
}
};
您还可以非常轻松地创建 Python 模块（使用 CMake），这样您就可以避免一直重新编译 C++ 代码。
首先，您应该确定自己的特定目的。上面提到了有关扩展和嵌入Python解释器的官方Python文档，我可以添加一个很好的二进制扩展概述。用例可分为3类：
为了给其他感兴趣的人一个更广阔的视野，并且由于您的最初问题有点含糊（“对C或C ++库”），我认为此信息可能对您很有趣。在上面的链接上，您可以了解使用二进制扩展名及其替代方法的缺点。
除了建议的其他答案外，如果您需要加速器模块，还可以尝试Numba。它的工作原理是“通过在导入时，运行时或静态（使用附带的pycc工具）使用LLVM编译器基础结构生成优化的机器代码”。
除非您期望编写Java包装程序，否则Cython绝对是必经之路，在这种情况下，SWIG可能更可取。
我建议使用runcython命令行实用程序，它使使用Cython的过程非常容易。如果您需要将结构化数据传递给C ++，请查看Google的protobuf库，它非常方便。
这是我使用这两种工具的最小示例：
https://github.com/nicodjimenez/python2cpp
希望它可以是一个有用的起点。
| 归档时间： |
|
| 查看次数： |
388411 次 |
| 最近记录： |