C扩展python的module和Type

有许多理由给CPython写扩展，比如 1.性能低 2.重复用别人的C/C++代码 3.在自己的程序中定制python 4.为了方便 等等。

写这种扩展其实都是套路，不过最好要有对CPython源码有点熟悉。

添加C完成的 module有两种方法

1.直接修改python源代码，写好自己的module。静态编译到CPython中去.

2.将module做成dll(pyd)文件，然后动态加载。

套路

Python代码调用C代码套路：

将被调用C函数包装成一个进PyCFunction函数，

在这个函数包装函数中，拆开python传进来的参数

调用目标C函数

C调用python代码套路：

将Python要用到参数做成PyTupleObject,PyDictObject

调用PyObject_Call(callable,tuple,dict)

这个过程中要注意各种ref_count增减规则，可能会导致内存泄漏，一般规则似乎是，

在创建对象的时候，各种new函数会增加ref_cnt,

在传递参数的时候，被调函数不会负责额外ref_cnt，但是不需要额外的inc,dec。

在作为返回值的时候，如果在调用函数中，需要把这个返回值存储到某个地方的，那么inc一次。

整个原则就是在我们需要额外存储一下的时候，inc一次，在作为参数传递或者返回值，但是不会被赋值到其他地方的，那么就不需要inc了

一、添加module

myext module,将下面这份C代码编译成myext.dll(pyd)，放到python.exe目录

#include <Python.h>

static PyObject *myextError;
static PyObject *callable;
//static PyObject *moduleself;

static PyObject* myext_system(PyObject *self, PyObject *args);
static PyObject* myext_call(PyObject *self,PyObject *args,PyObject* kwargs);

static PyMethodDef myextMethods[]={
{"system",  myext_system, METH_VARARGS,"Execute a shell command."},
{"call",(PyCFunction)myext_call,METH_VARARGS|METH_KEYWORDS,"None"},
{NULL, NULL, 0, NULL}
};

//初始化module
PyMODINIT_FUNC initmyext(void)
{
PyObject *m;
//创建PyModuleObject对象，存储到PyInterpreterState.modules中去
m = Py_InitModule("myext", myextMethods);
if (m == NULL)
return;
//创建一个error class object
myextError = PyErr_NewException("myext.error", NULL, NULL);
Py_INCREF(myextError);
//将error 添加到m.dict
PyModule_AddObject(m, "error", myextError);
}

/*
python代码调用C/C++代码,步骤
1.将被调用C函数包装成一个进PyCFunction函数，
2.在这个函数包装函数中，拆开python传进来的参数
3.调用目标C函数
*/
static PyObject* myext_system(PyObject *self, PyObject *args)
{
const char *command;
int sts;

if (!PyArg_ParseTuple(args, "s", &command))
return NULL;
sts = system(command);
if (sts < 0) {
PyErr_SetString(myextError, "System command failed");
return NULL;
}

return Py_BuildValue("i",sts);//这种虽然可以使用，但是效率显然低,PyLong_FromLong
}

/*
C代码调用Python代码,步骤
1.将Python要用到参数做成PyTupleObject,PyDictObject
2.调用PyObject_Call(callable,tuple,dict)
*/
static PyObject* myext_call(PyObject *self,PyObject* args,PyObject* kwargs){

if ((args!=NULL&&!PyTuple_Check(args))
||(kwargs!=NULL&&!PyDict_Check(kwargs)) ){
PyErr_SetString(PyExc_TypeError,"parameter type error");
return NULL;
}

Py_ssize_t size=PyTuple_Size(args);
if (size<1){
PyErr_SetString(PyExc_Exception,"first parameter must be a callable object");
return NULL;
}

PyObject* callablePositionArgs=NULL;
PyObject* callable=NULL;

callable=PyTuple_GetItem(args,0);
if (!PyCallable_Check(callable)){
PyErr_SetString(PyExc_Exception,"first parameter must be a callable object");
return NULL;
}

//切割tuple中剩余的值，作为 callable的参数
callablePositionArgs=PyTuple_GetSlice(args,1,size+1);

return PyObject_Call(callable,callablePositionArgs,kwargs);
}

　

