Python調用C/C++
1、Python調用C動態鏈接庫
Python調用C庫比較簡單，不經過任何封裝打包成so，再使用python的ctypes調用即可。
C語言文件：pycall.c
|
1
2
3
4
5
6
|
# include "stdio.h"#include "stdlib.h"int foof(int a, int b){ printf("you input %d and %d",a,b); return a+b;} |
gcc編譯生成動態庫libpycall.so
|
1
2
3
4
5
6
|
# include "stdio.h"#include "stdlib.h"int foof(int a, int b){ printf("you input %d and %d",a,b); return a+b;} |
Python調用動態庫的文件：pycall.py
|
1
2
3
4
|
import ctypesll = ctypes.cdll.LoadLibrarylib = ll("Cfoo.so")lib.foof(1,3) |
運行結果：
2、Python調用C/C++原生態導出
Python解釋器就是用C實現，因此只要我們的C++的數據結構能讓Python認識，理論上就是可以被直接調用的。我們實現test1.cpp如下：
|
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
|
#include <Python.h> int Add(int x, int y) { return x + y; } int Del(int x, int y) { return x - y; } PyObject* WrappAdd(PyObject* self, PyObject* args) { int x, y; if (!PyArg_ParseTuple(args, "ii", &x, &y)) { return NULL; } return Py_BuildValue("i", Add(x, y)); } PyObject* WrappDel(PyObject* self, PyObject* args) { int x, y; if (!PyArg_ParseTuple(args, "ii", &x, &y)) { return NULL; } return Py_BuildValue("i", Del(x, y)); } static PyMethodDef test_methods[] = { {"Add", WrappAdd, METH_VARARGS, "something"}, {"Del", WrappDel, METH_VARARGS, "something"}, {NULL, NULL} }; extern "C"void inittest1() { Py_InitModule("test1", test_methods); } |
編譯命令如下：
|
1
|
g++ -fPIC -shared test1.cpp -I/usr/include/python2.7 -o test1.so |
-fPIC：生成位置無關目標代碼，適用于動態連接；
-L path：表示在path目錄中搜索庫文件，如-L.表示在當前目錄；
-I path：表示在path目錄中搜索頭文件；
-o file：制定輸出文件為file；
-shared：生成一個共享庫文件；
運行Python解釋器，測試如下:
|
1
2
3
|
>>> import test1 >>> test1.Add(1,2) 3 |
這里要注意一下幾點:
1.如果生成的動態庫名字為test1，則源文件里必須有inittest1這個函數，且Py_InitModule的第一個參數必須是“test1”，否則Python導入模塊會失敗
2.如果是cpp源文件，inittest1函數必須用extern "C"修飾，如果是c源文件，則不需要。原因是Python解釋器在導入庫時會尋找initxxx這樣的函數，而C和C++對函數符號的編碼方式不同，C++在對函數符號進行編碼時會考慮函數長度和參數類型，具體可以通過nm test1.so查看函數符號，c++filt工具可通過符號反解出函數原型
3.PyArg_ParseTuple()函數的定義：
arg參數必須是一個元組對象,它包含了從Python傳遞到C語言函數的參數列表。format參數必須是格式字符串, 具體將在下方解釋.其余參數必須是變量的地址,其類型由格式字符串決定。為了能成功的轉換,arg對象必須與格式匹配,并且前后一一對應。
雖然 PyArg_ParseTuple() 檢查Python是否具有所需類型, 但是它不能檢查傳遞給調用的C變量地址的有效性: 如果在那里出錯，您的代碼可能會崩潰，或者覆蓋內存中的隨機位置。所以要小心
| 字符串 | 備注 |
|---|---|
| “s” (string or Unicode object) [char *] | 將Python字符串或Unicode對象轉換為指向字符串的C指針。不能為字符串本身提供存儲;指向現有字符串的指針存儲在您傳遞地址的字符指針變量中。C字符串以NULL結尾。Python字符串不能包含嵌入的空字節;如果有，就會引發TypeError異常。使用默認編碼將Unicode對象轉換為C字符串。如果轉換失敗，就會引發一個UnicodeError異常 |
| “s#” (string,Unicode or any read buffer compatible object) [char *, int] | “s”上的這個變體存儲在兩個C變量中，第一個變量是指向字符串的指針，第二個變量是字符串的長度。在這種情況下，Python字符串可能包含嵌入的空字節。如果可能的話，Unicode對象會返回一個指向對象的默認編碼字符串版本的指針。所有其他與讀取緩沖區兼容的對象都將對原始內部數據表示的引用傳回。 |
| “z” (string or None) [char *] | 與“s”類似，但是Python對象也可能是None，在這種情況下，C指針被設置為NULL。 |
| “z#” (string or None or any read buffer compatible object) [char *, int] | 這是"s#"就像"z"是"s"一樣。 |
| “u” (Unicode object) [Py_UNICODE *] | 將Python Unicode對象轉換為指向16位Unicode (UTF-16)數據的空端緩沖區的C指針。與“s”一樣，不需要為Unicode數據緩沖區提供存儲;指向現有Unicode數據的指針被存儲到Py_UNICODE指針變量中，您傳遞的地址就是這個變量。 |
| “u#” (Unicode object) [Py_UNICODE *, int] | “u”上的這個變體存儲在兩個C變量中，第一個變量是指向Unicode數據緩沖區的指針，第二個變量是它的長度。 |
| “es” (string,Unicode object or character buffer compatible object) [const char *encoding,char **buffer] | 這個“s”的變體用于編碼Unicode和轉換為Unicode的對象到字符緩沖區。它只適用于不嵌入空字節的編碼數據。 |
讀取一個變體C變量C和商店為兩個變量,第一個指針指向一個編碼名稱字符串(encoding),第二個一個指向指針的指針一個字符緩沖區(**buffer,緩沖用于存儲編碼數據)和第三個整數指針(*buffer_length,緩沖區長度)。
編碼名稱必須映射到已注冊的編解碼器。如果設置為NULL，則使用默認編碼。
PyArg_ParseTuple()將使用PyMem_NEW()分配一個所需大小的緩沖區，將已編碼的數據復制到這個緩沖區中，并調整*buffer以引用新分配的存儲。調用方負責調用PyMem_Free()以在使用后釋放分配的緩沖區。
編碼名稱必須映射到已注冊的編解碼器。如果設置為NULL，則使用默認編碼。操作方式有兩種:
如果buffer指向空指針，PyArg_ParseTuple()將使用PyMem_NEW()分配一個所需大小的緩沖區，將已編碼的數據復制到這個緩沖區，并調整buffer以引用新分配的存儲。調用方負責在使用后調用PyMem_Free()來釋放分配的緩沖區。
如果buffer指向非空指針(已經分配的緩沖區)，PyArg_ParseTuple()將使用這個位置作為緩沖區，并將buffer_length解釋為緩沖區大小。然后，它將把編碼后的數據復制到緩沖區中，并終止(0-terminate)它。緩沖區溢出以異常信號表示。
在這兩種情況下，都將*buffer_length設置為編碼數據的長度，沒有后面的0字節(0-byte)。
| 字符串 | 備注 |
|---|---|
| “b” (integer) [char] | 將Python整數轉換為存儲在C語言char中的一個小int(tiny int)。 |
| “h” (integer) [short int] | 將Python整數轉換為C語言short int。 |
| “i” (integer) [int] | 將Python整數轉換為普通的C語言int。 |
| “l” (integer) [long int] | 將Python整數轉換為C語言long int。 |
| “c” (string of length 1) [char] | 將長度為1的字符串表示的Python字符轉換為C語言char。 |
| “f” (float) [float] | 將Python浮點數轉換為C語言float。 |
| “d” (float) [double] | 將Python浮點數轉換為C 語言double。 |
| “D” (complex) [Py_complex] | 將Python復數轉換為C語言Py_complex結構。 |
| “O” (object) [PyObject *] | 在C對象指針中存儲Python對象(不進行任何轉換)。因此，C程序接收傳遞的實際對象。對象的引用計數沒有增加。存儲的指針不是空的(NULL)。 |
| “O!” (object)[typeobject, PyObject *] | 將Python對象存儲在C對象指針中。這類似于“O”，但是接受兩個C參數:第一個是Python類型對象的地址，第二個是對象指針存儲在其中的C變量(類型為PyObject *)的地址。如果Python對象沒有所需的類型，就會引發類型錯誤(TypeError)。 |
| “O&” (object)[converter,anything] | 通過轉換器函數將Python對象轉換為C變量。這需要兩個參數:第一個是函數，第二個是C變量(任意類型)的地址，轉換為void *。該轉換器功能依次調用如下:status = converter(object,address);對象是要轉換的Python對象，地址是傳遞給PyArg_ConvertTuple()的void *參數。對于成功的轉換，返回的狀態應該是1，如果轉換失敗，則返回0。當轉換失敗時，converter(函數名可能錯誤)函數應該引發異常。 |
| “S” (string) [PyStringObject *] | 與“O”類似，但要求Python對象是字符串對象。如果對象不是字符串對象，則引發類型錯誤(TypeError)。C變量也可以聲明為PyObject *。 |
| “U” (Unicode string) [PyUnicodeObject *] | 與“O”類似，但要求Python對象是Unicode對象。如果對象不是Unicode對象，則引發類型錯誤(TypeError)。C變量也可以聲明為PyObject *。 |
| “t#” (read-only character buffer) [char *, int] | 與“s#”類似，但接受任何實現只讀緩沖區接口的對象。char *變量設置為指向緩沖區的第一個字節，int設置為緩沖區的長度。只接受單段緩沖對象;對所有其他類型都引發類型錯誤(TypeError)。 |
| “w” (read-write character buffer) [char *] | 類似于“s”，但接受任何實現讀寫緩沖區接口的對象。調用者必須通過其他方法確定緩沖區的長度，或者使用“w#”。只接受單段緩沖對象;對所有其他類型都引發類型錯誤(TypeError)。 |
| “w#” (read-write character buffer) [char *, int] | 與“s#”類似，但接受任何實現讀寫緩沖區接口的對象。char *變量設置為指向緩沖區的第一個字節，int設置為緩沖區的長度。只接受單段緩沖對象;對所有其他類型都引發類型錯誤(TypeError)。 |
| “(items)” (tuple) [matching-items] | 對象必須是一個Python序列，其長度是項中的格式單元數。C參數必須對應于項中的單個格式單元。序列的格式單元可以嵌套。 |
3、Python調用C/C++通過boost實現
我們使用和上面同樣的例子，實現test2.cpp如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#include <boost/python/module.hpp> #include <boost/python/def.hpp> using namespace boost::python; int Add(const int x, const int y) { return x + y; } int Del(const int x, const int y) { return x - y; } BOOST_PYTHON_MODULE(test2) { def("Add", Add); def("Del", Del); } |
其中BOOST_PYTHON_MODULE的參數為要導出的模塊名字，編譯命令如下：
|
1
|
g++ test2.cpp -fPIC -shared -o test2.so -I/usr/include/python2.7 -I/usr/local/include -L/usr/local/lib -lboost_python |
注意： 編譯時需要指定boost頭文件和庫的路徑，我這里分別是/usr/local/include和/usr/local/lib
或者通過setup.py導出模塊：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/env python from distutils.core import setup from distutils.extension import Extension setup(name="PackageName", ext_modules=[ Extension("test2", ["test2.cpp"], libraries = ["boost_python"]) ]) |
Extension的第一個參數為模塊名，第二個參數為文件名
執行如下命令：
|
1
|
python setup.py build |
這時會生成build目錄，找到里面的test2.so，并進入同一級目錄，驗證如下：
|
1
2
3
4
5
|
>>> import test2 >>> test2.Add(1,2) 3>>> test2.Del(1,2) -1 |
4、Python調用C/C++通過導出類
test3.cpp實現如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include <boost/python.hpp> using namespace boost::python; class Test { public: int Add(const int x, const int y) { return x + y; } int Del(const int x, const int y) { return x - y; } }; BOOST_PYTHON_MODULE(test3) { class_<Test>("Test") .def("Add", &Test::Add) .def("Del", &Test::Del); } |
注意：BOOST_PYTHON_MODULE里的.def使用方法有點類似Python的語法，等同于：
|
1
2
|
class_<Test>("Test").def("Add", &Test::Add); class_<Test>("Test").def("Del", &Test::Del); |
編譯命令如下：
|
1
|
g++ test3.cpp -fPIC -shared -o test3.so -I/usr/include/python2.7 -I/usr/local/include/boost -L/usr/local/lib -lboost_python |
測試如下：
|
1
2
3
4
5
6
|
>>> import test3 >>> test = test3.Test() >>> test.Add(1,2) 3>>> test.Del(1,2) -1 |
5、Python調用C/C++通過導出變參函數
test4.cpp實現如下：
|
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
|
#include <boost/python.hpp> using namespace boost::python; class Test { public: int Add(const int x, const int y, const int z = 100) { return x + y + z; } }; int Del(const int x, const int y, const int z = 100) { return x - y - z; } BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(Add_member_overloads, Add, 2, 3) BOOST_PYTHON_FUNCTION_OVERLOADS(Del_overloads, Del, 2, 3) BOOST_PYTHON_MODULE(test4) { class_<Test>("Test") .def("Add", &Test::Add, Add_member_overloads(args("x", "y", "z"), "something")); def("Del", Del, Del_overloads(args("x", "y", "z"), "something")); } |
這里Add和Del函數均采用了默認參數，Del為普通函數，Add為類成員函數，這里分別調用了不同的宏，宏的最后兩個參數分別代表函數的最少參數個數和最多參數個數
編譯命令如下：
|
1
|
g++ test4.cpp -fPIC -shared -o test4.so -I/usr/include/python2.7 -I/usr/local/include/boost -L/usr/local/lib -lboost_python |
測試如下：
|
1
2
3
4
5
6
7
8
9
10
|
>>> import test4 >>> test = test4.Test() >>> print test.Add(1,2) 103>>> print test.Add(1,2,z=3) 6>>> print test4.Del(1,2) -1>>> print test4.Del(1,2,z=3) -1 |
6、Python調用C/C++通過導出帶Python對象的接口
既然是導出為Python接口，調用者難免會使用Python特有的數據結構，比如tuple,list,dict，由于原生態方法太麻煩，這里只記錄boost的使用方法，假設要實現如下的Python函數功能：
|
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
|
def Square(list_a) { return [x * x for x in list_a] }```即對傳入的list每個元素計算平方，返回list類型的結果，代碼如下：```cpp#include <boost/python.hpp> boost::python::list Square(boost::python::list& data) { boost::python::list ret; for (int i = 0; i < len(data); ++i) { ret.append(data[i] * data[i]); } return ret; } BOOST_PYTHON_MODULE(test5) { def("Square", Square); } |
編譯命令如下
|
1
|
g++ test5.cpp -fPIC -shared -o test5.so -I/usr/include/python2.7 -I/usr/local/include/boost -L/usr/local/lib -lboost_python |
測試如下：
|
1
2
3
|
>>> import test5 >>> test5.Square([1,2,3]) [1, 4, 9] |
boost實現了boost::python::tuple, boost::python::list, boost::python::dict這幾個數據類型，使用方法基本和Python保持一致，具體方法可以查看boost頭文件里的boost/python/tuple.hpp及其它對應文件
另外比較常用的一個函數是boost::python::make_tuple() ，使用方法如下
|
1
2
3
4
|
boost::python::tuple(int a, int b, int c) { return boost::python::make_tuple(a, b, c); } |
以上就是python模塊與C和C++動態庫相互調用實現過程示例的詳細內容，更多關于python模塊與C和C++動態庫相互調用的資料請關注服務器之家其它相關文章！
原文鏈接：https://blog.csdn.net/weixin_38582851/article/details/121036465
