python調用c庫
『壹』 c可以調用python嗎
可以的。
C中內嵌Python
新建立一個工程，首先需要將工作目錄設置到Python-3.1.1PCbuild中，以獲取到動態庫，至於靜態庫的包含，Include目錄的指定，那自然也是少不了的。文件中需要包含Python.h文件，這也是必須的。
介面中
Py_Initialize();
Py_Finalize();
其他的根據需求，再引入相應的python builder 即可
『貳』 如何在python中調用c語言代碼
先把C語言代碼做成DLL文件，再用python載入此DLL文件來訪問C語言功能代碼
『叄』 用python怎樣調用靜態庫里的c函數
將event.py目錄加入到system path中
1
2
3
import sys
sys.path.append("/Users/songrao/Library/Application Support/Sublime Text 3/Packages/User/")
from event import printme
『肆』 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的動態鏈接庫
Python調用C/C++動態鏈接庫的需求
在自動化測試過程中，難免會遇到語言混合使用的情況，這不，我們也遇到了。初步決定採用Robot Framework作為自動化測試框架後，其支持Java和Python，而Python作為主流的語言，怎麼能放棄使用它的機會^_^。 然而產品採用是古老90年代開發的C/S結構，因為古老，當時也沒有考慮到對產品的測試進行自動化，Client端並沒有預留CLI(Command Line interface)形式的介面，真是雪上加霜啊。
那怎麼自動化？採用AutoIT來對客戶端界面進行自動化測試？可惜AutoIT對當初開發採用的控制項識別不是很好，如果採用控制項所在位置來進行控制的方式，又會導致自動化測試並不是很穩定。那麼！！！只有自己開發介面了，目前在Client端開發出CLI形式的介面，將其封裝為DLL，然後在Robot FrameWork框架中採用Python對DLL進行調用。任務艱巨哪！
Python調用DLL例子
示例一
首先，在創建一個DLL工程(本人是在VS 2005中創建)，頭文件：
[cpp] view plain 在CODE上查看代碼片派生到我的代碼片//hello.h
#ifdef EXPORT_HELLO_DLL
#define HELLO_API __declspec(dllexport)
#else
#define HELLO_API __declspec(dllimport)
#endif
extern "C"
{
HELLO_API int IntAdd(int , int);
}
CPP文件：
[cpp] view plain 在CODE上查看代碼片派生到我的代碼片//hello.cpp
#define EXPORT_HELLO_DLL
#include "hello.h"
HELLO_API int IntAdd(int a, int b)
{
return a + b;
}
這里有兩個注意點：
（1）弄清楚編譯的時候函數的調用約定採用的__cdecl還是__stdcall，因為根據DLL中函數調用約定方式，Python將使用相應的函數載入DLL。
（2）如果採用C++的工程，那麼導出的介面需要extern "C"，這樣python中才能識別導出的函數。
我的工程中採用__cdecl函數調用約定方式進行編譯鏈接產生hello.dll，然後Python中採用ctypes庫對hello.dll進行載入和函數調用：
[python] view plain 在CODE上查看代碼片派生到我的代碼片from ctypes import *
dll = cdll.LoadLibrary('hello.dll');
ret = dll.IntAdd(2, 4);
print ret;
OK，一個小例子已經完成了，如果你感興趣，但還沒試過，那就嘗試一下吧。
示例二
示例一隻是一個"hello world"級別的程序，實際運用中更多的需要傳遞數據結構、字元串等，才能滿足我們的需求。那麼這個示例將展示，如何傳遞數據結構參數，以及如何通過數據結構獲取返回值。
首先編寫DLL工程中的頭文件：
[cpp] view plain 在CODE上查看代碼片派生到我的代碼片//hello.h
#ifdef EXPORT_HELLO_DLL
#define HELLO_API __declspec(dllexport)
#else
#define HELLO_API __declspec(dllimport)
#endif
#define ARRAY_NUMBER 20
#define STR_LEN 20
struct StructTest
{
int number;
char* pChar;
char str[STR_LEN];
int iArray[ARRAY_NUMBER];
};
extern "C"
{
//HELLO_API int IntAdd(int , int);
HELLO_API char* GetStructInfo(struct StructTest* pStruct);}
CPP文件如下：
[cpp] view plain 在CODE上查看代碼片派生到我的代碼片//hello.cpp
#include <string.h>
#define EXPORT_HELLO_DLL
#include "hello.h"
HELLO_API char* GetStructInfo(struct StructTest* pStruct){
for (int i = 0; i < ARRAY_NUMBER; i++)
pStruct->iArray[i] = i;
pStruct->pChar = "hello python!";
strcpy (pStruct->str, "hello world!");
pStruct->number = 100;
return "just OK";
}
GetStructInfo這個函數通過傳遞一個StructTest類型的指針，然後對對象中的屬性進行賦值，最後返回"just OK".
編寫Python調用代碼如下，首先在Python中繼承Structure構造一個和C DLL中一致的數據結構StructTest，然後設置函數GetStructInfo的參數類型和返回值類型，最後創建一個StructTest對象，並將其轉化為指針作為參數，調用函數GetStrcutInfo，最後通過輸出數據結構的值來檢查是否調用成功：
[python] view plain 在CODE上查看代碼片派生到我的代碼片from ctypes import *
ARRAY_NUMBER = 20;
STR_LEN = 20;
#define type
INTARRAY20 = c_int * ARRAY_NUMBER;
CHARARRAY20 = c_char * STR_LEN;
#define struct
class StructTest(Structure):
_fields_ = [
("number", c_int),
("pChar", c_char_p),
("str", CHARARRAY20),
("iArray", INTARRAY20)
]
#load dll and get the function object
dll = cdll.LoadLibrary('hello.dll');
GetStructInfo = dll.GetStructInfo;
#set the return type
GetStructInfo.restype = c_char_p;
#set the argtypes
GetStructInfo.argtypes = [POINTER(StructTest)];objectStruct = StructTest();
#invoke api GetStructInfo
retStr = GetStructInfo(byref(objectStruct));#check result
print "number: ", objectStruct.number;
print "pChar: ", objectStruct.pChar;
print "str: ", objectStruct.str;
for i,val in enumerate(objectStruct.iArray):
print 'Array[i]: ', val;
print retStr;
總結
1. 用64位的Python去載入32位的DLL會出錯
2. 以上只是些測試程序，在編寫Python過程中盡可能的使用"try Except"來處理異常3. 注意在Python與C DLL交互的時候位元組對齊問題4. ctypes庫的功能還有待繼續探索
『陸』 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#庫的dll文件
importclr
importSystem
clr.AddReferenceToFile("SimpleHash.dll")
fromCommonimport*
classHashPy(SimpleHash):
def__init__(self):
pass
defHashCalc(self,arg1,arg2):
#strtobyte[]
arg1=System.Text.Encoding.Default.GetBytes(arg1)
arg2=System.Text.Encoding.Default.GetBytes(arg2)
returnSimpleHash.HashCalc(self,arg1,arg2)
audiobuff='
12345678
12345678
'
key='12345678'
printHashPy().HashCalc(audiobuff,key)
python ctype只能調用c/c++. 你要調用c#的dll 要用IronPython。如上面的例子
『捌』 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++程序互相調用
二、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()。