python测试代码：

import myext

def fun(a,b,kw1='abc',kw2="abc"):
print "a+b="+str(a+b),kw1,kw2

myext.call(fun,1,333,kw2='xyz')

myext.system("ping www.weibo.com")
raw_input()

测试　　



二、添加PyTypeObject

这个过程相当于给Python添加了新类型，我们从PyTypeObject开始。一个typeobject 就相当于一个类，通常(有列外id情况) Python vm根据这个typeobject的设置来创建 instance，设置一些规则函数和class特性flag，比如compare,iter,call,getset,hash之类的。不同的类有不同的状况，所以有不同的设置。

这个添加的过程感觉最复杂的地方还是Py_XINCREF和Py_XDECREF的部分，有点凌乱。

先解释几个PyTypeObject中的几个字段：

tp_new:这个要new出一个 Type对应的 instance对象来

student_init:这个相当于构造函数，现在越来越觉得构造函数应该叫初始化函数了，C++/C#/java中都应该这么称呼。

tp_methods,tp_members,tp_getset:这里的东西会转换设置到Type的dict/dictproxy中去

student_traverse:在gc.collect的时候回调，在这个函数中检测有可能出现循环引用的成员

student_clear:在gc发现有循环引用之后回调,这个函数的主要目的是用于断开循环引用

student_dealloc:在删除对象的时候回调

tp_basicsize:对象基本部分的大小

tp_itemsize:可变部分对象，每个item的大小。

tp_flags:Py_TPFLAGS_HAVE_GC这个标记在gc的时候才会用到，如果没这个标记应该是不会检测循环引用的。

另外有许多在PyType_Ready的时候会填上，它们大多是从object等等继承而来的。

举个新增类型的栗子：

#include "studenttype.h"

static PyObject* info(StudentObject* self){
return Py_None;
}

static PyMemberDef Student_members[] = {
{"school", T_OBJECT_EX, offsetof(StudentObject, school), 0,"school"},
{"grade", T_INT, offsetof(StudentObject, grade), 0,"grade"},
{"name", T_OBJECT_EX, offsetof(StudentObject, name), 0,"name"},
//{"sex",T_OBJECT,offsetof(StudentObject,sex),0,"sex"},
{NULL}  /* Sentinel */
};

static PyObject* student_new(PyTypeObject* typeobj,PyObject* args,PyObject* kwds){
StudentObject* self=NULL;
self=(StudentObject*)typeobj->tp_alloc(typeobj,0);

if (self!=NULL){
Py_INCREF(Py_None);
self->grade=0;
}

return (PyObject*)self;
}

static void student_dealloc(StudentObject* student){
if (student!=NULL && student->ob_type==&PyStudent_Type){
printf("student dealloc\n");
Py_XDECREF(student->name);
Py_XDECREF(student->school);
Py_XDECREF(student->sex);
Py_CLEAR(student);

if (student==NULL){
printf("removed\n");
}
}
}

static int student_init(StudentObject* self, PyObject* args, PyObject* kwds){

PyObject *name=NULL,*school=NULL,*sex=NULL;
PyObject* tmp;
static char* kwlist[]={"grade","name","school","sex"};
if (!PyArg_ParseTupleAndKeywords(args,
kwds,
"|iSSS",
kwlist,
&self->grade,
&name,
&school,
&sex)){
return -1;
}

if (name){
tmp=self->name;
Py_XINCREF(name);
self->name=name;
Py_XDECREF(tmp);
}

if(school){
tmp=self->school;
Py_XINCREF(school);
self->school=school;
Py_XDECREF(tmp);
}

if(sex){
tmp=self->sex;
Py_XINCREF(sex);
self->sex=sex;
Py_XDECREF(tmp);
}

return 0;
}

