c语言调用python程序（C语言与Python如何相互调用）

Python这些年风头一直很盛    
    
    
    
    
，占据了很多领域的位置 


     


     


     


     


 ，Web    
    
    
    
    
、大数据 


     


     


     


     


 、人工智能

 




 




 




 




 、运维均有它的身影

 




 




 




 




 ，甚至图形界面做的也很顺   

   

   

   

   

，乃至full-stack这个词语刚出来的时候  

     

     

     

     

，似乎就是为了描述它    
    
    
    
    
。

Python虽有GIL的问题导致多线程无法充分利用多核


  




  




  




  




  ，但后来的multiprocess可以从多进程的角度来利用多核  


  


  


  


  

，甚至affinity可以绑定具体的CPU核   
     
     
     
     
，这个问题也算得到解决 


     


     


     


     


 。虽基本为全栈语言



   




   




   




   




  ，但有的时候为了效率 



 



 



 



 

，可能还是会去考虑和C语言混编

 




 




 




 




 。

混编是计算机里一个不可回避的话题                        ，涉及的东西很多




    




    




    




    




  ，技术   

   

   

   

   

、架构  

     

     

     

     

、团队情况


  




  




  




  




  、管理  


  


  


  


  

、客户等各个环节可能对其都有影响





















，混编这个问题我想到时候再开一贴专门讨论   

   

   

   

   

。本文只讲python和C混编的方式                         ，大致有如下几种方式（本文背景是linux



     



     



     



     



  ，其他平台可以类比）：

共享库

使用C语言编译产生共享库





















，然后python使用ctype库里的cdll来打开共享库  

     

     

     

     

。

举例如下    
    
    
    
    
，C语言代码为

/*func.c*/ intfunc(inta) { returna*a; }

python代码为

#!/usr/bin/envpython #test_so.py fromctypesimportcdll importos p=os.getcwd()+/libfunc.so f=cdll.LoadLibrary(p) printf.func(99)

测试如下：

$gcc-fPIC-sharedfunc.c-olibfunc.so $./test_so.py 9801

subprocess

C语言设计一个完整的可执行文件 


     


     


     


     


 ，然后python通过subprocess来执行该可执行文件

 




 




 




 




 ，本质上是fork+execve


  




  




  




  




  。

举例如下   

   

   

   

   

，C语言代码为

/*test.c*/ #include<stdio.h> intfunc(inta) { returna*a; } intmain(intargc,char**argv) { intx; sscanf(argv[1],"%d",&x); printf("%d\n",func(x)); return0; }

Python代码为

#!/usr/bin/envpython #test_subprocess.py importos importsubprocess subprocess.call([os.getcwd()+/a.out,99])

测试如下：

$gcctest.c-oa.out $./test_subprocess.py 9801

C语言中运行python程序

C语言使用popen/system或者直接以系统调用级fork+exec来运行python程序也是一种混编的手段了  


  


  


  


  

。

举例如下  

     

     

     

     

，Python代码如下：

#!/usr/bin/envpython #test.py importsys x=int(sys.argv[1]) printx*x

C语言代码如下：

/*test.c*/ #include<stdio.h> #include<stdlib.h> intmain() { FILE*f; chars[1024]; intret; f=popen("./test.py99","r"); while((ret=fread(s,1,1024,f))>0){ fwrite(s,1,ret,stdout); } fclose(f); return0; }

测试如下：

$gcctest.c $./a.out 9801

python对C语言扩展的支持

很多编程语言都为C语言扩展添加了支持


  




  




  




  




  ，这有两种原因：

（1）语言设计之初  


  


  


  


  

，可以充分的利用C语言已有的库来做很多扩展；

（2）C语言的运行效率高   
     
     
     
     
。

python也不例外   
     
     
     
     
，从诞生那天起



   




   




   




   




  ，很多库都是C语言写的



   




   




   




   




  。python的C语言扩展中涉及到python的数据结构与C语言的对应 



 



 



 



 

，扩展方法其实是用C语言编写一个共享库                        ，只是这个共享库中的接口是一个规范的




    




    




    




    




  ，可以被python识别的 



 



 



 



 

。

为了说明如何扩展





















，我这里先假设一个在python下的函数功能                         ，代码如下：

deffunc(*a): res=1 foriinrange(len(a)): res*=sum(a[i]) returnres

如上



     



     



     



     



  ，希望的函数功能是





















，参数是任意多个数字组成的列表（姑且排除其他数据结构）    
    
    
    
    
，返回每个列表的元素之和的乘积                        。

姑且先把python代码写了 


     


     


     


     


 ，如下所示：

