㈠ python 怎麼封裝有枚舉類型的c語言編寫的介面
枚舉就用幾個整數表示就可以了
㈡ 在python中如何調用PCSC中的介面
你找個工具將這個介面API，自動轉換成python版本的就可以了。好象是SWIG和Boost。 這兩個以前看過，偶爾還試過幾次。之所以建議你用自動工具，就是因為python對於C++擴展麻煩些，對於C語言介面可以使用ctypes和cython簡單解決。不過C++如果用這些方法有時候被很麻煩。
boost在linux里會經常用到，在windows下也可以使用。SWIG在一般的教程里都會提及到。SIP也是最近出名的。
下面是一些參考資料，搜索來的。
=== 使用工具進行擴展 ===
雖然擴展過程並不復雜，但也可以使用許多已知的工具簡化擴展過程。
(1) SWIG
由David Beazley創建，是一個自動的擴展構造工具。它讀入注釋的C/C++頭文件，為python、tcl、perl等多種腳本語言產生wrap代碼。SWIG可以包裝大量C++特性到Python的擴展模塊中。
評價：swig簡單，可以支持多種腳本文件，但支持的c++特性不完備。
(2) SIP
由Phil Thompson創建，是一個C++模塊構造器，專門為C++的類創造wrapper。它曾經被用於創建PyQt和PyKDE擴展模塊，因此比較出名。
評價：支持C++特徵很齊全，但比較復雜。
(3) bgen
該工具被包含在標准Python發布包中的模塊構建工具集里，由Jack Jansen維護。它用於產生在Macintosh版本可用的Python擴展模塊。
(4) pyfort
由Paul bois創建，用來產生Fortran語言生成的擴展模塊。
(5) cxx
也由Paul Dubois創建，是一個庫，為Python的C++擴展提供了友好的API。Cxx允許將許多python對象（如list和tuple）使用到STL的運算中。庫也提供了C++異常處理到python異常處理的轉化。
(6) WrapPy
由Greg Couch創建，通過讀入C++頭文件來產生擴展模塊。
(7) Boost Python Library
由David Abrahams創建。該庫提供了更多與眾不同的C++ wrap到python擴展中，而只需要對要擴展的C++類寫很少的附加信息。
評價：Boost為C++提供了許多實用的庫，如Regex（正則表達式庫）、Graph（圖組件和演算法）、concept check（檢查泛型編程中的concept）、Thread（可移植的C++多線程庫）、Python（把C++類和函數映射到Python之中）、Pool（內存池管理）等等。
Boost總體來說是實用價值很高，質量很高的庫。並且強調對跨平台的支持。但是Boost中也有很多是實驗性質的東西，在實際的開發中實用需要謹慎。
boost.python支持的c++特性較多，但是比較復雜。
㈢ python和c語言交互指針數據沒有發生變化
python是當下十分火爆的編程語言，尤其在人工智慧應用方面。如果有心從事編程方向的工作，最好到專業機構深入學習、多實踐，更貼近市場，這樣更有利於將來的發展。
㈣ c語言和python哪個好入門
從開始看Python到現在也有半個多月了，前後看了Python核心編程和Dive into
Python兩本書。話說半個月看兩本，是個人都知道有多囫圇吞棗，這也是因為我暫時沒有需求拿這個做大型開發，主要是平時的小程序test用一用。所以
我的策略是，整體瀏覽，用到時候現查。話說這核心編程第一版太古老了，老在講2.2之前的東西，我看的翻譯電子版，翻譯得也不好，很晦澀。看完這個後還有
點雲里霧里，看網上人家說DIP好，啄木鳥還有免費電子文檔，就找來看這個。怎麼說呢，講的比核心編程好，但不適合第一次看的初學者。我之所以覺得講得
好，是因為看核心編程，有些概念還有些模糊，看了這本書就明白不少了。要是初學者上來就看這本，保證不好理解。
下面就是在學習的過程中，在翻閱資料的過程中，總結的一些C和python比較明顯的不同之處，有大方向的，也有細節的。肯定沒有總結完，比如動態
函數，lambda這些，我都懶得往上寫了。實際上，作為兩種完全不同的語言，下面這些差異只是冰山一角而已。權當拋磚引玉吧，至少應該對和我有相同研究
興趣，正在考慮是否學習另一門語言的朋友有點幫助。此文也算是DIP的學習筆記吧。順帶說一句，要是有朋友了解，可以幫忙推薦一下實戰性強的Python
教材，語言這東西，不多練手，光比劃，是不可能學好的。
學習目的
我的以後的研究方向是嵌入式，顯然，C語言是我的主要語言。我不是一個語言愛好者，我以前覺得，對於做研究而不是應用的人來說，了解多門語言，不如
精通一門語言。之所以去看python，主要還是因為python更有利於快速開發一些程序，也是因為現在認識到，研究和應用是不能分離的。個人以為，要
想在計算機工程的競爭中立足，必須懂C語言。因為真正要做高性能編程,
不可能將機器的體系架構拋到腦後讓Python虛擬機（或Java虛擬機等）幫你搞定所有底層。越來越多的CPU
core，越來越恐怖的內存性能瓶頸，對於上層開發人員來說，無所謂，但是對高性能程序開發人員來說，這些是無法透明的。很多應用，還是自己掌控比較有
效。這些場合中，匯編和C還是不可替代的。但是，光知道C是不夠的，掌握一門面向對象語言，相對更高層的語言，不僅對以後的個人發展有利，也會對自己的技
術認識產生幫助。
如果要問對我來說誰更重要，我覺得還是C更重要。C的學習曲線更陡，貌似簡單，實際上到處都是陷阱，看上去比較簡單低效的程序，也不是學1，2個月
就能搞定的。談到優化的深層次和難度嘛，需要的功底是按年算的。但是一旦你C語言的基礎打好了，對計算機的理解，對其他語言的理解都是大有裨益的。比如，
如果你有C基礎，可以說，學過1天python，就能寫的出來一些不短的程序。後面的優化也不是什麼大不了的演算法，都是非常基本的語句換來換去。當然這里
不是說 Python不好，實際上，上層應用，Python比C方便的不是一個層次。
很多人覺得，既然懂C了，那麼進一步掌握C＋＋應該是水到渠成，但C++不是C的超集，而我又不喜歡C＋＋的繁瑣和巨大，所以才決定看一看Python。我很喜歡Python的優雅與快捷。
語言類型
和C不一樣，Python是一種動態類型語言，又是強類型語言。這個分類怎麼理解呢？大概是可以按照下列說明來分類的：
靜態類型語言
一種在編譯期間就確定數據類型的語言。大多數靜態類型語言是通過要求在使用任一變數之前聲明其數據類型來保證這一點的。Java和 C 是靜態類型語言。
動態類型語言
一種在運行期間才去確定數據類型的語言，與靜態類型相反。Python 是動態類型的，因為它們確定一個變數的類型是在您第一次給它賦值的時候。
強類型語言
一種總是強制類型定義的語言。Java 和 Python 是強制類型定義的。您有一個整數，如果不明確地進行轉換 ，不能將把它當成一個字元串。
弱類型語言
一種類型可以被忽略的語言，與強類型相反。VBScript 是弱類型的。在 VBScript 中，您可以將字元串 『12′ 和整數 3 進行連接得到字元串』123′，然後可以把它看成整數 123 ，所有這些都不需要任何的顯示轉換。
對象機制
具體怎麼來理解這個「動態確定變數類型」，就要從Python的Object對象機制說起了。Objects（以下稱對象）是Python對於數據
的抽象，Python中所有的數據，都是由對象或者對象之間的關系表示的，函數是對象，字元串是對象，每個東西都是對象的概念。每一個對象都有三種屬性：
實體，類型和值。理解實體是理解對象中很重要的一步，實體一旦被創建，那麼就一直不會改變，也不會被顯式摧毀，同時通常意義來講，決定對象所支持的操作方
式的類型（type，包括number，string，tuple及其他）也不會改變，改變的只可能是它的值。如果要找一個具體點的說明，實體就相當於對
象在內存中的地址，是本質存在。而類型和值都只是實體的外在呈現。然後Python提供一些介面讓使用者和對象交互，比如id(）函數用來獲得對象實體的
整形表示（實際在這里就是地址），type()函數獲取其類型。
這個object機制，就是c所不具備的，主要體現在下面幾點：
1 剛才說了，c是一個靜態類型語言，我們可以定義int a, char
b等等，但必須是在源代碼裡面事先規定。比如我們可以在Python裡面任意一處直接規定a =
「lk」，這樣，a的類型就是string，這是在其賦值的時候才決定的，我們無須在代碼中明確寫出。而在C裡面，我們必須顯式規定char *a =
「lk」，也就是人工事先規定好a的類型
2 由於在C中，沒有對象這個概念，只有「數據的表示」，比如說，如果有兩個int變數a和b，我們想比較大小，可以用a ＝＝
b來判斷，但是如果是兩個字元串變數a和b，我們就不得不用strcmp來比較了，因為此時，a和b本質上是指向字元串的指針，如果直接還是用＝＝比較，
那比較的實際是指針中存儲的值——地址。
在Java中呢，我們通過使用 str1 == str2 可以確定兩個字元串變數是否指向同一塊物理內存位置，這叫做「對象同一性」。在 Java 中要比較兩個字元串值，你要使用 str1.equals(str2)。
然後在Python中，和前兩者都不一樣，由於對象的引入，我們可以用「is」這個運算符來比較兩個對象的實體，和具體對象的type就沒有關系
了，比如你的對象是tuple也好，string也好，甚至class也好，都可以用」is」來比較，本質上就是「對象同一性」的比較，和Java中
的＝＝類似，和 C中的pointer比較類似。Python中也有＝＝比較，這個就是值比較了。
3
由於對象機制的引入，讓Python的使用非常靈活，比如我們可以用自省方法來查看內存中以對象形式存在的其它模塊和函數，獲取它們的信息，並對它們進行
操作。用這種方法，你可以定義沒有名稱的函數，不按函數聲明的參數順序調用函數，甚至引用事先並不知道名稱的函數。 這些操作在C中都是不可想像的。
4 還有一個很有意思的細節，就是類型對對象行為的影響是各方面的，比如說，a = 1; b =
1這個語句中，在Python裡面引發的，可能是a，b同時指向一個值為1的對象，也可能是分別指向兩個值為1的對象。而例如這個語句，c = []; d
= []，那麼c和d是肯定指向不同的，新創建的空list的。沒完，如果是」c = d =
[]「這個語句呢？此時，c和d又指向了相同的list對象了。這些區別，都是在c中沒有的。
最後，我們來說說為什麼python慢。主要原因就是function call
overhead比較大。因為所有東西現在都是對象了，contruct 和destroy 花費也大。連1 + 1 都是 function
call，像』12′+』45′ 這樣的要 create a third string object, then calls the string
obj』s __add。可想而知，速度如何能快起來？
列表和數組
分析Python中的list和C中的數組總是很有趣的。相信可能一些朋友和一樣，初學列表的時候，都是把它當作是數組來學的。最初對於list和數組區別的定性，主要是集中在兩點。首先，list可以包含很多不同的數據類型，比如
["this", 1, "is", "an", "array"]
這個List，如果放在C中，其實是一個字元串數組，相當於二維的了。
其次呢，list有很多方法，其本身就是一個對象，這個和C的單純數組是不同的。對於List的操作很多樣，因為有方法也有重載的運算符。也帶來一些問題，比如下面這個例子：
加入我們要產生一個多維列表，用下面這個語句
A = [[None] * 2] * 3
結果，A的值會是
[[None, None], [None, None], [None, None]]
初一看沒問題，典型的二維數組形式的列表。好，現在我們想修改第一個None的值，用語句
A[0][0] = 5
現在我們再來看看A的值：
[[5, None], [5, None], [5, None]]
發現問題沒有？這是因為用 * 來復制時，只是創建了對這個對象的引用，而不是真正的創建了它。 *3 創建了一個包含三個引用的列表，這三個引用都指向同一個長度為2的列表。其中一個行的改變會顯示在所有行中，這當然不是你想要的。解決方法當然有，我們這樣來創建
A = [None]*3
for i in range(3):
A[i] = [None] * 2
這樣創建了一個包含三個不同的長度為2的列表。
所以，還是一直強調的，越復雜的東西，越靈活，也越容易出錯。
代碼優化
C是一個很簡單的語言，當我們考慮優化的時候，通常想得也很簡單，比如系統級調用越少越好（緩沖區機制），消除循環的低效率和不必要的系統引用，等
等，其實主要都是基於系統和硬體細節考慮的。而Python就完全不一樣了，當然上面說的這些優化形式，對於Python仍然是實用的，但由於
Python的語法形式千差萬別，庫和模塊多種多樣，所以對於語言本身而言，就有很多值得注意的優化要點，舉幾個例子吧。
比如我們有一個list L1，想要構建一個新的list L2，L2包括L1的頭4個元素。按照最直接的想法，代碼應該是
L2 = []
for i in range[3]:
L2.append(L1[i])
而更加優化和優美的版本是
L2 = L1[:3]
再比如，如果s1..s7是大字元串(10K+)，那麼join([s1,s2,s3,s4,s5,s6,s7])就會比
s1+s2+s3+s4+s5+s6+s7快得多,因為後者會計算很多次子表達式，而join()則在一次過程中完成所有的復制。還有，對於字元串操作，
對字元串對象使用replace()方法。僅當在沒有固定字元串模式時才使用正則表達式。
所以說，以優化為評判標准，如果說C是短小精悍，Python就是博大精深。
include和import
在C語言中的include非常簡單，因為形式單一，意義明確，當你需要用到外部函數等資源時，就用include。而Python中有一個相似的
機制，就是import。乍一看，這兩個傢伙挺像的，不都是我們要用外部資源（最常見的就是函數或者模塊（Python））時就用這個來指明么？其實不
然，兩者的處理機制本質區別在於，C中的include是用於告訴預處理器，這個include指定的文件的內容，你都給我當作在本地源文件中出現過。而
import呢，不是簡單的將後面的內容*直接*插入到本地裡面去，這玩意更加靈活。事實上，幾乎所有類似的機制，Python都比C靈活。這里不是說C
不好，C很簡練，我其實更喜歡C。
簡單說說這個靈活性。import在python中有三種形式，import X, from X import *( or a,b,c……),
X = __import__(』x')。最常用的是第二種，因為比較方便，不像第一種那樣老是用X.mole來調用模塊。from X
import *只是import那些public的mole(一般都是不以__命名的模塊)，也可以指定a,b,c來import。
什麼時候用哪一種形式呢？應該說，在大多數的模塊文檔里，都會明確告訴你應該用哪種形式。如果需要用到很多對象，那麼from X import
*可能更合適一些，但是，就目前來看，大多數第三方Python庫都不推薦使用from molename import *
這種格式。這樣做會使引入者的namespace混亂。很多人甚至對於那些專門設計用於這種模式的模塊（包括Tkinter,
threading和matplot）都不採用這種方式。而如果你僅僅需要某個對象類a，那麼用from X import a比用import
X.a更好，因為以後你調用a的函數直接用a.function()既可以了，不用加X。
如果你連自己希望import的模塊都不知道怎麼辦？請注意，此時Python的優勢就體現出來了，我們可以用
__import__(mole)來調用mole，其中這個mole是字元串，這樣，可以在運行時再決定，你到底要調用什麼mole。舉
個例子：
def classFromMole (mole, Name):
mod = __import__ (mole)
return getattr (mod, Name)
這里，定義了一個函數classFromMole，你可以在代碼的任何時候調用它，
o = classFromMole (MoleOfTheClass, NameOfTheAttribute)()
只需要傳入字元串形式的你希望import的模塊MoleOfTheClass和其中屬性的名字NameOfTheAttribute（當然可以是數據也可以是方法），就能調用了，這個名字字元串不用事先指定，而是根據當時運行的情況來判斷。
順帶說一句，Python中import的順序也有默認規定，這個和C中的include有點類似，因為我們一般都是先include系統文件，再
include自己的頭文件（而且還有<>和「」的區別）。Python中呢，一般應該按照以下順序import模塊：
1. 標准庫模塊 — 如 sys, os, getopt 等
2. 第三方模塊
3. 本地實現的模塊。
全局變數
這里談全局變數呢，倒不是說Python和c的全局變數概念不同，他們的概念是相同的。只是在使用機制上，是有一些差異的。舉個例子：
– mole.py –
globalvar = 1
def func():
print globalvar
# This makes someglobal readonly,
# any attempt to write to someglobal
# would create a new local variable.
def func2():
global globalvar
globalvar = 2
# this allows you to manipulate the global
# variable
在 func這個函數中，globalvar是只讀的。如果你使用了globalvar =
xxx這種賦值語句，Python會重新創造一個新的本地對象並將新值賦給它，原來的對象值不變。而在func2函數中，由於我們事先申明了
globalvar是global的，那麼此時的更改就直接在全局變數上生效。
㈤ python能做的事情用C語言都能做到，那麼C語言能完成的事情用python是否也都能完成
C語言完成的很多事情python是做不到的。
越萬能的語言一般越低級，因此使用越麻煩，越高級的語言越與應用靠近，但是通用性越差。
你說的那個萬能語言就是匯編語言，可以解決任何問題。
㈥ Python C API使用時需要注意什麼
一：用C API為Python寫C語言函數，以方便Python中調用
1. 首先實現一個特定原型的函數，用Python C API來實現的話，所有函數必須是這種原型。必須是類似這樣的
PyObject *Fun(PyObject *self, PyObject *args)
self應該是在用類的時候才會用到（我沒有用到），args就是函數的參數。因為args是一個PyObject*類型（可以代表Python語言中的任何類型）
2. 將參數轉換成C 語言表示的內容，用PyArg_ParseTuple函數。
3. 執行完需要的操作後，也必須返回一個PyObject*類型的值。通過Py_BuildValue函數來構建。
這里要說的是，假如希望返回一個Tuple類型的值，可以先用
PyObject *tuple = Py_BuildValue("(iis)", 1, 2, "three");
形式來構建，假如很多的話，可以用下面的方式來構建
PyObject *t;
t = PyTuple_New(3);
PyTuple_SetItem(t, 0, PyLong_FromLong(1L));
PyTuple_SetItem(t, 1, PyLong_FromLong(2L));
PyTuple_SetItem(t, 2, PyString_FromString("three"));
這一點在剛開始開工的時候迷惑了很久。
4. 將要輸出的所有函數放入一個數組中，數組的結構是：
struct PyMethodDef {
const char *ml_name; /* The name of the built-in function/method */
PyCFunction ml_meth; /* The C function that implements it */
int ml_flags; /* Combination of METH_xxx flags, which mostly
describe the args expected by the C func */
const char *ml_doc; /* The __doc__ attribute, or NULL */
};
數組以{NULL, NULL}結束
5. 構造一個Python import時初始化的函數
類似
PyMODINIT_FUNC
initexample(void)
{
Py_InitMole("example", example_methods);
}
這里有個特別需要注意的是，初始化函數名字有嚴格要求，init後面必須跟模塊名，否則Python找不到確定的函數會報沒有初始化函數的錯誤
擴展模塊寫完後，編譯成動態庫（Python要求此動態庫名字為pyd,實際就是改個後綴而已）。就可以直接在Python腳本中用import的方式載入了，對於使用來說，根本不需要知道此庫是用C API擴展寫的還是直接用Python語句寫的（這點Lua做的也是一樣好）
最後，python的源代碼中附帶了一個叫做example_nt的例子，可以參考一樣，完整的擴展代碼如下：
#include "Python.h"
static PyObject *
ex_foo(PyObject *self, PyObject *args)
{
printf("Hello, world/n");
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef example_methods[] = {
{"foo", ex_foo, METH_VARARGS, "foo() doc string"},
{NULL, NULL}
};
PyMODINIT_FUNC
initexample(void)
{
Py_InitMole("example", example_methods);
}
二．C語言中調用Python語句
首先，void Py_Initialize()用來初始化，void Py_Finalize()用來結束Python的調用，這是必須要的。
燃火分兩種情況，假如僅僅是幾條語句的話，那麼以PyRun_為前綴的一些函數都很好用，比如
int PyRun_SimpleString(const char *command)
函數就可以直接執行一條char*的Python語句。
需要獲得返回值得話
PyObject* PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
也很好用，以上兩個函數用來處理Python源代碼已經讀入內存的情況，在文件中的時候
int PyRun_SimpleFile(FILE *fp, const char *filename)
PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
使用類似。不多講了。
假如是個模塊的話（比如一個函數），希望在C語言中調用的話那麼使用起來就稍微復雜了一點。這種情況的需要在於你可以從C語言中向Python函數中傳入參數並且執行，然後獲取結果。
此處又分為幾種情況：
在文件中，在內存中，編譯過的，源代碼。
在文件中都很好解決，和上面一樣。這里主要講在內存中的情況。（事實上我工作中需要並且耗費了很長時間才找到解決方法的就是這種情況）
未編譯時：（也就是源代碼）
1.通過
PyObject* Py_CompileString(const char *str, const char *filename, int start)
API首先編譯一次。此API的參數我說明一下，str就是內存中的源代碼，filename主要是出錯時報錯誤用的，事實測試證明，你隨意給個字元串也沒有關系，但給NULL參數在運行時必然報錯。start我一般用的是Py_file_input，因為的確是從文件中讀取過來的，相對的還有Py_single_input用來表示一條語句，Py_eval_input的用法我也不是太清楚。
源代碼通過此函數調用後，獲得編譯後的PyObject*,（其實假如跟進源代碼中去看，是一個PyCodeObject結構）假設命名為lpCode。
2.此時再調用API
PyObject* PyImport_ExecCodeMole(char *name, PyObject *co)
導入模塊。參數也說明一下，name為導入的模塊名，co就是前面編譯過的代碼對象（lpCode）。返回的就是模塊對象了，假設命名為lpMod。
3.再調用API
PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
獲得函數對象。o就是模塊對象（lpMod）,attr_name就是你想要調用的函數名了，假設叫main的函數，就是」main」，然後返回的就是函數對象，假設命名為lpFun。
4.此時可以用API
int PyCallable_Check(PyObject *o)
去檢查一下是不是獲得了一個函數。假如確定的話，就可以直接用
PyObject_Call開頭的一族函數調用lpFun了。這些函數包括很多，一般就是輸入參數的不同，但是效果都是一樣的，就是調用函數而已。參數一般可以通過前面說過的build函數來獲得，返回值也是獲得一個PyObject*,可以通過PyArg_那個函數來獲取，但是好像不太好，那是分析參數用的。推薦用確定類型（假設為type）的類似Py[type]_As的函數來獲取。
比如：
long PyLong_AsLong(PyObject *pylong)獲取long
double PyLong_AsDouble(PyObject *pylong)獲取double
這里想說的是，應該有直接從源代碼中獲取函數調用對象的方式，但是我本人沒有試出來，有人知道請一定賜教！
編譯過的代碼：
對於編譯過的代碼和上面就是獲得編譯後的PyCodeObject對象,當然在源代碼中表示還是PyObject*的方法不同（上例中的lpCode）。
當然要想以後獲得一個編譯後的lpCode,自然要先編譯一下啦。但是純粹編譯成pyc結尾的文件後，直接讀入內存，我沒有找到將其轉化為PyCodeObject對象的方法（也希望有人知道能告訴我！）
我找到的方法是先用
PyObject* PyMarshal_WriteObjectToString(PyObject *value, int version)
void PyMarshal_WriteLongToFile(long value, FILE *file, int version)
兩個函數先把PyCodeObject對象(lpCode)序列化到文件或者內存中。
再在需要的時候用函數
PyObject* PyMarshal_ReadObjectFromFile(FILE *file)
PyObject* PyMarshal_ReadObjectFromString(char *string, Py_ssize_t len)
讀出來，讀出來的PyObject*其實就是想要的PyCodeObject對象了(lpCode)。接下來的步驟與未編譯時的步驟一樣。
光是這個扭曲的方法我還是參考老總給的半邊資料反復研究出來的。而真正直接有效的方法我還是沒有找到。
㈦ 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 Ctypes 重寫C介面的問題
>>>fromctypesimport*
>>>ppvoid=POINTER(c_void_p)
>>>ppvoid
<class'__main__.LP_c_void_p'>
㈨ 為什麼python可以調用C或者C++寫的模塊
Python的API（應用程序編程介面）定義了一系列的函數、宏指令和變數 來與Python的運行系統的大部分方面進行連接通信，而通常來說，用C語言編寫的Python API 會在程序文檔里添加「python.h」作為頭文件。
按我的理解來說就像Python把一個值交給運行系統，然後運行系統把這個值轉化成C語言能夠識別的值，然後交到C語言模塊去做運算，運算好了把結果值交給Python的運行系統，處理成Python能夠識別的值。
你不妨看看這幾個網頁：
http://hi..com/softguarder/blog/item/c3dc8b02b44cec80d43f7c57.html
http://docs.python.org/extending/extending.html#a-simple-example
http://hi..com/softguarder/blog/item/c3dc8b02b44cec80d43f7c57.html