前言(更新:更方便易用的方式在http://www.swig.org/tutorial.html)
大部分的Python的扩展都是用C语言写的,但也很容易移植到C++中。
一般来说,所有能被整合或者导入到其它python脚本的代码,都可以称为扩展。
扩展可以用纯Python来写,也可以用C或者C++之类的编译型的语言来扩展。
就算是相同的架构的两台电脑之间最好也不要互相共享二进制文件,最好在各自的
电脑上编译Python和扩展。因为就算是编译器或者CPU之间的些许差异。
官方文档
需要扩展Python语言的理由:
1. 添加/额外的(非Python)功能,提供Python核心功能中没有提供的部分,比如创建新的
数据类型或者将Python嵌入到其它已经存在的应用程序中,则必须编译。
2. 性能瓶颈的效率提升, 解释型语言一般比编译型语言慢,想要提高性能,全部改写成编译型
语言并不划算,好的做法是,先做性能测试,找出性能瓶颈部分,然后把瓶颈部分在扩展中实现,
是一个比较简单有效的做法。
3. 保持专有源代码的私密,脚本语言一个共同的缺陷是,都是执行的源代码,保密性便没有了。
把一部分的代码从Python转到编译语言就可以保持专有源代码私密性。不容易被反向工程,对涉及
到特殊算法,加密方法,以及软件安全时,这样做就显得很重要。
另一种对代码保密的方式是只发布预编译后的.pyc文件,是一种折中的方法。
创建Python扩展的步骤
1. 创建应用程序代码
#
include
<stdio.h
>
# include <stdlib.h >
# include <string.h >
# define BUFSIZE 10
int fac( int n) {
if (n < 2)
return 1;
return n * fac(n - 1);
}
char *reverse( char *s) {
register char t;
char *p = s;
char *q = (s + (strlen(s) - 1));
while (p < q) {
t = *p;
*p ++ = *q;
*q -- = t;
}
return s;
}
int main() {
char s[BUFSIZE];
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 <stdlib.h >
# include <string.h >
# define BUFSIZE 10
int fac( int n) {
if (n < 2)
return 1;
return n * fac(n - 1);
}
char *reverse( char *s) {
register char t;
char *p = s;
char *q = (s + (strlen(s) - 1));
while (p < q) {
t = *p;
*p ++ = *q;
*q -- = t;
}
return s;
}
int main() {
char s[BUFSIZE];
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;
}
一般是需要写main()函数,用于单元测试
使用gcc进行编译
>gcc Extest.c -o Extest
执行
>./Extest
![](https://i-blog.csdnimg.cn/blog_migrate/4f9812893257507f85a4b63618401bee.png)
2. 利用样板来包装代码
整个扩展的实现都是围绕"包装"这个概念来进行的。你的设计要尽可能让你的实现语言与Python无缝结合。
接口的代码又被称为"样板"代码,它是你的代码与Python解释器之间进行交互所必不可少的部分:
我们的样板代码分为4步:
a. 包含python的头文件
需要找到python的头文件在哪,一般是在/usr/local/include/python2.x中
在上面的C代码中加入#include "Python.h"
b. 为每个模块的每一个函数增加一个型如PyObject* Module_func()的包装函数
包装函数的用处就是先把python的值传递给c,再把c中函数的计算结果转换成Python对象返回给python。
需要为所有想被Python环境访问到的函数都增加一个静态函数,返回类型为PyObject *,函数名格式为
模块名_函数名;
static PyObject
* Extest_fac(PyObject
*self, PyObject
*args) {
int res; //计算结果值
int num; //参数
PyObject * retval; //返回值
//i表示需要传递进来的参数类型为整型,如果是,就赋值给num,如果不是,返回NULL;
res = PyArg_ParseTuple(args, "i", &num);
if ( !res) {
//包装函数返回NULL,就会在Python调用中产生一个TypeError的异常
return NULL;
}
res = fac(num);
//需要把c中计算的结果转成python对象,i代表整数对象类型。
retval = (PyObject *)Py_BuildValue( "i", res);
return retval;
}
int res; //计算结果值
int num; //参数
PyObject * retval; //返回值
//i表示需要传递进来的参数类型为整型,如果是,就赋值给num,如果不是,返回NULL;
res = PyArg_ParseTuple(args, "i", &num);
if ( !res) {
//包装函数返回NULL,就会在Python调用中产生一个TypeError的异常
return NULL;
}
res = fac(num);
//需要把c中计算的结果转成python对象,i代表整数对象类型。
retval = (PyObject *)Py_BuildValue( "i", res);
return retval;
}
也可以写成更简短,可读性更强的形式:
static PyObject
* Extest_fac(PyObject
*self, PyObject
*args) {
int m;
if ( !(PyArg_ParseTuple(args, "i", &num))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "i", fac(num));
}
int m;
if ( !(PyArg_ParseTuple(args, "i", &num))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "i", fac(num));
}
下面是python和c对应的类型转换参数表:
![](https://i-blog.csdnimg.cn/blog_migrate/834f3226e1b30eccab17a6c67f78e646.png)
这里还有一个Py_BuildValue的用法表:
![](https://i-blog.csdnimg.cn/blog_migrate/12e4c40e92fe13c9d02a892092070284.png)
reverse函数的包装也类似:
static PyObject
*
Extest_reverse(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "s", reverse(orignal));
}
Extest_reverse(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "s", reverse(orignal));
}
也可以再改造成返回包含原始字串和反转字串的tuple的函数
static PyObject
*
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
//ss,就可以返回两个字符串,应该reverse是在原字符串上进行操作,所以需要先strdup复制一下
return (PyObject *)Py_BuildValue( "ss", orignal, reverse(strdup(orignal)));
}
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
//ss,就可以返回两个字符串,应该reverse是在原字符串上进行操作,所以需要先strdup复制一下
return (PyObject *)Py_BuildValue( "ss", orignal, reverse(strdup(orignal)));
}
上面的代码有什么问题呢?
和c语言相关的问题,比较常见的就是内存泄露。。。上面的例子中,Py_BuildValue()函数生成
要返回Python对象的时候,会把转入的数据复制一份。上面的两个字符串都被复制出来。但是
我们申请了用于存放第二个字符串的内存,在退出的时候没有释放掉它。于是内存就泄露了。
正确的做法是:先生成返回的python对象,然后释放在包装函数中申请的内存。
static PyObject
*
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
char *reversed;
PyObject * retval;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
retval = (PyObject *)Py_BuildValue( "ss", orignal, reversed =reverse(strdup(orignal)));
free(reversed);
return retval;
}
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
char *reversed;
PyObject * retval;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
retval = (PyObject *)Py_BuildValue( "ss", orignal, reversed =reverse(strdup(orignal)));
free(reversed);
return retval;
}
c. 为每个模块增加一个型如PyMethodDef ModuleMethods[]的数组
我们已经创建了几个包装函数,需要在某个地方把它们列出来,以便python解释器能够导入并调用它们。
这个就是ModuleMethods[]数组所需要做的事情。
格式如下 ,每一个数组都包含一个函数的信息,最后一个数组放置两个NULL值,代表声明结束
static PyMethodDef
ExtestMethods[] = {
{ "fac", Extest_fac, METH_VARARGS},
{ "doppel", Extest_doppel, METH_VARARGS},
{ "reverse", Extest_reverse, METH_VARARGS},
{NULL, NULL},
};
ExtestMethods[] = {
{ "fac", Extest_fac, METH_VARARGS},
{ "doppel", Extest_doppel, METH_VARARGS},
{ "reverse", Extest_reverse, METH_VARARGS},
{NULL, NULL},
};
METH_VARARGS代表参数以tuple的形式传入。如果我们需要使用PyArg_ParseTupleAndKeywords()
函数来分析关键字参数的话,这个标志常量应该写成: METH_VARARGS & METH_KEYWORDS,进行逻辑与运算。
d. 增加模块初始化函数void initMethod()
最后的工作就是模块的初始化工作。这部分代码在模块被python导入时进行调用。
void initExtest() {
Py_InitModule( "Extest", ExtestMethods);
}
Py_InitModule( "Extest", ExtestMethods);
}
最终代码如下:
#
include
<stdio.h
>
# include <stdlib.h >
# include <string.h >
# include "Python.h"
# define BUFSIZE 10
int fac( int n) {
if (n < 2)
return 1;
return n * fac(n - 1);
}
char *reverse( char *s) {
register char t;
char *p = s;
char *q = (s + (strlen(s) - 1));
while (p < q) {
t = *p;
*p ++ = *q;
*q -- = t;
}
return s;
}
static PyObject *
Extest_fac(PyObject *self, PyObject *args) {
int res;
int num;
PyObject * retval;
res = PyArg_ParseTuple(args, "i", &num);
if ( !res) {
return NULL;
}
res = fac(num);
retval = (PyObject *)Py_BuildValue( "i", res);
return retval;
}
static PyObject *
Extest_reverse(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "s", reverse(orignal));
}
static PyObject *
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
char *resv;
PyObject *retval;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
retval = (PyObject *)Py_BuildValue( "ss", orignal, resv =reverse(strdup(orignal)));
free(resv);
return retval;
}
static PyMethodDef
ExtestMethods[] = {
{ "fac", Extest_fac, METH_VARARGS},
{ "doppel", Extest_doppel, METH_VARARGS},
{ "reverse", Extest_reverse, METH_VARARGS},
{NULL, NULL},
};
void initExtest() {
Py_InitModule( "Extest", ExtestMethods);
}
int main() {
char s[BUFSIZE];
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));
test();
return 0;
}
# include <stdlib.h >
# include <string.h >
# include "Python.h"
# define BUFSIZE 10
int fac( int n) {
if (n < 2)
return 1;
return n * fac(n - 1);
}
char *reverse( char *s) {
register char t;
char *p = s;
char *q = (s + (strlen(s) - 1));
while (p < q) {
t = *p;
*p ++ = *q;
*q -- = t;
}
return s;
}
static PyObject *
Extest_fac(PyObject *self, PyObject *args) {
int res;
int num;
PyObject * retval;
res = PyArg_ParseTuple(args, "i", &num);
if ( !res) {
return NULL;
}
res = fac(num);
retval = (PyObject *)Py_BuildValue( "i", res);
return retval;
}
static PyObject *
Extest_reverse(PyObject *self, PyObject *args) {
char *orignal;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
return (PyObject *)Py_BuildValue( "s", reverse(orignal));
}
static PyObject *
Extest_doppel(PyObject *self, PyObject *args) {
char *orignal;
char *resv;
PyObject *retval;
if ( !(PyArg_ParseTuple(args, "s", &orignal))) {
return NULL;
}
retval = (PyObject *)Py_BuildValue( "ss", orignal, resv =reverse(strdup(orignal)));
free(resv);
return retval;
}
static PyMethodDef
ExtestMethods[] = {
{ "fac", Extest_fac, METH_VARARGS},
{ "doppel", Extest_doppel, METH_VARARGS},
{ "reverse", Extest_reverse, METH_VARARGS},
{NULL, NULL},
};
void initExtest() {
Py_InitModule( "Extest", ExtestMethods);
}
int main() {
char s[BUFSIZE];
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));
test();
return 0;
}
3. 编译与测试
为了让你的新python扩展能够被创建,你需要把它们与python库放在一起编译。python中的distutils包被
用来编译,安装和分发这些模块,扩展和包。步骤如下:
a. 创建setup.py
我们在安装python第三方包的时候,很多情况下会用到python setup.py install这个命令,
下面我们来了解一下setup.py文件的内容。
编译的最主要的内容由setup函数完成,你需要为每一个扩展创建一个Extension实例,在这里我们只有一个
扩展,所以只需要创建一个实例。
Extension('Extest', sources=['Extest.c']),第一个参数是扩展的名字,如果模块是包的一部分,还需要加".";
第二个参数是源代码文件列表
setup('Extest', ext_modules=[...]),第一个参数表示要编译哪个东西,第二个参数列出要编译的Extension对象。
#!/usr/bin/env python
from distutils.core import setup, Extension
MOD = 'Extest'
setup(name =MOD, ext_modules =[Extension(MOD, sources[ 'Extest.c'])])
from distutils.core import setup, Extension
MOD = 'Extest'
setup(name =MOD, ext_modules =[Extension(MOD, sources[ 'Extest.c'])])
setup函数还有很多选项可以设置。详情可见官网。
b. 通过运行setup.py来编译和连接你的代码
在shell中运行命令
>python setup.py build
当你报错如:无法找到Python.h文件
![](https://i-blog.csdnimg.cn/blog_migrate/3be3db9e980258c66b59c590c10ab4ca.png)
那么说明你没有安装python-dev包,需要去官网下载源码包重装自己编译安装一下python。
Python.h文件一般会出现在/usr/include/Python2.X文件夹中,我这里反正是没有的。。。
只有重新编译一个python...
我现在linux系统上的python版本是2.6.6,我下载一个相同版本的源码,也可以下载更高版本。
解压源码包
> tar xzf Python-2.6.6.tgz
> cd Python-2.6.6.tgz
编译安装Python
> ./configure --prefix=/usr/local/python2.6
> make
> sudo make install
创建一个新编译python的链接
> sudo ln -sf /usr/local/python2.6/bin/python2.6 /usr/bin/python2.6
测试一下,可用
![](https://i-blog.csdnimg.cn/blog_migrate/13517b09cb5d027916b5f4afd3eb22ea.png)
使用这种方法可以在Linux上运行不同版本的python.
Python.h文件也在/usr/local/python2.6/include/python2.6路径下找到。
重新运行编译
![](https://i-blog.csdnimg.cn/blog_migrate/aa7d812d16a7306f40f14114498e6d6d.png)
编译成功后,你的扩展就会被创建在bulid/lib.*目录下。你会看到一个.so文件,这是linux下的
动态库文件:
![](https://i-blog.csdnimg.cn/blog_migrate/d67456bac24f4710875b94b9bba0cde9.png)
c. 进行调试
你可以直接用python代码调用进行测试:
#!/usr/bin/python
from ctypes import *
import os
#需要使用绝对路径
extest = cdll.LoadLibrary( os.getcwd() + '/Extest.so')
print extest.fac( 4)
from ctypes import *
import os
#需要使用绝对路径
extest = cdll.LoadLibrary( os.getcwd() + '/Extest.so')
print extest.fac( 4)
也可以在当前目录下执行命令,安装到你的python路径下
> python setup.py install
![](https://i-blog.csdnimg.cn/blog_migrate/840ba9de19b8cddef10ab4bf4137f281.png)
安装成功的话,直接导入测试:
![](https://i-blog.csdnimg.cn/blog_migrate/5cc693629c8342dcb5f857a25ba0db3d.png)
最后需要注意一点的是,原来的c文件中有一个main函数,因为一个系统中只能有一个main
函数,所以为了不起冲突,可以把main函数改成test函数,再用Extest_test()包装函数处理一下,
再加入ExtestMethods数组,这样就可以调用这个测试函数了。
static PyObject
*
Extest_test(PyObject *self, PyObject *args) {
test();
#返回空的话,就使用下面这一句
return (PyObject *)Py_BuildValue( "");
}
Extest_test(PyObject *self, PyObject *args) {
test();
#返回空的话,就使用下面这一句
return (PyObject *)Py_BuildValue( "");
}
简单性能比较
测试代码
import Extest
import time
start = time.time()
a = Extest.reverse( "abcd")
timeC = time.time() - start
print 'C costs', timeC, 'the result is', a
start = time.time()
b = list( "abcd")
b.reverse()
b = ''.join(b)
timePython = time.time() -start
print 'Python costs', timePython, 'the result is', b
import time
start = time.time()
a = Extest.reverse( "abcd")
timeC = time.time() - start
print 'C costs', timeC, 'the result is', a
start = time.time()
b = list( "abcd")
b.reverse()
b = ''.join(b)
timePython = time.time() -start
print 'Python costs', timePython, 'the result is', b
运行结果
![](https://i-blog.csdnimg.cn/blog_migrate/334badc595433f635054338ae95a05be.png)
可以看出,python也不是绝对比C慢嘛,还要看情况。