Python与C混合编程！是Python和C都不具备的超能力！

编写 c => python 的接口文件

// vectory_py.c
extern \"C\" {
 vector<point_t>* new_vector(){
 return new vector<point_t>;
 }
 void delete_vector(vector<point_t>* v){
 cout << \"destructor called in C++ for \" << v << endl;
 delete v;
 }
 int vector_size(vector<point_t>* v){
 return v->size();
 }
 point_t vector_get(vector<point_t>* v, int i){
 return v->at(i);
 }
 void vector_push_back(vector<point_t>* v, point_t i){
 v->push_back(i);
 }
}

编译： gcc -fPIC -shared -lpython3.6m -o vector_py.so vectory_py.c

编写 ctypes 类型文件

from ctypes import *
class c_point_t(Structure):
 _fields_ = [(\"x\", c_int), (\"y\", c_int)]
class Vector(object):
 lib = cdll.LoadLibrary(\'./vector_py_lib.so\') # class level loading lib
 lib.new_vector.restype = c_void_p
 lib.new_vector.argtypes = []
 lib.delete_vector.restype = None
 lib.delete_vector.argtypes = [c_void_p]
 lib.vector_size.restype = c_int
 lib.vector_size.argtypes = [c_void_p]
 lib.vector_get.restype = c_point_t
 lib.vector_get.argtypes = [c_void_p, c_int]
 lib.vector_push_back.restype = None
 lib.vector_push_back.argtypes = [c_void_p, c_point_t]
 lib.foo.restype = None
 lib.foo.argtypes = []
 def __init__(self):
 self.vector = Vector.lib.new_vector() # pointer to new vector
 def __del__(self): # when reference count hits 0 in Python,
 Vector.lib.delete_vector(self.vector) # call C++ vector destructor
 def __len__(self):
 return Vector.lib.vector_size(self.vector)
 def __getitem__(self, i): # access elements in vector at index
 if 0 <= i < len(self):
 return Vector.lib.vector_get(self.vector, c_int(i))
 raise IndexError(\'Vector index out of range\')
 def __repr__(self):
 return \'[{}]\'.format(\', \'.join(str(self[i]) for i in range(len(self))))
 def push(self, i): # push calls vector\'s push_back
 Vector.lib.vector_push_back(self.vector, i)
 def foo(self): # foo in Python calls foo in C++
 Vector.lib.foo(self.vector)

然后才是调用

from vector import *
a = Vector()
b = c_point_t(10, 20)
a.push(b)
a.foo()
for i in range(len(a)) :
 print(a[i].x)
 print(a[i].y)

为Python写扩展

完成上述的操作后，我头很大，很难想象当项目稍微修改后，我们要跟随变化的代码量有多大！于是换了一种思路，为Python写扩展。

进群：960410445   有惊喜大礼包！

安装Python开发包

yum install -y python36-devel

修改数据交互文件

#include <python3.6m/Python.h>
PyObject* foo()
{
 PyObject* result = PyList_New(0);
 int i = 0, j = 0;
 for (j = 0; j < 2; j++) {
 PyObject* sub = PyList_New(0);
 for (i = 0; i < 100; ++i)
 {
 PyList_Append(sub, Py_BuildValue(\"{s:i, s:i}\", \"x\", i, \"y\", 100 - i));
 }
 PyList_Append(result, sub);
 }
 return result;
}

调用

from ctypes import *
lib = cdll.LoadLibrary(\'./extlist.so\') # class level loading lib
lib.foo.restype = py_object
b = lib.foo()
for i in range(len(b)) :
 for j in range(len(b[i])) :
 d = b[i][j]
 print(d[\'x\'])

很显然，第二种方式中，我已经封装了很复杂的结构了，如果用 c++ 来表示的话，将是：

vector<vector >

遇到的问题

Python C 混编时 Segment

这个问题困扰了我有一段时间，开始一直在纠结是代码哪错了，后来恍然大悟，Python 和 C 的堆栈是完全不同的，而当我在交互大量数据的时候，Python GC 可能会把 C 的内存当作未使用，直接给释放了(尤其是上述第二种方案)，这就是问题所在。(Python GC 中使用的代龄后续专门开文章来说明，欢迎关注公众号 cn_isnap)

这里的解决方案其实有很多，内存能撑过Python前两代的检查就可了，或者是纯C管理。在这里我推荐一种粗暴的解决方案：

对于任何调用Python对象或Python C API的C代码，确保你首先已经正确地获取和释放了GIL。 这可以用 PyGILState_Ensure() 和 PyGILState_Release() 来做到，如下所示：

...
/* Make sure we own the GIL */
PyGILState_STATE state = PyGILState_Ensure();
/* Use functions in the interpreter */
...
/* Restore previous GIL state and return */
PyGILState_Release(state);