#!/usr/bin/envpython #test.py importcolin deffunc(*a): res=1 foriinrange(len(a)): res*=sum(a[i]) returnres a=[1,2,3] b=[4,5,6] c=[7,8] d=[9] e=[10,11,12,13,14] f=colin.func2(99) g=colin.func3(a,b,c,d,e) h=func3(a,b,c,d,e) print"f=",f print"g=",g print"h=",h

带上之前一直测试的平方func

 




 




 




 




 ，这个实现相对简单   

   

   

   

   

，希望python写出来的func可以和C语言扩展出来的结果一致




    




    




    




    




  。

先用C语言写上这些函数的实现  

     

     

     

     

，其中func3用上了一个表示任意多个任意长的数组的数据结构y_t,而x_t用来表示单个数组





















。

/*colin.h*/ #ifndefColin_h #defineColin_h typedefstruct{ int*a; intlen; }x_t; typedefstruct{ x_t*ax; intlen; }y_t; intfunc2(inta); intfunc3(y_t*p); voidfree_y_t(y_t*p); #endif /*colin.c*/ #include"colin.h" #include<stdlib.h> intfunc2(inta) { returna*a; } intfunc3(y_t*p) { intresult; intsum; inti,j; result=1; for(i=0;i<p->len;i++){ sum=0; for(j=0;j<p->ax[i].len;j++) sum+=p->ax[i].a[j]; result*=sum; } returnresult; } voidfree_y_t(y_t*p) { inti; for(i=0;i<p->len;i++){ free(p->ax[i].a); } free(p->ax); }

上面定义了三个函数


  




  




  




  




  ，func2代表平方  


  


  


  


  

，func3代表之前所说的功能   
     
     
     
     
，又因y_t这个结构可能都是动态分配出来的



   




   




   




   




  ，所以给个归还内存的方法                         。

刚才说过python扩展的话 



 



 



 



 

，需要把这个共享库的接口“标准化
    
    
    
    
 ”一下



     



     



     



     



  。于是我们就包装一下                        ，并给个python加载的入口





















。

/*wrap.c*/ #include<Python.h> #include<stdlib.h> #include"colin.h" PyObject*wrap_func2(PyObject*self,PyObject*args) { intn,result; /*从参数列表中导出一个整形




    




    




    




    




  ，用"i"*/ if(!PyArg_ParseTuple(args,"i",&n)) returnNULL; /*用C语言的库实现来计算*/ result=func2(n); /*计算结果必须要导成python识别的类型*/ returnPy_BuildValue("i",result); } PyObject*wrap_func3(PyObject*self,PyObject*args) { intn,result; inti,j; intsize,size2; PyObject*p,*q; y_t*y; y=malloc(sizeof(y_t)); /*先数数有多少个参数





















，也就是列表的个数*/ size=PyTuple_Size(args); /*把数组的个数先分配了*/ y->len=size; y->ax=malloc(sizeof(x_t)*size); /*遍历python里各个列表(参数)*/ for(i=0;i<size;i++){ /*先获得第i个参数                         ，是一个列表*/ p=PyTuple_GetItem(args,i); /*获得列表的长度*/ size2=PyList_Size(p); /*为数组分配好空间*/ y->ax[i].len=size2; y->ax[i].a=malloc(sizeof(int)*size2); /*遍历列表



     



     



     



     



  ，依次把列表里的数转到数组里*/ for(j=0;j<size2;j++){ q=PyList_GetItem(p,j); PyArg_Parse(q,"i",&y->ax[i].a[j]); } } /*用C语言的库实现来计算*/ result=func3(y); free_y_t(y); free(y); /*结果转成python识别格式*/ returnPy_BuildValue("i",result); } /*这是接口列表





















，加载时是只加载此列表的地址    
    
    
    
    
，所以这个数据结构不能放栈（局部变量）内 


     


     


     


     


 ，会被清掉*/ staticPyMethodDefcolinMethods[]= { {"func2",wrap_func2,METH_VARARGS,"Justatest"}, {"func3",wrap_func3,METH_VARARGS,"Justatest"}, {NULL,NULL,METH_NOARGS,NULL} }; /*python加载的时候的接口*/ /*注意

 




 




 




 




 ，既然库名叫colin,此函数必须交initcolin*/ voidinitcolin() { PyObject*m; m=Py_InitModule("colin",colinMethods); }

过程中   

   

   

   

   

，我猜测PyArg_VaParse应该功能更为强大  

     

     

     

     

，可是反复测没有成功


  




  




  




  




  ，也没细看文档    
    
    
    
    
。

测试一下

$gcc-I/usr/include/python2.7/-fPIC-sharedcolin.cwrap.c-ocolin.so $./test.py f=9801 g=729000 h=729000

可以看到  


  


  


  


  

，C语言写的函数和python写的函数结果一致 


     


     


     


     


 。

众多python培训视频   
     
     
     
     
，尽在python学习网



   




   




   




   




  ，欢迎在线学习！