在上一篇中我们已经使用c语言实现了一个最简单的扩展模块,这一篇中将在其基础上进行功能的丰富。
首先来考虑如何从外部的Python向C模块传递进参数,foo_bar2展示了如何向C模块传递整数,浮点数,字符串三个参数,其中"ids"指明了传入参数的数据类型。PyArg_ParseTuple负责对args进行解析,若解析失败则返回0.
  1. #include <Python.h>  
  2.  
  3. static PyObject* foo_bar(PyObject* self, PyObject* args) {  
  4.     Py_RETURN_NONE;  
  5. }  
  6.  
  7. static PyObject* foo_bar2(PyObject* self, PyObject* args) {  
  8.     int iNum;  
  9.     double fNum;  
  10.     char* str;  
  11.     if (!PyArg_ParseTuple(args, "ids", &iNum, &fNum, &str)) {  
  12.         return NULL;  
  13.     }  
  14.     Py_RETURN_NONE;  
  15. }  
  16. static PyMethodDef foo_methods[] = {  
  17.     {"bar",(PyCFunction)foo_bar,METH_NOARGS,NULL},  
  18.     {"bar2", (PyCFunction)foo_bar2,METH_VARARGS,NULL},  
  19.     {NULL,NULL,0,NULL}  
  20. };  
  21.  
  22. PyMODINIT_FUNC initfoo() {  
  23.     Py_InitModule3("foo", foo_methods, "My first extension module.");  

 你还可以指定可选的参数,只需要通过在格式字符串中包含一个"|"字符即可,如下所示:

  1. static PyObject* foo_bar2(PyObject* self, PyObject* args) {  
  2.     int iNum;  
  3.     double fNum;  
  4.     char* str;  
  5.     int iNum2 = 4;  
  6.     double fNum2 = 5.0;  
  7.     char *str2 = "hello";  
  8.     if (!PyArg_ParseTuple(args, "ids|ids", &iNum, &fNum, &str,&iNum2, &fNum2, &str2)) {  
  9.         return NULL;  
  10.     }  
  11.     Py_RETURN_NONE;  
 

 你在调用此函数时,前面三个参数是必须要传递的,而后面的则是可选的。

另一种情况是当你的函数接受关键字参数,那么m_flags可设置为METH_VARARGS|METH_KEYWORDS,相应的使用PyArg_ParseTupleAndKeywords来进行参数解析。

函数 PyArg_ParseTupleAndKeywords() 声明如下:

  1. int PyArg_ParseTupleAndKeywords(PyObject* arg, PyObject* kwdict, char* format, char* kwlist[],...); 

参数arg和format定义同 PyArg_ParseTuple() 。参数 kwdict 是关键字字典,用于接受运行时传来的关键字参数。参数 kwlist 是一个NULL结尾的字符串,定义了可以接受的参数名,并从左到右与format中各个变量对应。如果执行成功 PyArg_ParseTupleAndKeywords() 会返回true,否则返回false并抛出异常。

注:嵌套的tuple在使用关键字参数时无法生效,不在kwlist中的关键字参数会导致 TypeError 异常

  1. #include <Python.h> 
  2.  
  3. static PyObject* foo_bar3(PyObject* self, PyObject* args, PyObject* kw) {  
  4.     static char* kwlist[] = {"i", "d", "s",NULL};  
  5.     int iNum = 0;  
  6.     double fNum = 2.0f;  
  7.     char* str = "thing";  
  8.     if (!PyArg_ParseTupleAndKeywords(args,kw,"i|ds",kwlist,&iNum,&fNum,&str)) {  
  9.         printf("ERROR");  
  10.         return NULL;  
  11.     }  
  12.     printf("num is: %d,%f,%s\n",iNum,fNum,str);  
  13.     Py_RETURN_NONE;  
  14. }  
  15. static PyMethodDef foo_methods[] = {  
  16.     {"bar3", (PyCFunction)foo_bar3, METH_VARARGS|METH_KEYWORDS, NULL},  
  17.     {NULL,NULL,0,NULL}  
  18. };  
  19.  
  20. PyMODINIT_FUNC initfoo() {  
  21.     Py_InitModule3("foo", foo_methods, "My first extension module.");  

相应的在函数表里记录如下:

  1. {"foo_bar",(PyCFunction)foo_bar, METH_VARARGS|METH_KEYWORDS,NULL}, 

这样你在python代码中调用时可以传递关键字参数,其中只有i表示的整数是必需的,因此下述调用都是合法的:

  1. import foo  
  2. foo.bar3(1)  
  3. foo.bar3(1,d=2.0)  
  4. foo.bar33(i=1,d=2.0) 

而如果你传递了其他关键参数,则会报TypeError,比如foo.bar3(i=1,dd=3.0,s="fda")

下面来看第二个问题:上面说的PyArg_ParseTuple和PyArg_ParseTupleAndKeywords这两个函数是将传递进C模块的 Python对象转变为C里的数据类型,那么相反的情况如何呢?即如何从C模块返回值到Python程序中。要完成这件事,我们所需要的函数是 Py_BuildValue,示例如下:

  1. #include <Python.h> 
  2.  
  3. static PyObject* foo_add_sub(PyObject* self, PyObject* args) {  
  4.     int num1,num2;  
  5.     if (!PyArg_ParseTuple(args, "ii", &num1, &num2)) {  
  6.         return NULL;  
  7.     }  
  8.     return Py_BuildValue("ii", num1 + num2, num1 - num2);  
  9. }  
  10.  
  11. static PyMethodDef foo_methods[] = {  
  12.     {"add_sub", (PyCFunction)foo_add_sub, METH_VARARGS, NULL},  
  13.     {NULL,NULL,0,NULL}  
  14. };  
  15.  
  16. PyMODINIT_FUNC initfoo() {  
  17.     Py_InitModule3("foo", foo_methods, "My first extension module.");  

这样在Python代码中调用如下:

  1. import foo  
  2. (sum,sub) = foo.add_sub(9,3) 

好了,现在从Python代码传递参数进C模块,以及C模块返回值到Python代码都已经清楚了,下一篇我们将利用这些技术来完成一个实际的C扩展模块