python和C语言互相调用的几种方式

落日映苍穹つ 2022-05-13 03:16 229阅读 0赞

<table> 
 <tbody> 
  <tr> 
   <td> <p><code>版权申明：本文为博主窗户(Colin Cai)原创，欢迎转帖。如要转贴，必须注明原文网址</code></p> <p>&nbsp;</p> <p><code>http://www.cnblogs.com/Colin-Cai/p/7594551.html </code></p> <p>&nbsp;</p> <p><code>作者：窗户</code></p> <p>&nbsp;</p> <p><code>QQ：6679072</code></p> <p>&nbsp;</p> <p><code>E-mail：6679072@qq.com</code></p> </td> 
  </tr> 
 </tbody> 
</table>

Python这些年风头一直很盛，占据了很多领域的位置，Web、大数据、人工智能、运维均有它的身影，甚至图形界面做的也很顺，乃至full-stack这个词语刚出来的时候，似乎就是为了描述它。

Python虽有GIL的问题导致多线程无法充分利用多核，但后来的multiprocess可以从多进程的角度来利用多核，甚至affinity可以绑定具体的CPU核，这个问题也算得到解决。虽基本为全栈语言，但有的时候为了效率，可能还是会去考虑和C语言混编。混编是计算机里一个不可回避的话题，涉及的东西很多，技术、架构、团队情况、管理、客户等各个环节可能对其都有影响，混编这个问题我想到时候再开一贴专门讨论。本文只讲python和C混编的方式，大致有如下几种方式（本文背景是linux，其他平台可以类比）：

共享库

使用C语言编译产生共享库，然后python使用ctype库里的cdll来打开共享库。

举例如下，C语言代码为

/* func.c */
    int func(int a)
    {
            return a*a;
    }

python代码为

![复制代码][copycode.gif]

#!/usr/bin/env python
    #test_so.py
    from ctypes import cdll
    import os
    
    p = os.getcwd() + '/libfunc.so'
    f = cdll.LoadLibrary(p)
    print f.func(99)

![复制代码][copycode.gif]

测试如下

<table> 
 <tbody> 
  <tr> 
   <td> <p>1</p> <p>2</p> <p>3</p> </td> 
   <td> <p><code>$ gcc -fPIC -shared func.c -o libfunc.so</code></p> <p><code>$ ./test_so.py</code></p> <p><code>9801</code></p> </td> 
  </tr> 
 </tbody> 
</table>

subprocess

C语言设计一个完整的可执行文件，然后python通过subprocess来执行该可执行文件，本质上是fork+execve。

举例如下，C语言代码为

![复制代码][copycode.gif]

/* test.c */
    #include <stdio.h>
    int func(int a)
    {
            return a*a;
    }
    
    int main(int argc, char **argv)
    {
            int x;
    
            sscanf(argv[1], "%d", &x);
            printf("%d\n", func(x));
            return 0;
    }

![复制代码][copycode.gif]

Python代码为

![复制代码][copycode.gif]

#!/usr/bin/env python
    # test_subprocess.py
    import os
    import subprocess
    
    subprocess.call([os.getcwd()+'/a.out', '99'])

![复制代码][copycode.gif]

测试如下

<table> 
 <tbody> 
  <tr> 
   <td> <p>1</p> <p>2</p> <p>3</p> </td> 
   <td> <p><code>$ gcc test.c -o a.</code><code>out</code></p> <p><code>$ ./test_subprocess.py</code></p> <p><code>9801</code></p> </td> 
  </tr> 
 </tbody> 
</table>

C语言中运行python程序

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

举例如下，Python代码如下

#!/usr/bin/env python
    # test.py
    import sys
    x = int(sys.argv[1])
    print x*x

C语言代码如下

![复制代码][copycode.gif]

/* test.c */
    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
            FILE *f;
            char s[1024];
            int ret;
    
            f = popen("./test.py 99", "r");
            while((ret=fread(s,1,1024,f))>0) {
                    fwrite(s,1,ret,stdout);
            }
            fclose(f);
            return 0;
    }

![复制代码][copycode.gif]

测试如下

python对C语言扩展的支持

很多编程语言都为C语言扩展添加了支持，这有两种原因：(1)语言设计之初，可以充分的利用C语言已有的库来做很多扩展；(2)C语言的运行效率高。

