延伸的巨蟒来痛饮，不痛饮或Cython

https://stackoverflow.com/questions/456884

19-08-2019
|

题

我发现的瓶颈，在我的代码，发挥了与心理等等。然后决定编写的c/c++扩展性能。

帮助痛饮你几乎不需要护理有关的参数等。一切正常。

现在我的问题：痛饮创建了一个相当大的番文件，该文件做了很多的审核"和"PySwigObject'话之前实际。pyd。这样的代码。

任何人都不会对你有任何经验中是否有一些更多的性能获得，如果你手编写这一文件或者让痛饮这样做。

解决方案

有关确保你将永远有一个性能增益手工做这个，但相比要做到这一点需要努力的增益会很小。我没有任何数字给你，但我不建议这样做，因为你需要保持手的界面，如果你的模块很大，这是不是一种选择！

你做选择，因为你想快速发展，使用脚本语言正确的事情。这样你可以避免早期优化综合征，现在你想优化的瓶颈部分，太棒了！但是，如果你自己动手完成的C / Python接口你会爱上肯定早期优化综合征。

如果您希望用更少的接口代码的东西，你可以考虑从你的C代码创建一个DLL，并直接从蟒蛇使用该库的 cstruct 。

考虑也如果你想在你的程序只使用Python代码用Cython 。

其他提示

你应该考虑提升。蟒蛇如果你不是计划产生的绑定对其他语言以及有痛饮.

如果你有一个很大的职能和类绑定， Py++ 是一个伟大的工具，可以自动生成的所需码使绑定。

Pybindgen 也可能是一种选择，但这是一个新的项目和较不完整，提高。蟒蛇。

编辑：

也许我需要更加明确的关于职业和缺点。

痛饮:

专业：你可以产生绑定的许多脚本语言。

缺点：我不喜欢的方式分析器工作。我不知道，如果取得了一些进展，但是两年前的C++析是相当有限。大多数时候我不得复制过去的我的.h的标题中添加一些 % 字符，并得到额外的提示的痛饮分析器。

我还需要处理的蟒蛇C-API时(不)复杂类型的转换。

我不是使用它了。
提升。蟒蛇：

专业：这是一个非常完整的图书馆。它可以让你做几乎一切可用的C-API，但在C++。我从来没有写C-API代码这个图书馆。我还从来没有遇到错误的，由于该图书馆。代码绑定的任一工作就像一个魅力或拒绝编译。

它可能是一个最好的解决方案目前可以，如果你已经有一些C++库绑定。但是如果你只有一个小C功能重写,我可能会尝试与Cython.

缺点：如果你没有预先编制的提升。蟒蛇图书馆，你要使用Bjam(种做更换)。我真的很讨厌Bjam和语法。

蟒蛇图书馆创建了与B.P往往成为肥胖。它也需要一个很多时间编制它们。
Py++(停产):这是提升。蟒蛇变得容易。Py++使用C++分析器读取你的代码然后产生的提升。蟒蛇的代码。你还有一个很大的支持自它的作者(没有这不是我;-)).

缺点：唯一的问题，由于提升。蟒蛇本身。更新：作为2014年的这个项目现在看起来停止。
Pybindgen:

它产生的代码处理的C-API。你可以描述的职能和类Python文件，或者让Pybindgen读你的头和产生的绑定自动(为此，它采用pygccxml，python库写的作者Py++).

缺点：这是一个年轻的项目，有一个小队于提升。蟒蛇。仍然有一些限制：你不能使用多个继承C++类，回调(不自动定义的回调处理代码可以是书面的，尽管).翻译的蟒蛇的例外情况C.

