c和python混合編程
Ⅰ python怎樣嵌入c
用c語言編寫一個動態庫，提供兩個函數，兩個數的整形求和，兩個浮點數的求和。取名為mylib.c。
將c函數文件編譯成so動態庫。運行gcc mylib.c -fPIC -shared -o libtest.so命令，在目錄下可以看到生成的庫文件libtest.so。
Python調用so庫文件。首先導入ctypes，其次用CDLL載入so文件，最後調用對應的函數。將python代碼保存到pydemo.py中。
執行python pydemo.py查看運行結果。
眾多python培訓視頻，盡在python學習網，歡迎在線學習！
Ⅱ 怎樣讓Python腳本與C++程序互相調用
二、Python調用C/C++
1、Python調用C動態鏈接庫
Python調用C庫比較簡單，不經過任何封裝打包成so，再使用python的ctypes調用即可。
（1）C語言文件：pycall.c
[html] view plain
/***gcc -o libpycall.so -shared -fPIC pycall.c*/
#include <stdio.h>
#include <stdlib.h>
int foo(int a, int b)
{
printf("you input %d and %d\n", a, b);
return a+b;
}
（2）gcc編譯生成動態庫libpycall.so：gcc -o libpycall.so -shared -fPIC pycall.c。使用g++編譯生成C動態庫的代碼中的函數或者方法時，需要使用extern "C"來進行編譯。
（3）Python調用動態庫的文件：pycall.py
[html] view plain
import ctypes
ll = ctypes.cdll.LoadLibrary
lib = ll("./libpycall.so")
lib.foo(1, 3)
print '***finish***'
（4）運行結果：
2、Python調用C++(類)動態鏈接庫
需要extern "C"來輔助，也就是說還是只能調用C函數，不能直接調用方法，但是能解析C++方法。不是用extern "C"，構建後的動態鏈接庫沒有這些函數的符號表。
（1）C++類文件：pycallclass.cpp
[html] view plain
#include <iostream>
using namespace std;
class TestLib
{
public:
void display();
void display(int a);
};
void TestLib::display() {
cout<<"First display"<<endl;
}
void TestLib::display(int a) {
cout<<"Second display:"<<a<<endl;
}
extern "C" {
TestLib obj;
void display() {
obj.display();
}
void display_int() {
obj.display(2);
}
}
（2）g++編譯生成動態庫libpycall.so：g++ -o libpycallclass.so -shared -fPIC pycallclass.cpp。
（3）Python調用動態庫的文件：pycallclass.py
[html] view plain
import ctypes
so = ctypes.cdll.LoadLibrary
lib = so("./libpycallclass.so")
print 'display()'
lib.display()
print 'display(100)'
lib.display_int(100)
（4）運行結果：
3、Python調用C/C++可執行程序
（1）C/C++程序：main.cpp
[html] view plain
#include <iostream>
using namespace std;
int test()
{
int a = 10, b = 5;
return a+b;
}
int main()
{
cout<<"---begin---"<<endl;
int num = test();
cout<<"num="<<num<<endl;
cout<<"---end---"<<endl;
}
（2）編譯成二進制可執行文件：g++ -o testmain main.cpp。
（3）Python調用程序：main.py
[html] view plain
import commands
import os
main = "./testmain"
if os.path.exists(main):
rc, out = commands.getstatusoutput(main)
print 'rc = %d, \nout = %s' % (rc, out)
print '*'*10
f = os.popen(main)
data = f.readlines()
f.close()
print data
print '*'*10
os.system(main)
（4）運行結果：
4、擴展Python（C++為Python編寫擴展模塊）
所有能被整合或導入到其它python腳本的代碼，都可以被稱為擴展。可以用Python來寫擴展，也可以用C和C++之類的編譯型的語言來寫擴展。Python在設計之初就考慮到要讓模塊的導入機制足夠抽象。抽象到讓使用模塊的代碼無法了解到模塊的具體實現細節。Python的可擴展性具有的優點：方便為語言增加新功能、具有可定製性、代碼可以實現復用等。
為 Python 創建擴展需要三個主要的步驟：創建應用程序代碼、利用樣板來包裝代碼和編譯與測試。
（1）創建應用程序代碼
[html] view plain
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int fac(int n)
{
if (n < 2) return(1); /* 0! == 1! == 1 */
return (n)*fac(n-1); /* n! == n*(n-1)! */
}
char *reverse(char *s)
{
register char t, /* tmp */
*p = s, /* fwd */
*q = (s + (strlen(s) - 1)); /* bwd */
while (p < q) /* if p < q */
{
t = *p; /* swap & move ptrs */
*p++ = *q;
*q-- = t;
}
return(s);
}
int main()
{
char s[BUFSIZ];
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;
}
上述代碼中有兩個函數，一個是遞歸求階乘的函數fac()；另一個reverse()函數實現了一個簡單的字元串反轉演算法，其主要目的是修改傳入的字元串，使其內容完全反轉，但不需要申請內存後反著復制的方法。
（2）用樣板來包裝代碼
介面的代碼被稱為「樣板」代碼，它是應用程序代碼與Python解釋器之間進行交互所必不可少的一部分。樣板主要分為4步：a、包含Python的頭文件；b、為每個模塊的每一個函數增加一個型如PyObject* Mole_func()的包裝函數；c、為每個模塊增加一個型如PyMethodDef MoleMethods[]的數組；d、增加模塊初始化函數void initMole()。
Ⅲ 求助 關於c程序中嵌入Python的問題
嵌入
與python的擴展相對，嵌入是把Python解釋器包裝到C的程序中。這樣做可以給大型的，單一的，要求嚴格的，私有的並且（或者）極其重要的應用程序內嵌Python解釋器的能力。一旦內嵌了Python，世界完全不一樣了。
C調用python中的函數：
hw.py：
#coding=utf8
def hw_hs(canshu):
return canshu
if __name__ == "__main__":
ccss = "I am hw"
print hw_hs(ccss)
helloWorld.py：
#coding=utf8
import hw
def hello():
ccss = "I am helloWorld"
return hw.hw_hs(ccss)
if __name__ == "__main__":
print hello()
testcpypy.c：
//#include "testcpypy.h"
#include <Python.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
//初始化Python
Py_Initialize();
if (!Py_IsInitialized()) {
printf("Py_Initialize");
getchar();
return -1;
}
//執行python語句
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");
PyObject *pMole = NULL;
PyObject *pFunc = NULL;
PyObject *reslt =NULL;
//載入python模塊
if(!(pMole = PyImport_ImportMole("helloWorld"))) {
printf("PyImport_ImportMole");
getchar();
return -1;
}
//查找函數
pFunc = PyObject_GetAttrString(pMole, "hello");
if ( !pFunc || !PyCallable_Check(pFunc) )
{
printf("can't find function [hello]");
getchar();
return -1;
}
//調用python中的函數
reslt = (PyObject*)PyEval_CallObject(pFunc, NULL);
//printf("function return value : %d\r\n", PyInt_AsLong(reslt));
//將python返回的對象轉換為C的字元串
char *resltc=NULL;
int res;
res = PyArg_Parse(reslt, "s", &resltc);
if (!res) {
printf("PyArg_Parse");
getchar();
return -1;
}
printf("resltc is %s", resltc);
getchar();
//釋放內存
Py_DECREF(reslt);
Py_DECREF(pFunc);
Py_DECREF(pMole);
//關閉python
Py_Finalize();
return 0;
}
編譯：
gcc -o testcpypy testcpypy.c -IC:\Python27\include -LC:\Python27\libs -lpython27 ---C:\Python27為python安裝目錄
或：
gcc -c testcpypy.c -IC:\Python27\include
gcc -o testcpypy.exe testcpypy.o -LC:\Python27\libs -lpython27
執行結果：
帶參數的情況：
#include "callpydll.h"
#include "Python.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
int callhello(char *instr, char *outstr)
{
PyObject *pMole = NULL;
PyObject *pFunc = NULL;
PyObject *reslt = NULL;
PyObject *pParm = NULL;
char *resltc = NULL;
int resltn;
int res;
char *helloWorld = "TestIM_ProtocBuf";
char *im_account = "aaaa";
char *auth_code = "aaaa";
char *im_uid = "aaaa";
char *proxy_topic = "";
//初始化Python
Py_Initialize();
if (!Py_IsInitialized()) {
printf("Py_Initialize");
getchar();
return -1;
}
//執行python語句
PyRun_SimpleString("import sys");
PyRun_SimpleString("sys.path.append('./')");
//載入python模塊
if(!(pMole = PyImport_ImportMole(helloWorld))) {
printf("PyImport_ImportMole");
getchar();
return -2;
}
//查找函數
pFunc = PyObject_GetAttrString(pMole, "login_proxy_body_serialize");
if ( !pFunc || !PyCallable_Check(pFunc) )
{
printf("can't find function [hello]");
getchar();
return -3;
}
//參數轉換C --> python, 參數必須是元組（一個參數也是，否則會失敗！！！坑啊）
pParm = Py_BuildValue("(ssss)", im_account, auth_code, im_uid, proxy_topic);
//調用python中的函數
reslt = (PyObject*)PyEval_CallObject(pFunc, pParm);
//將python返回的對象轉換為C的字元串
res = PyArg_ParseTuple(reslt, "si", &resltc, &resltn);
if (!res) {
printf("PyArg_Parse");
getchar();
return -4;
}
printf("resltn is %d", resltn);
memcpy(outstr, resltc, strlen(resltc)+1);
//釋放內存
Py_DECREF(reslt);
Py_DECREF(pFunc);
Py_DECREF(pMole);
Py_DECREF(pParm);
//關閉python
Py_Finalize();
return 0;
}
int main() {
int i;
char *dais = "iammain";
char res[10240];
memset(res,'\0',sizeof(res));
i = callhello(dais, res);
if(0 != i) {
printf("Notify:error");
getchar();
return -1;
}
printf("result is %s", res);
getchar();
return 0;
}
Ⅳ 怎樣把Python代碼嵌入到C程序
這篇文章主要介紹了將Python代碼嵌入C++程序進行編寫的實例,盡管通常還是Python代碼中調用C++程序的情況較多...需要的朋友可以參考下
把python嵌入的C++裡面需要做一些步驟
安裝python程序，這樣才能使用python的頭文件和庫
在我們寫的源文件中增加「Python.h」頭文件，並且鏈入「python**.lib」庫（還沒搞清楚這個庫時靜態庫還是導出庫，需要搞清楚）
掌握和了解一些python的C語言api，以便在我們的c++程序中使用
常用的一些C API函數
在了解下面的函數之前有必要了解一下**PyObject***指針，python裡面幾乎所有的對象都是使用這個指針來指示的。
Py_Initialize（）&&Py_Finalize（）
在調用任何python的c函數之前需要調用的函數，「Py_Initialize」是用來初始化python模塊的，推測是載入初始化載入dll的。對應的在使用python模塊之後用「Py_Finalize」來釋放模塊。
PyImport_ImportMole（）
用來載入一個python模塊，這個模塊就是一般的python文件。這里需要注意的是，在載入這個模塊的時候會執行模塊裡面所有可以執行的語句。包括import導入語句和在函數體之外的所有語句
PyObject_GetAttrString（）
返回模塊裡面的函數
Py_BuildValue（）
建立一個參數元組，一般都是用這個函數來建立元組，然後將這個元組作為參數傳遞給python裡面的函數。
PyEval_CallObject（）
調用函數，並把「Py_BuildValue」建立的元組作為參數傳遞給被調用的函數
源碼實例
下面的實例是在c++代碼中調用Python的函數，傳遞參數並且獲取返回值
test.cpp代碼
[cpp]view plain
#include<iostream>
#include<Python.h>
usingnamespacestd;
intmain(intargc,char*argv[])
{
Py_Initialize();//初始化
PyObject*pMole=NULL;
PyObject*pFunc=NULL;
PyObject*pParam=NULL;
PyObject*pResult=NULL;
constchar*pBuffer=NULL;
intiBufferSize=0;
pMole=PyImport_ImportMole(「test_python");
if(!pMole)
{
cout<<"getmolefailed!"<<endl;
exit(0);
}
pFunc=PyObject_GetAttrString(pMole,"main");
if(!pFunc)
{
cout<<"getfuncfailed!"<<endl;
cout<<int(pFunc)<<endl;
exit(0);
}
pParam=Py_BuildValue("(s)","HEHEHE");
pResult=PyEval_CallObject(pFunc,pParam);
if(pResult)
{
if(PyArg_Parse(pResult,"(si)",&pBuffer,iBufferSize))
{
cout<<pBuffer<<endl;
cout<<iBufferSize<<endl;
}
}
Py_DECREF(pParam);
Py_DECREF(pFunc);
Py_Finalize();
//cout<<"hello"<<endl;
return0;
}
defmain(szString):
return("hello",5)
test_python.py代碼
[py]view plain
Ⅳ 請教高手，我在C/C++中嵌入python，用PyImport
#include<iostream>
#include<Python.h>
usingnamespacestd;
voidHelloWorld();
voidAdd();
voidTestTransferDict();
voidTestClass();
intmain()
{
cout<<"StartingTest..."<<endl;
cout<<"HelloWorld()-------------"<<endl;
HelloWorld();
cout<<"Add()--------------------"<<endl;
Add();
cout<<"TestDict-----------------"<<endl;
TestTransferDict();
cout<<"TestClass----------------"<<endl;
TestClass();
system("pause");
return0;
}
//調用輸出"HelloWorld"函數
voidHelloWorld()
{
Py_Initialize();//使用python之前，要調用Py_Initialize();這個函數進行初始化
PyObject*pMole=NULL;//聲明變數
PyObject*pFunc=NULL;//聲明變數
pMole=PyImport_ImportMole("Test001");//這里是要調用的Python文件名
pFunc=PyObject_GetAttrString(pMole,"HelloWorld");//這里是要調用的函數名
PyEval_CallObject(pFunc,NULL);//調用函數,NULL表示參數為空
Py_Finalize();//調用Py_Finalize,這個和Py_Initialize相對應的.
}
//調用Add函數,傳兩個int型參數
voidAdd()
{
Py_Initialize();
PyObject*pMole=NULL;
PyObject*pFunc=NULL;
pMole=PyImport_ImportMole("Test001");//Test001:Python文件名
pFunc=PyObject_GetAttrString(pMole,"add");//Add:Python文件中的函數名
//創建參數:
PyObject*pArgs=PyTuple_New(2);//函數調用的參數傳遞均是以元組的形式打包的,2表示參數個數
PyTuple_SetItem(pArgs,0,Py_BuildValue("i",5));//0---序號i表示創建int型變數
PyTuple_SetItem(pArgs,1,Py_BuildValue("i",7));//1---序號
//返回值
PyObject*pReturn=NULL;
pReturn=PyEval_CallObject(pFunc,pArgs);//調用函數
//將返回值轉換為int類型
intresult;
PyArg_Parse(pReturn,"i",&result);//i表示轉換成int型變數
cout<<"5+7="<<result<<endl;
Py_Finalize();
}
//參數傳遞的類型為字典
voidTestTransferDict()
{
Py_Initialize();
PyObject*pMole=NULL;
PyObject*pFunc=NULL;
pMole=PyImport_ImportMole("Test001");//Test001:Python文件名
pFunc=PyObject_GetAttrString(pMole,"TestDict");//Add:Python文件中的函數名
//創建參數:
PyObject*pArgs=PyTuple_New(1);
PyObject*pDict=PyDict_New();//創建字典類型變數
PyDict_SetItemString(pDict,"Name",Py_BuildValue("s","WangYao"));//往字典類型變數中填充數據
PyDict_SetItemString(pDict,"Age",Py_BuildValue("i",25));//往字典類型變數中填充數據
PyTuple_SetItem(pArgs,0,pDict);//0---序號將字典類型變數添加到參數元組中
//返回值
PyObject*pReturn=NULL;
pReturn=PyEval_CallObject(pFunc,pArgs);//調用函數
//處理返回值:
intsize=PyDict_Size(pReturn);
cout<<"返回字典的大小為:"<<size<<endl;
PyObject*pNewAge=PyDict_GetItemString(pReturn,"Age");
intnewAge;
PyArg_Parse(pNewAge,"i",&newAge);
cout<<"TrueAge:"<<newAge<<endl;
Py_Finalize();
}
//測試類
voidTestClass()
{
Py_Initialize();
PyObject*pMole=NULL;
PyObject*pFunc=NULL;
pMole=PyImport_ImportMole("Test001");//Test001:Python文件名
pFunc=PyObject_GetAttrString(pMole,"TestDict");//Add:Python文件中的函數名
//獲取Person類
PyObject*pClassPerson=PyObject_GetAttrString(pMole,"Person");
//創建Person類的實例
PyObject*pInstancePerson=PyInstance_New(pClassPerson,NULL,NULL);
//調用方法
PyObject_CallMethod(pInstancePerson,"greet","s","HelloKitty");//s表示傳遞的是字元串,值為"HelloKitty"
Py_Finalize();
}
#test.py
defHelloWorld():
print"HelloWorld"
defadd(a,b):
returna+b
defTestDict(dict):
printdict
dict["Age"]=17
returndict
classPerson:
defgreet(self,greetStr):
printgreetStr
#printadd(5,7)
#a=raw_input("EnterToContinue...")
結果：
注意兩點：
若編譯Debug版，請將C:/Python26/libs下的python26.lib復制一份改名為python26_d.lib
test.py 記得放項目的當前目錄。
測試通過
Ⅵ 怎樣把Python代碼嵌入到C程序
步驟1：安裝Python開發包
由於需要訪問Python/C API，首先安裝Python開發包。
在Debian，Ubuntu或Linux Mint中：
在CentOS，Fedora或RHEL中：
安裝成功後，Python頭文件在/usr/include/python2.7。根據Linux發行版的不同，確切的路徑可能是不相同的。例如，CentOS 6中是/usr/include/python2.6。
步驟2：初始化解釋器並設置路徑
C中嵌入Python的第一步是初始化Python解釋器，這可以用以下C函數完成。
初始化解釋器後，需要設置你的C程序中要導入的Python模塊的路徑。例如，比如你的Python模塊位於/usr/local/moles。然後使用以下C函數調用來設置路徑。
步驟3：數據轉換
C中嵌入Python最重要的方面之一是數據轉換。從C中傳遞數據到Python函數，需要首先將數據從C數據類型轉換到Python數據類型。Python/C API提供各種函數來實現這。例如，轉換C字元串到Python字元串，使用PyString_FromString函數。
另外一個類似函數PyInt_FromLong，將C中long數據類型轉換為Python int。每個Python/C API函數返回一個PyObject類型的引用。
步驟4：定義一個Python模塊
當你想嵌入Python代碼到另一種語言如C，該代碼需要被寫成Python模塊，然後用另一種語言「導入」。所以讓我們來看看如何在C中導入Python模塊。
為了進行說明，我們實現一個簡單的Python模塊例子如下：
以上的Python函數有一個字元串作為參數並返回兩個重復的字元串。例如，如果輸入字元串是「cyberpersons」，該函數返回'cyberpersonscyberpersons'。此模塊文件命名為「printData.py」並將它放在前面聲明的Python模塊目錄中（/usr/local/moles）。
步驟5：載入一個Python模塊
現在你已經定義了Python模塊，是時候在C程序中載入它了。導入模塊的C代碼看起來像這樣：
步驟6：構建函數的參數
當載入一個模塊時，可以調用模塊中定義的Python函數。通常，我們需要傳遞一個或多個參數到一個Python函數。我們必須構建一個Python元組對象，它包括Python函數中的參數。
在我們的例子中，printData函數定義帶一個參數的模塊。因此，我們構建一個大小是一的Python元組對象如下。我們可以使用PyTuple_SetItem設置元組對象的每個項。
我們已經成功構建一個參數傳遞到函數調用，是時候從C程序調用python函數了。
步驟7：調用Python函數
一旦成功創建Python元組對象作為函數參數，我們可以調用一個帶參數的Python函數。為此，通過使用PyObject_GetAttrString首先獲得模塊中定義的函數的引用，然後使用PyObject_CallObject調用該函數。例如：
步驟8：錯誤檢查
避免運行時錯誤的常見方法是檢查函數的返回值並根據返回值採取適當的行動。類似於C程序中的全局變數errno，Python/C API提供一個全局指示符，它報告最後發生的錯誤。當Python/C API函數失敗，全局指示符設置為指示錯誤，並且PyErr_Print可以用於顯示相應的人類可讀的trackback。例如：
在你的應用程序中，你可以輕松地將各種錯誤檢查。
這里是完整的C程序，它如本教程描述的嵌入Python代碼。
步驟9：編譯和執行
保存以上代碼到finalCode.c，並且鏈接Python庫（-lpython2.7）編譯該代碼。根據發行版的不同，可能使用不同的版本（例如，-lpython2.6）。
Ⅶ python與c++混合編程如何入門
派桑和c/c++實際上是不同的工具，一個是斧頭，一個是菜刀，各有各的用途。非要把讓菜刀能砍柴，讓斧頭能切菜，這種努力有無必要，值得考慮。
派桑常用劇本，嚕蘇，速度慢，不嚴謹，但有它的便利，例如它有 list, tuple, 之類的東西。
混合編程 常用於 提高 派桑 速度。
常用 方法 是（1）包含 Python.h 文件頭 （2）定義 派桑 的 各種對象 為 各種 c 結構
（3）派桑 的 各種對象用指針，名字用 Py 或 _Py大頭 動態分配 在 heap （4）用函數跟蹤統計 各種對象結構 的個數變化，即時 釋放內存（5）及時處理 派桑 exception
(6) 輸出為派桑的數據格式。
我沒有合起來用過，不過基本套路如此。
Ⅷ 求助 關於c程序中嵌入Python的問題
在C/C++中嵌入Python也比較簡單，首先需要在VC中添加Python的include文件目錄和lib文件目錄：
VC6.0下，打開 tools->options->directories->show directories for，將Python安裝目錄下的inlude目錄添加到inlude files項中，將libs目錄添加到library files項中。
VC2005下，打開tools->options->項目和解決方案->VC++目錄，然後做相同工作。
代碼如下：
//在debug下執行出錯，「無法找到python31_d.lib文件」，後查到原因是：在debug下生成必須要有python31_d.lib文件，否則只能在release下生成
#include <python.h>
int main()
{
Py_Initialize();
PyRun_SimpleString("Print 'hi, python!'");
Py_Finalize();
return 0;
}
Py_Initialize函數原型是：void Py_Initialize()，在嵌入Python腳本時必須使用該函數，它初始化Python解釋器，在使用其他的Python/C API之前必須先調用該函數。可以使用Py_IsInitialized函數判斷是否初始化成功，成功返回True。
PyRun_SimpleString函數原型是int PyRun_SimpleString(const char *command)，用來執行一段Python代碼。注意：是否需要維持語句間的縮進呢？
Py_Finalize函數原型是void Py_Finalize()，用於關閉Python解釋器，釋放解釋器所佔用的資源。
PyRun_SimpleFile函數可以用來運行".py"腳本文件，函數原型如下：
int PyRun_SimpleFile(FILE *fp, const char *filename);
其 中fp是打開的文件指針，filename是要運行的python腳本文件名。但是由於該函數官方發布的是由visual studio 2003.NET編譯的，如果使用其他版本的編譯器，FILE定義可能由於版本原因導致崩潰。同時，為簡便起見可以使用如下方式來代替該函數：
PyRun_SimpleString("execfile(『file.py』)"); //使用execfile來運行python文件
Py_BuildValue()用於對數字和字元串進行轉換處理，變成Python中相應的數據類型（在C語言中，所有Python類型都被聲明為PyObject類型），函數原型如下：
PyObject *Py_BuildValue(const char *format, …..);
PyString_String()用於將PyObject*類型的變數轉換成C語言可以處理的char*型，具體原型如下：
char* PyString_String(PyObject *p);
列表操作函數：
PyObject * PyList_New(Py_ssize_t len);
int PyList_SetItem(PyObject *list, Py_ssize_t index, PyObject *item);
PyObject * PyList_GetItem(PyObject *list, Py_ssize_t index);
int PyList_Append(PyObject *list, PyObject *item);
int PyList_Sort(PyObject *list);
int PyList_Reverse(PyObject *list);
Py_ssize_t PyList_Size(PyObject *list);
元組操作函數：
int PyTuple_New(Py_ssize_t len);
int PyTuple_SetItem(PyObject *p, Py_ssize_t pos, PyObject *o);
PyObject * PyTuple_GetItem(PyObject *p, Py_ssize_t pos);
int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize); //注意是**指針
字典操作函數：
PyObject * PyDict_New();
int PyDict_SetItem(PyObject *p, PyObject *key, PyObject *val);
int PyDict_SetItemString(PyObject *p, const char *key, PyObject *val);
PyObject* PyDict_GetItem(PyObject *p, PyObject *key);
PyObject* PyDict_GetItemString(PyObject *p, const char *key);
//與PyDict_SetItemString對應
int PyDict_DelItem(PyObject *p, PyObject *key);
int PyDict_DelItemString(PyObject *p, char *key);
//與PyDict_SetItemString對應
int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue);
PyObject* PyDict_Items(PyObject *p);
PyObject* PyDict_keys(PyObject *p);
PyObject* PyDict_Values(PyObject *p);
在C/C++中使用Python對象應正確地處理引用計數問題，否則容易導致內存泄漏。當使用Python/C API中的函數創建列表、元組、字典等後，在對其完成操作後應該使用Py_CLEAR()和Py_DECREF()等宏來銷毀這些對象。原型如下：
void Py_CLEAR(PyObject *o);
void Py_DECREF(PyObject *o);
其中，對於Py_CLEAR函數，參數可以為NULL指針，表示不進行任何操作，但是Py_DECREF函數不能為NULL指針，否則導致錯誤。
使用PyImport_Import()函數可以在C中導入Python模塊，返回一個模塊對象。函數原型為：
PyObject* PyImport_Import(PyObject *name);
PyMole_GetDict()函數可以獲得Python模塊中的函數列表，返回一個字典，字典中的關鍵字為函數名，值為函數的調用地址。原型如下：
PyObject* PyMole_GetDict(PyObject *mole);
使用PyObject_CallObject()函數和PyObject_CallFunction()函數可以在C中調用Python中的函數，原型如下：
PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args);
//args是元組形式
PyObject* PyObject_CallFunction(PyObject *callable, char *format, ……);
//format是類似」iss」這樣的參數類型，後面是指定參數
可以使用PyCallable_Check(func)來判斷是否可以調用函數，可以則返回True。