python引用c
❶ python如何調用C++外部庫中的類
你好流程比較復雜，需要通過一個c的介面來做。下面是一個簡單的例子，你也可以到booth去看看他們是怎麼用的。
//YourFile.cpp (compiled into a .dll or .so file)
#include
//For std::nothrow
//Either include a header defining your class, or define it here.
extern "C" //Tells the compile to use C-linkage for the next scope.
{
//Note: The interface this linkage region needs to use C only.
void * CreateInstanceOfClass( void )
{
// Note: Inside the function body, I can use C++.
return new(std::nothrow) MyClass;
}
//Thanks Chris.
void DeleteInstanceOfClass (void *ptr)
{
delete(std::nothrow) ptr;
}
int CallMemberTest(void *ptr)
{
// Note: A downside here is the lack of type safety.
// You could always internally(in the C++ library) save a reference to all
// pointers created of type MyClass and verify it is an element in that
//structure.
//
// Per comments with Andre, we should avoid throwing exceptions.
try
{
MyClass * ref = reinterpret_cast
(ptr);
return ref->Test();
}
catch(...)
{
return -1; //assuming -1 is an error condition.
}
}
} //End C linkage scope.
第二步：
gcc -shared -o test.so test.cpp
#creates test.so in your current working directory.
第三步：
>>> from ctypes import cdll
>>> stdc=cdll.LoadLibrary("libc.so.6") # or similar to load c library
>>> stdcpp=cdll.LoadLibrary("libstdc++.so.6") # or similar to load c++ library
>>> myLib=cdll.LoadLibrary("/path/to/test.so")
>>> spam = myLib.CreateInstanceOfClass()
>>> spam
[outputs the pointer address of the element]
>>> value=CallMemberTest(spam)
[does whatever Test does to the spam reference of the object]
❷ 如何讓python調用C和C++代碼
二、Python調用C/C++1、Python調用C動態鏈接庫Python調用C庫比較簡單，不經過任何封裝打包成so，再使用python的ctypes調用即可。（1）c語言文件：pycall.c[html]viewplain/***gcc-olibpycall.so-shared-fPICpycall.c*/#include#includeintfoo(inta,intb){printf("youinput%dand%d\n",a,b);returna+b;}（2）gcc編譯生成動態庫libpycall.so：gcc-olibpycall.so-shared-fPICpycall.c。使用g++編譯生成C動態庫的代碼中的函數或者方法時，需要使用extern"C"來進行編譯。（3）Python調用動態庫的文件：pycall.py[html]viewplainimportctypesll=ctypes.cdll.LoadLibrarylib=ll("./libpycall.so")lib.foo(1,3)print'***finish***'（4）運行結果：2、Python調用C++(類)動態鏈接庫需要extern"C"來輔助，也就是說還是只能調用C函數，不能直接調用方法，但是能解析C++方法。不是用extern"C"，構建後的動態鏈接庫沒有這些函數的符號表。（1）C++類文件：pycallclass.cpp[html]viewplain#includeusingnamespacestd;classTestLib{public:voiddisplay();voiddisplay(inta);};voidTestLib::display(){cout#include#includeintfac(intn){if(n<2)return(1);/*0!==1!==1*/return(n)*fac(n-1);/*n!==n*(n-1)!*/}char*reverse(char*s){registerchart,/*tmp*/*p=s,/*fwd*/*q=(s+(strlen(s)-1));/*bwd*/while(p
❸ c可以調用python嗎
可以的。
C中內嵌Python
新建立一個工程，首先需要將工作目錄設置到Python-3.1.1PCbuild中，以獲取到動態庫，至於靜態庫的包含，Include目錄的指定，那自然也是少不了的。文件中需要包含Python.h文件，這也是必須的。
介面中
Py_Initialize();
Py_Finalize();
其他的根據需求，再引入相應的python builder 即可
❹ 怎樣把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寫的嗎
python是用c寫的，下面給大家介紹一下Python與c的聯系：
python的誕生
1991年，第一個Python編譯器(同時也是解釋器)誕生。它是用C語言實現的，並能夠調用C庫(.so文件)。從一出生，Python已經具有了：類(class)，函數(function)，異常處理(exception)，包括表(list)和詞典(dictionary)在內的核心數據類型，以及模塊(mole)為基礎的拓展系統。
Guido希望有一種語言，這種語言能夠像C語言那樣，能夠全面調用計算機的功能介面，又可以像shell那樣，可以輕松的編程。ABC語言讓Guido看到希望。ABC是由荷蘭的CWI (Centrum Wiskunde & Informatica, 數學和計算機研究所)開發的。Guido在CWI工作，並參與到ABC語言的開發。ABC語言以教學為目的。與當時的大部分語言不同，ABC語言的目標是「讓用戶感覺更好」。ABC語言希望讓語言變得容易閱讀，容易使用，容易記憶，容易學習，並以此來激發人們學習編程的興趣。
相關推薦：《Python基礎教程》
python與c
Python語法很多來自C，但又受到ABC語言的強烈影響。來自ABC語言的一些規定直到今天還富有爭議，比如強制縮進。但這些語法規定讓Python容易讀。另一方面，Python聰明的選擇服從一些慣例(特別是C語言的慣例)。比如使用等號賦值，使用def來定義函數。Guido認為，如果「常識」上確立的東西，沒有必要過度糾結。
Python從一開始就特別在意可拓展性(extensibility)。Python可以在多個層次上拓展。從高層上，你可以引入.py文件。在底層，你可以引用C語言的庫。Python程序員可以快速的使用Python寫.py文件作為拓展模塊。但當性能是考慮的重要因素時，Python程序員可以深入底層，寫C程序，編譯為.so文件引入到Python中使用。Python就好像是使用鋼構建房一樣，先規定好大的框架。而程序員可以在此框架下相當自由的拓展或更改。
最初的Python完全由Guido本人開發。Python得到Guido同事的歡迎。他們迅速的反饋使用意見，並參與到Python的改進。Guido和一些同事構成Python的核心團隊。他們將自己大部分的業余時間用於hack Python (也包括工作時間，因為他們將Python用於工作)。隨後，Python拓展到CWI之外。Python將許多機器層面上的細節隱藏，交給編譯器處理，並凸顯出邏輯層面的編程思考。Python程序員可以花更多的時間用於思考程序的邏輯，而不是具體的實現細節 (Guido有一件T恤，寫著：人生苦短，我用Python)。這一特徵吸引了廣大的程序員。Python開始流行。
python的發展
到今天，Python的框架已經確立。Python語言以對象為核心組織代碼(Everything is object)，支持多種編程範式(multi-paradigm)，採用動態類型(dynamic typing)，自動進行內存回收(garbage collection)。Python支持解釋運行(interpret)，並能調用C庫進行拓展。Python有強大的標准庫 (battery included)。由於標准庫的體系已經穩定，所以Python的生態系統開始拓展到第三方包。這些包，如Django, web.py, wxpython, numpy, matplotlib,PIL.
Python從其他語言中學到了很多，無論是已經進入歷史的ABC，還是依然在使用的C和Perl，以及許多沒有列出的其他語言。可以說，Python的成功代表了它所有借鑒的語言的成功。同樣，Ruby借鑒了Python，它的成功也代表了Python某些方面的成功。每個語言都是混合體，都有它優秀的地方，但也有各種各樣的缺陷。同時，一個語言「好與不好」的評判，往往受制於平台、硬體、時代等等外部原因。
❻ python調用c語言編譯器
如何讓python調用C和C++代碼
安裝python後，會有一個chm格式的python手冊。要搞明白如何讓python調用C/C++代碼(也就是寫python的 extension)，你需要征服手冊中的
<<Extending && embedding>>厚厚的一章。在昨天花了一個小時看地頭暈腦脹，仍然不知道如何寫python的extension後，查閱了一些其他 書籍，最終在<<Python Programming On Win32>>書中找到了教程。
下面記錄一下如何在visual studio 2005中，寫一段C/C++的MessageBox代碼，然後提供後python調用，最後的結果當然是顯示一個MessageBox.
1. 首先要明白的是，所謂的python擴展（也就是你提供給python的c/c++代碼，不一定是c/c++代碼，可以是其他語言寫的代碼)是一個 dll,並且這個dll放在本機python安裝目錄下的DLLs目錄下（譬如我機器上的路徑是：F:\Program Files\Python25\DLLs)，假如我們接下來要寫的擴展mole名為mb,python調用的代碼為： import mb
mb.showMsg("Python's really amazing, I kindda love it!")
python怎麼找到我們的mb模塊呢？就是上面說的，我們要生成一個mb.dll，然後拷貝到Dlls目錄下面，為了區別普通的dll和python專用擴展的dll,我們的 mb.dll修改成mb.pyd(python dll)
2. 搭建環境，我們要使用python提供的c頭文件和lib庫來進行擴展的開發。 在vs 2005下點擊菜單 "工具"->"選項", 打開選項對話框，選擇"項目和解決方案->VC++目錄", 然後在右邊"顯示以下內容的目錄"得comboBox上選擇"包含文件」，添加python的include目錄(我的機器上是"F:\Program
Files\Python25\include"),然後選擇庫文件,添加python的libs目錄(我的機器上是"F:\Program Files\Python25\libs")。
既然擴展是一個dll,接下來我們要建立一個「動態鏈接庫」工程，然後開始寫代碼：
#include <python.h> //python.h是包含python一些定義的頭文件，在python的include目錄下 /*
我的python版本是2.5, 因為安裝python後它沒提供debug下的lib庫文件，因此你必須生成release版的dll，
想要生成dll版本的，你要到python官網上自己去下載python源代碼,當然你可以繼續生成release版本的dll,但dll中包含調試信息
❼ python 怎麼調用c語言介面
ctypes: 可直接調用c語言動態鏈接庫。
使用步驟：
1> 編譯好自己的動態連接庫
2> 利用ctypes載入動態連接庫
3> 用ctype調用C函數介面時，需要將python變數類型做轉換後才能作為函數參數，轉換原則見下圖：
#Step1:test.c#include<stdio.h>
intadd(inta,intb)
{
returna+b;
}#Step2:編譯動態鏈接庫(如何編譯動態鏈接庫在本文不詳解，網上資料一大堆。)gcc-fPIC-sharedtest.c-olibtest.so
#Step3:test.py
fromctypesimport*mylib=CDLL("libtest.so")或者cdll.LoadLibrary("libtest.so")add=mylib.add
add.argtypes=[c_int,c_int]#參數類型，兩個int（c_int是ctypes類型，見上表）
add.restype=c_int#返回值類型，int(c_int是ctypes類型，見上表）
sum=add(3,6)
❽ 怎樣讓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()。
❾ python調用c函數
Python是解釋性語言, 底層就是用c實現的, 所以用python調用C是很容易的, 下面就總結一下各種調用的方法, 給出例子, 所有例子都在ubuntu9.10, python2.6下試過
1. Python 調用 C (base)
想在python中調用c函數, 如這兒的fact
#include <Python.h>
int fact(int n)
{
if (n <= 1)
return 1;
else
return n * fact(n - 1);
}
PyObject* wrap_fact(PyObject* self, PyObject* args)
{
int n, result;
if (! PyArg_ParseTuple(args, "i:fact", &n))
return NULL;
result = fact(n);
return Py_BuildValue("i", result);
}
static PyMethodDef exampleMethods[] =
{
{"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
{NULL, NULL}
};
void initexample()
{
PyObject* m;
m = Py_InitMole("example", exampleMethods);
}
把這段代碼存為wrapper.c, 編成so庫,
gcc -fPIC wrapper.c -o example.so -shared -I/usr/include/python2.6 -I/usr/lib/python2.6/config
然後在有此so庫的目錄, 進入python, 可以如下使用
import example
example.fact(4)
2. Python 調用 C++ (base)
在python中調用C++類成員函數, 如下調用TestFact類中的fact函數,
#include <Python.h>
class TestFact{
public:
TestFact(){};
~TestFact(){};
int fact(int n);
};
int TestFact::fact(int n)
{
if (n <= 1)
return 1;
else
return n * (n - 1);
}
int fact(int n)
{
TestFact t;
return t.fact(n);
}
PyObject* wrap_fact(PyObject* self, PyObject* args)
{
int n, result;
if (! PyArg_ParseTuple(args, "i:fact", &n))
return NULL;
result = fact(n);
return Py_BuildValue("i", result);
}
static PyMethodDef exampleMethods[] =
{
{"fact", wrap_fact, METH_VARARGS, "Caculate N!"},
{NULL, NULL}
};
extern "C" //不加會導致找不到initexample
void initexample()
{
PyObject* m;
m = Py_InitMole("example", exampleMethods);
}
把這段代碼存為wrapper.cpp, 編成so庫,
g++ -fPIC wrapper.cpp -o example.so -shared -I/usr/include/python2.6 -I/usr/lib/python2.6/config
然後在有此so庫的目錄, 進入python, 可以如下使用
import example
example.fact(4)
3. Python 調用 C++ (Boost.Python)
Boost庫是非常強大的庫, 其中的python庫可以用來封裝c++被python調用, 功能比較強大, 不但可以封裝函數還能封裝類, 類成員.
http://dev.gameres.com/Program/Abstract/Building%20Hybrid%20Systems%20with%20Boost_Python.CHN.by.JERRY.htm
首先在ubuntu下安裝boost.python, apt-get install libboost-python-dev
#include <boost/python.hpp>
char const* greet()
{
return "hello, world";
}
BOOST_PYTHON_MODULE(hello)
{
using namespace boost::python;
def("greet", greet);
}
把代碼存為hello.cpp, 編譯成so庫
g++ hello.cpp -o hello.so -shared -I/usr/include/python2.5 -I/usr/lib/python2.5/config -lboost_python-gcc42-mt-1_34_1
此處python路徑設為你的python路徑, 並且必須加-lboost_python-gcc42-mt-1_34_1, 這個庫名不一定是這個, 去/user/lib查
然後在有此so庫的目錄, 進入python, 可以如下使用
>>> import hello
>>> hello.greet()
'hello, world'
4. python 調用 c++ (ctypes)
ctypes is an advanced ffi (Foreign Function Interface) package for Python 2.3 and higher. In Python 2.5 it is already included.
ctypes allows to call functions in dlls/shared libraries and has extensive facilities to create, access and manipulate simple and complicated C data types in Python - in other words: wrap libraries in pure Python. It is even possible to implement C callback functions in pure Python.
http://python.net/crew/theller/ctypes/
#include <Python.h>
class TestFact{
public:
TestFact(){};
~TestFact(){};
int fact(int n);
};
int TestFact::fact(int n)
{
if (n <= 1)
return 1;
else
return n * (n - 1);
}
extern "C"
int fact(int n)
{
TestFact t;
return t.fact(n);
}
將代碼存為wrapper.cpp不用寫python介面封裝, 直接編譯成so庫,
g++ -fPIC wrapper.cpp -o example.so -shared -I/usr/include/python2.6 -I/usr/lib/python2.6/config
進入python, 可以如下使用
>>> import ctypes
>>> pdll = ctypes.CDLL('/home/ubuntu/tmp/example.so')
>>> pdll.fact(4)
12
❿ 如何在python中調用C語言代碼
先把C語言代碼做成DLL文件，再用python載入此DLL文件來訪問C語言功能代碼