这绝对值得好好看看。
一个新的一项:在2009/01/20提交人的Py++宣布新的软件包连接C/C++编码与蟒蛇。它是基于ctypes.我没有尝试了但是我会!注：这个项目看起来discontiued，Py++.
CFFI:我不知道存在这样一个直到最近，所以现在我不能给我的意见。它看起来像你一样可以定义C功能Python串，并呼吁他们直接从相同的蟒蛇模块。
Cython:这是该方法目前，我正在使用我的项目。基本上你写代码的特殊。pyx文件。这些文件是编译(翻译)到C码而这又是编CPython模块。Cython码可以看起来像普通Python(事实上纯蟒蛇是有效的。pyx Cython文件)，但你还可以更多信息，如可变类型。这个可选的打字允许Cython产生更快C码。代码在Cython文件可以调用的两个纯粹的蟒蛇的功能，但也C和C++的功能(也C++方法)。

我花了一些时间来考虑在Cython，在同样的代码呼C和C++的功能，混合Python和C的变量，等等。但它是一个非常强有力的语言，与一个活跃的(在2014年)和友好的社会。

SWIG 2.0.4已引入了一个提高性能的新-builtin选项。我没有用一个例子程序，做了很多快速调用一个C ++扩展的一些基准测试。我内置使用Boost.Python的，PyBindGen，SIP和SWIG有和没有-builtin选项扩展。下面是结果（平均100次的）：

SWIG with -builtin     2.67s
SIP                    2.70s
PyBindGen              2.74s
boost.python           3.07s
SWIG without -builtin  4.65s

SWIG曾经是最慢的。随着新-builtin选项，SWIG似乎是最快的。

使用用Cython 是相当不错的。你可以写你的C扩展与一个Python语法类似，让其生成C代码。样板包括在内。既然你在Python已经有代码，你所要做的只是你的瓶颈代码和C代码的一些变化会从中产生。

实施例。 hello.pyx：

cdef int hello(int a, int b):
    return a + b

这产生的 601线的样板代码：

