一、扩展理论基础

概念：
任何可以集成或导入另一个Python脚本的代码都是一个扩展
举例：将C代码封装进Python中

什么时候需要扩展python：
1、需要python没有的额外功能
2、改善瓶颈性能。把软件开发过程中的瓶颈部分在扩展中实现
3、隐藏专有代码。实现自我研究成果保护

什么情况下不应该扩展python：
1、必须编写c/c++代码
2、需要手动管理应用

二、扩展代码编写

编写python扩展的3个步骤

2.1、创建应用代码：Extest1.c

所有需要成为扩展的代码应组成一个独立的库，这些代码将作为一个Python模块存在。创建测试代码来保证代码的正确性

#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
  
int fac(int n)  	                      //递归阶乘
{  
	if (n < 2) return (1); 
	return (n) * fac(n-1); 
}  

char *reverse(char *s)                    //字符串逆序
{  
	register char t,  *p = s, *q = (s + (strlen(s)-1));  
	while (p < q)  
	{  
		t = *p;  
		*p++ = *q;  
		*q-- = t;  
	}  
	return s;  
}  

int main()  
{  
	char s[BUFSIZ];  
	printf("4! == %d\n", fac(4));  
	printf("8! == %d\n", fac(8));  
	printf("12! == %d\n", fac(12));  
	strcpy(s, "abcdef");  
	printf("reversing 'abcdef', we get '%s'\n", reverse(s));  
	strcpy(s, "madam");  
	printf("reversing 'madam', we get '%s'\n", reverse(s));  
	return 0;  
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

2.2、根据样板编写封装代码

样板代码主要有四部分
1、包含python头文件。#include "Python.h"
2、为每一个模块函数添加形如PyObject* Module_func()的封装函数
—-需要为所有想被Python环境访问的函数增加一个静态函数，函数返回类型是PyObject*，函数名前要加上模块名和一个下划线。从后面来看就是，与普通的Python模块导入没有什么差别，即在Python解释器中能先import Extest，再通过Extest.fac()来访问上述C代码中的fac()函数。
—-包装函数的用处就是，先把Python的值传给C，然后调用相关函数，得到相应的结果，再把这个结果转换成Python对象，传回给Python。从Python到C，要用到PyArg_Parse*()函数，从C到Python要用到Py_BuildValue()函数。
——–a、PyArg_Parse*()函数接受一个字符串流，并根据一个指定的格式字符串进行解析，把结果放入到相应的指针所指的变量中。若返回1，表示解析成功，返回0，表示解析失败。
——–b、Py_BuildValue()，把所有的参数按格式字符串所指定的格式转换成一个Python对象

3、为每一个模块函数添加一个PyMethodDef ModuleMethods[]数组/表
4、添加模块初始化函数void initModule()

#include<stdio.h>  
#include<stdlib.h>  
#include<string.h>  
  
int fac(int n)  
{  
	if (n < 2) return (1);  
	return (n) * fac(n-1);   
}

char *reverse(char *s)  
{  
	register char t,  *p = s,  *q = (s + (strlen(s)-1));  
	while (s &&(p < q))  
	{  
		t = *p;  
		*p++ = *q;  
		*q-- = t;  
	}  
	return s;  
}  

int test()  
{  
	char s[BUFSIZ];  
	printf("4! == %d\n", fac(4));  
	printf("8! == %d\n", fac(8));  
	printf("12! == %d\n", fac(12));  
	strcpy(s, "abcdef");  
	printf("reversing 'abcdef', we get '%s'\n", reverse(s));  
	strcpy(s, "madam");  
	printf("reversing 'madam', we get '%s'\n", reverse(s));  
	return 0;  
} 
 
#include "Python.h"                                   //Python头文件  
  
//两个包装函数Extest_fac和Extest_doppel  
static PyObject *  
Extest_fac(PyObject *self, PyObject *args)  
{  
	int num;                                          //解析结果  
	if (!PyArg_ParseTuple(args, "i", &num))           //PyArg_ParseTuple(args, "i", &num)就是将传入的数据解析，i表示希望得到整型变量，如果传入正确，将它保存到num变量中  
		return NULL;                                  //如果传入错误，返回NULL  
	return (PyObject*)Py_BuildValue("i", fac(num));   //直接将结果转为Python的整型返回  
}  
static PyObject *  
Extest_doppel(PyObject *self, PyObject *args)  
{  
	char *orig_str;                                   //原始字符串  
	char *dupe_str;                                   //反转后的字符串  
	PyObject* retval;  
	if (!PyArg_ParseTuple(args, "s", &orig_str))  
		return NULL;  
	retval = (PyObject*)Py_BuildValue("ss", orig_str, dupe_str=reverse(strdup(orig_str)));                 
	//'ss'就表示返回一个含有两个字符串的元组，strdup是复制字符串，要复制一份原始字符串

	free(dupe_str);                                  //释放内存  
	return retval;  
}  

//测试函数，将Extest1中的main()改为test()  
static PyObject *  
Extest_test(PyObject *self, PyObject *args)  
{  
	test();  
	return (PyObject*)Py_BuildValue("");             //返回空字符串给Python  
}  

//把包装函数列在某个地方，以便Python解释器能够导入并调用  
static PyMethodDef  
ExtestMethods[] =                                   //该数组由多个二维数组组成，每个数组包含一个函数的信息，最后的NULL表示列表的结束
{  
	{"fac", Extest_fac, METH_VARARGS },             //第一项是函数在Python中的名字，第二项是相应的包装函数的名字，第三项是METH_VARARGS常量，该常量表示参数以元组形式传入  
	{"doppel", Extest_doppel, METH_VARARGS },  
	{"test", Extest_test, METH_VARARGS },  
	{NULL, NULL },  
};  

//模块初始化函数void initModule()，这部分代码在模块导入时被解释器调用  
void initExtest()  
{  
	Py_InitModule("Extest", ExtestMethods);  
}  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84

2.3、编译并测试(此处只解读编译)

1、创建setup.py
2、运行setup.py来编译并链接代码
3、在python中导入模块
4、添加测试函数

#! /usr/bin/python
#-*-coding: utf-8-*-  

from distutils.core import setup, Extension  
MOD = 'Extest'  
setup(name=MOD, ext_modules=[Extension(MOD, sources=['Extest2.c'])])   
#在编译扩展之前，需为每一个扩展创建Extension实例，本例中是'Extest'，后面跟的sources是所有源代码的文件列表，本例中是'Extest2.c'  
#setup()需两个参数，一个是名字参数，表示要编译哪个东西，另外一个是列表，列出要编译的对象

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8