python也不例外，从诞生那天起，很多库都是C语言写的。python的C语言扩展中涉及到python的数据结构与C语言的对应，扩展方法其实是用C语言编写一个共享库，只是这个共享库中的接口是一个规范的，可以被python识别的。

为了说明如何扩展，我这里先假设一个在python下的函数功能，代码如下

def func(*a):
        res=1
        for i in range(len(a)):
            res *= sum(a[i])
        return res

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

姑且先把python代码写了，如下所示

![复制代码][copycode.gif]

#!/usr/bin/env python
    # test.py
    import colin
    
    def func(*a):
        res=1
        for i in range(len(a)):
            res *= sum(a[i])
        return res
    
    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

![复制代码][copycode.gif]

带上之前一直测试的平方func，这个实现相对简单，希望python写出来的func可以和C语言扩展出来的结果一致。

先用C语言写上这些函数的实现，其中func3用上了一个表示任意多个任意长的数组的数据结构y\_t,而x\_t用来表示单个数组。

![复制代码][copycode.gif]

/* colin.h */
    #ifndef Colin_h
    #define Colin_h
    typedef struct {
            int *a;
            int len;
    } x_t;
    typedef struct {
            x_t *ax;
            int len;
    } y_t;
    int func2(int a);
    int func3(y_t *p);
    void free_y_t(y_t *p);
    #endif

![复制代码][copycode.gif]

/* colin.c */
    #include "colin.h"
    #include <stdlib.h>
    
    int func2(int a)
    {
            return a*a;
    }
    
    int func3(y_t *p)
    {
            int result;
            int sum;
            int i, 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;
            }
    
            return result;
    }
    
    void free_y_t(y_t *p)
    {
            int i;
            for(i=0;i<p->len;i++) {
                    free(p->ax[i].a);
            }
            free(p->ax);
    }

![复制代码][copycode.gif]

上面定义了三个函数，func2代表平方，func3代表之前所说的功能，又因y\_t这个结构可能都是动态分配出来的，所以给个归还内存的方法。

刚才说过python扩展的话，需要把这个共享库的接口“标准化”一下。于是我们就包装一下，并给个python加载的入口。

![复制代码][copycode.gif]

/* wrap.c */
    #include <Python.h>
    #include <stdlib.h>
    #include "colin.h"
    PyObject* wrap_func2(PyObject* self, PyObject* args)
    {
            int n, result;
            /* 从参数列表中导出一个整形，用"i" */
            if (!PyArg_ParseTuple(args, "i", &n))
                    return NULL;
    
            /* 用C语言的库实现来计算 */
            result = func2(n);
            /* 计算结果必须要导成python识别的类型 */
            return Py_BuildValue("i", result);
    }
    
    PyObject* wrap_func3(PyObject* self, PyObject* args)
    {
            int n, result;
            int i, j;
            int size, 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识别格式 */
            return Py_BuildValue("i", result);
    }
    
    /* 这是接口列表，加载时是只加载此列表的地址，所以这个数据结构不能放栈（局部变量）内，会被清掉 */
    static PyMethodDef colinMethods[] =
    {
            {"func2", wrap_func2, METH_VARARGS, "Just a test"},
            {"func3", wrap_func3, METH_VARARGS, "Just a test"},
            {NULL, NULL, METH_NOARGS, NULL}
    };
    
    /* python加载的时候的接口 */
    /* 注意，既然库名叫colin,此函数必须交initcolin */
    void initcolin()
    {
            PyObject *m;
            m = Py_InitModule("colin", colinMethods);
    }

![复制代码][copycode.gif]

过程中，我猜测PyArg\_VaParse应该功能更为强大，可是反复测没有成功，也没细看文档。

测试一下

<table> 
 <tbody> 
  <tr> 
   <td> <p>1</p> <p>2</p> <p>3</p> <p>4</p> <p>5</p> </td> 
   <td> <p><code>$ gcc -I /usr/include/python2.7/ -fPIC -shared colin.c wrap.c -o colin.so</code></p> <p><code>$ ./test.py</code></p> <p><code>f =&nbsp; 9801</code></p> <p><code>g =&nbsp; 729000</code></p> <p><code>h =&nbsp; 729000</code></p> </td> 
  </tr> 
 </tbody> 
</table>

可以看到，C语言写的函数和python写的函数结果一致。

[copycode.gif]: /images/20220513/aedef50393904ee3a24055727161f73d.png