/* Generated by Cython 0.10.3 on Mon Jan 19 08:24:44 2009 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #include "structmember.h" #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #if PY_VERSION_HEX < 0x02040000 #define METH_COEXIST 0 #endif #if PY_VERSION_HEX < 0x02050000 typedef int Py_ssize_t; #define PY_SSIZE_T_MAX INT_MAX #define PY_SSIZE_T_MIN INT_MIN #define PyInt_FromSsize_t(z) PyInt_FromLong(z) #define PyInt_AsSsize_t(o) PyInt_AsLong(o) #define PyNumber_Index(o) PyNumber_Int(o) #define PyIndex_Check(o) PyNumber_Check(o) #endif #if PY_VERSION_HEX < 0x02060000 #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) #define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) #define PyVarObject_HEAD_INIT(type, size) \ PyObject_HEAD_INIT(type) size, #define PyType_Modified(t) typedef struct { void *buf; PyObject *obj; Py_ssize_t len; Py_ssize_t itemsize; int readonly; int ndim; char *format; Py_ssize_t *shape; Py_ssize_t *strides; Py_ssize_t *suboffsets; void *internal; } Py_buffer; #define PyBUF_SIMPLE 0 #define PyBUF_WRITABLE 0x0001 #define PyBUF_LOCK 0x0002 #define PyBUF_FORMAT 0x0004 #define PyBUF_ND 0x0008 #define PyBUF_STRIDES (0x0010 | PyBUF_ND) #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) #endif #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #endif #if PY_MAJOR_VERSION >= 3 #define Py_TPFLAGS_CHECKTYPES 0 #define Py_TPFLAGS_HAVE_INDEX 0 #endif #if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3) #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyString_Type PyBytes_Type #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define PyBytes_Type PyString_Type #endif #if PY_MAJOR_VERSION >= 3 #define PyMethod_New(func, self, klass) PyInstanceMethod_New(func) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #else #define _USE_MATH_DEFINES #endif #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #include <math.h> #define __PYX_HAVE_API__helloworld #ifdef __GNUC__ #define INLINE __inline__ #elif _WIN32 #define INLINE __inline #else #define INLINE #endif typedef struct {PyObject **p; char *s; long n; char is_unicode; char intern; char is_identifier;} __Pyx_StringTabEntry; /*proto*/ static int __pyx_skip_dispatch = 0; /* Type Conversion Predeclarations */ #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_FromString PyString_FromString #define __Pyx_PyBytes_AsString PyString_AsString #else #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_AsString PyBytes_AsString #endif #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) static INLINE int __Pyx_PyObject_IsTrue(PyObject* x); static INLINE PY_LONG_LONG __pyx_PyInt_AsLongLong(PyObject* x); static INLINE unsigned PY_LONG_LONG __pyx_PyInt_AsUnsignedLongLong(PyObject* x); static INLINE Py_ssize_t __pyx_PyIndex_AsSsize_t(PyObject* b); #define __pyx_PyInt_AsLong(x) (PyInt_CheckExact(x) ? PyInt_AS_LONG(x) : PyInt_AsLong(x)) #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) static INLINE unsigned char __pyx_PyInt_unsigned_char(PyObject* x); static INLINE unsigned short __pyx_PyInt_unsigned_short(PyObject* x); static INLINE char __pyx_PyInt_char(PyObject* x); static INLINE short __pyx_PyInt_short(PyObject* x); static INLINE int __pyx_PyInt_int(PyObject* x); static INLINE long __pyx_PyInt_long(PyObject* x); static INLINE signed char __pyx_PyInt_signed_char(PyObject* x); static INLINE signed short __pyx_PyInt_signed_short(PyObject* x); static INLINE signed int __pyx_PyInt_signed_int(PyObject* x); static INLINE signed long __pyx_PyInt_signed_long(PyObject* x); static INLINE long double __pyx_PyInt_long_double(PyObject* x); #ifdef __GNUC__ /* Test for GCC > 2.95 */ #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* __GNUC__ > 2 ... */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ > 2 ... */ #else /* __GNUC__ */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char **__pyx_f; static void __Pyx_AddTraceback(const char *funcname); /*proto*/ /* Type declarations */ /* Module declarations from helloworld */ static int __pyx_f_10helloworld_hello(int, int); /*proto*/ /* Implementation of helloworld */ /* "/home/nosklo/devel/ctest/hello.pyx":1 * cdef int hello(int a, int b): # <<<<<<<<<<<<<< * return a + b * */ static int __pyx_f_10helloworld_hello(int __pyx_v_a, int __pyx_v_b) { int __pyx_r; /* "/home/nosklo/devel/ctest/hello.pyx":2 * cdef int hello(int a, int b): * return a + b # <<<<<<<<<<<<<< * */ __pyx_r = (__pyx_v_a + __pyx_v_b); goto __pyx_L0; __pyx_r = 0; __pyx_L0:; return __pyx_r; } static struct PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; static void __pyx_init_filenames(void); /*proto*/ #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "helloworld", 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static int __Pyx_InitCachedBuiltins(void) { return 0; return -1; } static int __Pyx_InitGlobals(void) { return 0; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC inithelloworld(void); /*proto*/ PyMODINIT_FUNC inithelloworld(void) #else PyMODINIT_FUNC PyInit_helloworld(void); /*proto*/ PyMODINIT_FUNC PyInit_helloworld(void) #endif { __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Library function declarations ---*/ __pyx_init_filenames(); /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("helloworld", __pyx_methods, 0, 0, PYTHON_API_VERSION); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; #if PY_MAJOR_VERSION < 3 Py_INCREF(__pyx_m); #endif __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_skip_dispatch = 0; /*--- Global init code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "/home/nosklo/devel/ctest/hello.pyx":1 * cdef int hello(int a, int b): # <<<<<<<<<<<<<< * return a + b * */ #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif __pyx_L1_error:; __Pyx_AddTraceback("helloworld"); #if PY_MAJOR_VERSION >= 3 return NULL; #endif } static const char *__pyx_filenames[] = { "hello.pyx", }; /* Runtime support code */ static void __pyx_init_filenames(void) { __pyx_f = __pyx_filenames; } #include "compile.h" #include "frameobject.h" #include "traceback.h" static void __Pyx_AddTraceback(const char *funcname) { PyObject *py_srcfile = 0; PyObject *py_funcname = 0; PyObject *py_globals = 0; PyObject *empty_string = 0; PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(__pyx_filename); #else py_srcfile = PyUnicode_FromString(__pyx_filename); #endif if (!py_srcfile) goto bad; if (__pyx_clineno) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, __pyx_clineno); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, __pyx_clineno); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_globals = PyModule_GetDict(__pyx_m); if (!py_globals) goto bad; #if PY_MAJOR_VERSION < 3 empty_string = PyString_FromStringAndSize("", 0); #else empty_string = PyBytes_FromStringAndSize("", 0); #endif if (!empty_string) goto bad; py_code = PyCode_New( 0, /*int argcount,*/ #if PY_MAJOR_VERSION >= 3 0, /*int kwonlyargcount,*/ #endif 0, /*int nlocals,*/ 0, /*int stacksize,*/ 0, /*int flags,*/ empty_string, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ __pyx_lineno, /*int firstlineno,*/ empty_string /*PyObject *lnotab*/ ); if (!py_code) goto bad; py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ py_globals, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = __pyx_lineno; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); Py_XDECREF(empty_string); Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* Type Conversion Functions */ static INLINE Py_ssize_t __pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject* x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { if (x == Py_True) return 1; else if (x == Py_False) return 0; else return PyObject_IsTrue(x); } static INLINE PY_LONG_LONG __pyx_PyInt_AsLongLong(PyObject* x) { if (PyInt_CheckExact(x)) { return PyInt_AS_LONG(x); } else if (PyLong_CheckExact(x)) { return PyLong_AsLongLong(x); } else { PY_LONG_LONG val; PyObject* tmp = PyNumber_Int(x); if (!tmp) return (PY_LONG_LONG)-1; val = __pyx_PyInt_AsLongLong(tmp); Py_DECREF(tmp); return val; } } static INLINE unsigned PY_LONG_LONG __pyx_PyInt_AsUnsignedLongLong(PyObject* x) { if (PyInt_CheckExact(x)) { long val = PyInt_AS_LONG(x); if (unlikely(val < 0)) { PyErr_SetString(PyExc_TypeError, "Negative assignment to unsigned type."); return (unsigned PY_LONG_LONG)-1; } return val; } else if (PyLong_CheckExact(x)) { return PyLong_AsUnsignedLongLong(x); } else { PY_LONG_LONG val; PyObject* tmp = PyNumber_Int(x); if (!tmp) return (PY_LONG_LONG)-1; val = __pyx_PyInt_AsUnsignedLongLong(tmp); Py_DECREF(tmp); return val; } } static INLINE unsigned char __pyx_PyInt_unsigned_char(PyObject* x) { if (sizeof(unsigned char) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); unsigned char val = (unsigned char)long_val; if (unlikely((val != long_val) || (long_val < 0))) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned char"); return (unsigned char)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE unsigned short __pyx_PyInt_unsigned_short(PyObject* x) { if (sizeof(unsigned short) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); unsigned short val = (unsigned short)long_val; if (unlikely((val != long_val) || (long_val < 0))) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned short"); return (unsigned short)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE char __pyx_PyInt_char(PyObject* x) { if (sizeof(char) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); char val = (char)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to char"); return (char)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE short __pyx_PyInt_short(PyObject* x) { if (sizeof(short) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); short val = (short)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to short"); return (short)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE int __pyx_PyInt_int(PyObject* x) { if (sizeof(int) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); int val = (int)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE long __pyx_PyInt_long(PyObject* x) { if (sizeof(long) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); long val = (long)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE signed char __pyx_PyInt_signed_char(PyObject* x) { if (sizeof(signed char) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); signed char val = (signed char)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed char"); return (signed char)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE signed short __pyx_PyInt_signed_short(PyObject* x) { if (sizeof(signed short) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); signed short val = (signed short)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed short"); return (signed short)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE signed int __pyx_PyInt_signed_int(PyObject* x) { if (sizeof(signed int) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); signed int val = (signed int)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed int"); return (signed int)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE signed long __pyx_PyInt_signed_long(PyObject* x) { if (sizeof(signed long) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); signed long val = (signed long)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to signed long"); return (signed long)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } } static INLINE long double __pyx_PyInt_long_double(PyObject* x) { if (sizeof(long double) < sizeof(long)) { long long_val = __pyx_PyInt_AsLong(x); long double val = (long double)long_val; if (unlikely((val != long_val) )) { PyErr_SetString(PyExc_OverflowError, "value too large to convert to long double"); return (long double)-1; } return val; } else { return __pyx_PyInt_AsLong(x); } }