//gc回调函数
static int student_traverse(StudentObject *self, visitproc visit, void *arg)
{
if (self->ob_type==&PyStudent_Type){
printf("student_traverse\n");
Py_VISIT(self->name);
Py_VISIT(self->school);
Py_VISIT(self->sex);
}

return 0;
}

//在检测到有循环引用之后会调用这个函数
static int student_clear(StudentObject* student){
printf("student clear1\n");
Py_CLEAR(student->name);
Py_CLEAR(student->school);
Py_CLEAR(student->sex);

return 0;
}

static PyObject* getsex(StudentObject* self,void* closure){
printf("in getsex\n");
//Py_INCREF(self->sex);
return self->sex;
//Py_INCREF(Py_None);
//return Py_None;
}

static int setsex(StudentObject* self,PyObject* value,void* closure){
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "are you joking?");
return -1;
}

if (! PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError, "the sex attribute must be string");
return -1;
}

if (_PyString_Eq(value,PyString_FromString("male"))
|| _PyString_Eq(value,PyString_FromString("female"))){
Py_XDECREF(self->sex);
Py_XINCREF(value);
self->sex = value;
}else{
PyErr_SetString(PyExc_TypeError, "sex type should be female or male");
return -1;
}

return 0;
}

static PyGetSetDef Student_getseters[]={
{"sex",(getter)getsex,(setter)setsex, "about sex",NULL},
{NULL}
};

static PyMethodDef Student_methods[]={
{"info", (PyCFunction)info, METH_NOARGS,"Return detail info of student"},
{NULL}  /* Sentinel */
};

static PyTypeObject PyStudent_Type = {
PyObject_HEAD_INIT(NULL)
0,                         /*ob_size*/
"student",				   /*tp_name*/
sizeof(StudentObject),	   /*tp_basicsize*/
0,                         /*tp_itemsize*/
(destructor)student_dealloc,           /*tp_dealloc  这个 del student的时候会回调到*/
0,                         /*tp_print*/
0,                         /*tp_getattr*/
0,                         /*tp_setattr*/
0,                         /*tp_compare*/
0,                         /*tp_repr*/
0,                         /*tp_as_number*/
0,                         /*tp_as_sequence*/
0,                         /*tp_as_mapping*/
0,                         /*tp_hash */
0,                         /*tp_call*/
0,                         /*tp_str*/
0,                         /*tp_getattro*/
0,                         /*tp_setattro*/
0,                         /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,        /*tp_flags*/
"student",				   /* tp_doc */
(traverseproc)student_traverse, /* tp_traverse */
(inquiry)student_clear,		   /* tp_clear  不明白这个怎么回事*/
0,		                   /* tp_richcompare */
0,		                   /* tp_weaklistoffset */
0,		                   /* tp_iter */
0,		                   /* tp_iternext */
Student_methods,           /* tp_methods */
Student_members,           /* tp_members */
Student_getseters,         /* tp_getset */
0,                         /* tp_base */
0,                         /* tp_dict */
0,                         /* tp_descr_get */
0,                         /* tp_descr_set */
0,                         /* tp_dictoffset */
(initproc)student_init,    /* tp_init */
0,                         /* tp_alloc */
student_new,               /* tp_new */
};

PyTypeObject* initstudenttype(){
//PyStudent_Type.tp_new=PyType_GenericNew;
if (PyType_Ready(&PyStudent_Type)){
return NULL;
}
return &PyStudent_Type;
}

python测试代码：

import myext
import gc
import sys

from myext import student
s=student(grade=2,name='mike',school='thu',sex='male')
#s.name=s;
print("refcnt:",sys.getrefcount(s))
del s
gc.collect()

此处没有循环引用，结果



将s.name=s去掉注释，结果：