python和C語言互相調用的幾種方式

時間 2019-12-07

標籤 python c語言互相調用幾種方式欄目 Python 简体版

原文原文鏈接

1html

2python

3linux

4編程

5數組

6數據結構

7多線程

8架構

9運維

版權申明：本文爲博主窗戶(Colin Cai)原創，歡迎轉帖。如要轉貼，必須註明原文網址python2.7

http://www.cnblogs.com/Colin-Cai/p/7594551.html

做者：窗戶

QQ：6679072

E-mail：6679072@qq.com

　　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代碼爲

#!/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)

　　測試以下

$ gcc -fPIC -shared func.c -o libfunc.so

$ ./test_so.py

9801

　　subprocess

　　C語言設計一個完整的可執行文件，而後python經過subprocess來執行該可執行文件，本質上是fork+execve。

　　舉例以下，C語言代碼爲

/* 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;
}

　　Python代碼爲

#!/usr/bin/env python
# test_subprocess.py
import os
import subprocess

subprocess.call([os.getcwd()+'/a.out', '99'])

　　測試以下

$ gcc test.c -o a.out

$ ./test_subprocess.py

9801

　　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語言代碼以下

/* 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;
}

　　測試以下

$ gcc test.c

$ ./a.out

9801

　　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代碼寫了，以下所示

#!/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

　　帶上以前一直測試的平方func，這個實現相對簡單，但願python寫出來的func能夠和C語言擴展出來的結果一致。

　　先用C語言寫上這些函數的實現，其中func3用上了一個表示任意多個任意長的數組的數據結構y_t,而x_t用來表示單個數組。

/* 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

/* 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);
}

　　上面定義了三個函數，func2表明平方，func3表明以前所說的功能，又因y_t這個結構可能都是動態分配出來的，因此給個歸還內存的方法。

　　剛纔說過python擴展的話，須要把這個共享庫的接口「標準化」一下。因而咱們就包裝一下，並給個python加載的入口。

/* 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);
}

　　過程當中，我猜想PyArg_VaParse應該功能更爲強大，但是反覆測沒有成功，也沒細看文檔。

　　測試一下

$ gcc -I /usr/include/python2.7/ -fPIC -shared colin.c wrap.c -o colin.so

$ ./test.py

f = 9801

g = 729000

h = 729000

　　能夠看到，C語言寫的函數和python寫的函數結果一致。

出處：http://www.cnblogs.com/Colin-Cai/p/7594551.html