的观察：基于由pybindgen开发进行的基准，存在的Boost.Python和大口之间没有显著差异。我没有做我自己的基准测试来验证有多少，这取决于有正确使用Boost.Python的功能。

请注意也有可能是一个原因，pybindgen似乎是一般相当多的速度比痛饮和Boost.Python的：它的可能的不会产生作为一个多才多艺与其他两个结合。举例来说，异常传播，调用的参数类型检查，等等。我还没有机会使用pybindgen，但是我打算。

升压是一般比较大的包安装，和我最后一次见到你不能只安装升压蟒你很可能需要整个Boost库。正如其他人所说的编译将是缓慢的，由于大量使用模板编程，这也意味着在编译时通常非常模糊的错误消息。

摘要：鉴于是SWIG多么容易安装和使用，它产生体面的结合是强大的，多功能的，而且一个界面文件使你的C ++的DLL可以从像LUA，C＃和Java几种其他语言，我赞成过来Boost.Python的。但是，除非你真的需要多语言支持，我会采取在PyBindGen的密切关注，因为它的本意是速度，并密切关注稳健性和结合它产生的通用性。

因为你是关心速度和开销，我建议考虑 PyBindGen .

我有经验，利用它来包裹大内部的C++图书馆。在尝试口，SIP，并提升。蟒我喜欢PyBindGen，原因如下：

一PyBindGen包装是纯-蟒蛇，没有必要学习另一种文件的格式

PyBindGen产生Python C API calls直接的是，没有速抢劫间接层喜欢痛饮.

所产生的C码是干净的和简单明了的。我喜欢Cython太多，但试图读取它的C输出的可能是困难的时候。

STL序列容器的支持(我们使用了大量的标准::矢量的)

有是龙这里。不要痛饮，不刺激。对于任何复杂的工程你的代码，以填补自己，使他们的工作很快就会变得难以管理。如果它是一个普通的C API到库（无类），你可以使用ctypes的。这将是很容易和方便，你将不必花时间通过这些迷宫式封装项目的文档拖网试图找到你所需要的功能的一个小小的音符。

如果它不是一个大的扩展，提高::蟒蛇也可能是一种选择，它的执行速度比痛饮更快，因为您可以控制发生了什么，但它会需要更长的时间到dev。

反正痛饮的开销是可以接受如果单个呼叫中的工作的量是足够大。例如，如果你的问题是，你必须要移动到C / C ++的一些中等规模的逻辑块，而该块是一个严密的循环中调用频繁，你可能必须避免痛饮，但我真的不能相信任何真实世界的例子除了脚本图形着色器。

在Python代码放弃之前，看看 ShedSkin 。他们声称比Psyco的更好的性能上的一些代码（和还指出，它仍然是实验性的）。

否则，有几种选择用于结合C / C ++代码蟒。

升压是冗长编译但真正最灵活和易于使用的溶液中。

我从来没有使用痛饮但相比提高，它不是那么灵活，因为它是通用的绑定框架，而不是一个框架，致力于蟒蛇。

接着选择是的Pyrex 。它允许编写被编译为C扩展伪Python代码。

有一篇文章值得一读的话题 Cython,pybind11,cffi–哪个工具应该是你的选择？

快速回顾为不耐烦:

Cython 编译python C/C++允许你嵌入你C/C++进蟒蛇的代码。使用静态约束力。为蟒蛇的程序员。

pybind11 (和提升。蟒)是相反。绑好你的东西，在编制时间从C++侧。C++编程人员。

CFFI 可以让你结合本地的动态的东西在运行时间。简单的使用，但是高性能的惩罚。

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow