新聞中心

這里有您想知道的互聯網營銷解決方案

創(chuàng)新互聯Python教程：ctypes —- Python 的外部函數庫

ctypes —- python 的外部函數庫

ctypes 是 Python 的外部函數庫。它提供了與 C 兼容的數據類型，并允許調用 DLL 或共享庫中的函數?？墒褂迷撃K以純 Python 形式對這些庫進行封裝。

目前創(chuàng)新互聯公司已為1000+的企業(yè)提供了網站建設、域名、網絡空間、網站運營、企業(yè)網站設計、忻州網站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協力一起成長，共同發(fā)展。

ctypes 教程

注：本教程中的示例代碼使用 doctest 來保證它們能正確運行。由于有些代碼示例在 Linux, Windows 或 macOS 上的行為有所不同，它們在注釋中包含了一些 doctest 指令。

注意：部分示例代碼引用了 ctypes c_int 類型。在 sizeof(long) == sizeof(int) 的平臺上此類型是 c_long 的一個別名。所以，在程序輸出 c_long 而不是你期望的 c_int 時不必感到迷惑 —- 它們實際上是同一種類型。

載入動態(tài)連接庫

ctypes 導出了 cdll 對象，在 Windows 系統(tǒng)中還導出了 windll 和 oledll 對象用于載入動態(tài)連接庫。

通過操作這些對象的屬性，你可以載入外部的動態(tài)鏈接庫。cdll 載入按標準的 cdecl 調用協議導出的函數，而 windll 導入的庫按 stdcall 調用協議調用其中的函數。 oledll 也按 stdcall 調用協議調用其中的函數，并假定該函數返回的是 Windows HRESULT 錯誤代碼，并當函數調用失敗時，自動根據該代碼甩出一個 OSError 異常。

在 3.3 版更改: 原來在 Windows 下拋出的異常類型 WindowsError 現在是 OSError 的一個別名。

這是一些 Windows 下的例子。注意：msvcrt 是微軟 C 標準庫，包含了大部分 C 標準函數，這些函數都是以 cdecl 調用協議進行調用的。

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> print(windll.kernel32)  
  
  
    
  
  
  >>> print(cdll.msvcrt)  
  
  
    
  
  
  >>> libc = cdll.msvcrt  
  
  
  >>>

Windows 會自動添加通常的 .dll 文件擴展名。

備注

通過 cdll.msvcrt 調用的標準 C 函數，可能會導致調用一個過時的，與當前 Python 所不兼容的函數。因此，請盡量使用標準的 Python 函數，而不要使用 msvcrt 模塊。

在 Linux 下，必須使用包含文件擴展名的文件名來導入共享庫。因此不能簡單使用對象屬性的方式來導入庫。因此，你可以使用方法 LoadLibrary()，或構造 CDLL 對象來導入庫。

 
 
 
   
  
  
  >>> cdll.LoadLibrary("libc.so.6")  
  
  
    
  
  
  >>> libc = CDLL("libc.so.6")  
  
  
  >>> libc  
  
  
    
  
  
  >>>

操作導入的動態(tài)鏈接庫中的函數

通過操作dll對象的屬性來操作這些函數。

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> libc.printf  
  
  
  <_FuncPtr object at 0x...>  
  
  
  >>> print(windll.kernel32.GetModuleHandleA)  
  
  
  <_FuncPtr object at 0x...>  
  
  
  >>> print(windll.kernel32.MyOwnFunction)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
   File "ctypes.py", line 239, in __getattr__  
  
  
   func = _StdcallFuncPtr(name, self)  
  
  
  AttributeError: function 'MyOwnFunction' not found  
  
  
  >>>

注意：Win32 系統(tǒng)的動態(tài)庫，比如 kernel32 和 user32，通常會同時導出同一個函數的 ANSI 版本和 UNICODE 版本。UNICODE 版本通常會在名字最后以 W 結尾，而 ANSI 版本的則以 A 結尾。 win32的 GetModuleHandle 函數會根據一個模塊名返回一個 模塊句柄，該函數暨同時包含這樣的兩個版本的原型函數，并通過宏 UNICODE 是否定義，來決定宏 GetModuleHandle 導出的是哪個具體函數。

 
 
 
   
  
  
  /* ANSI version */  
  
  
  HMODULE GetModuleHandleA(LPCSTR lpModuleName);  
  
  
  /* UNICODE version */  
  
  
  HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

windll 不會通過這樣的魔法手段來幫你決定選擇哪一種函數，你必須顯式的調用 GetModuleHandleA 或 GetModuleHandleW，并分別使用字節(jié)對象或字符串對象作參數。

有時候，dlls的導出的函數名不符合 Python 的標識符規(guī)范，比如 "??2@YAPAXI@Z"。此時，你必須使用 getattr() 方法來獲得該函數。

 
 
 
   
  
  
  >>> getattr(cdll.msvcrt, "??2@YAPAXI@Z")  
  
  
  <_FuncPtr object at 0x...>  
  
  
  >>>

Windows 下，有些 dll 導出的函數沒有函數名，而是通過其順序號調用。對此類函數，你也可以通過 dll 對象的數值索引來操作這些函數。

 
 
 
   
  
  
  >>> cdll.kernel32[1]  
  
  
  <_FuncPtr object at 0x...>  
  
  
  >>> cdll.kernel32[0]  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
   File "ctypes.py", line 310, in __getitem__  
  
  
   func = _StdcallFuncPtr(name, self)  
  
  
  AttributeError: function ordinal 0 not found  
  
  
  >>>

調用函數

你可以貌似是調用其它 Python 函數那樣直接調用這些函數。在這個例子中，我們調用了 time() 函數，該函數返回一個系統(tǒng)時間戳（從 Unix 時間起點到現在的秒數），而``GetModuleHandleA()`` 函數返回一個 win32 模塊句柄。

此函數中調用的兩個函數都使用了空指針（用 None 作為空指針）:

 
 
 
   
  
  
  >>> print(libc.time(None))  
  
  
  1150640792  
  
  
  >>> print(hex(windll.kernel32.GetModuleHandleA(None)))  
  
  
  0x1d000000  
  
  
  >>>

如果你用 cdecl 調用方式調用 stdcall 約定的函數，則會甩出一個異常 ValueError。反之亦然。

 
 
 
   
  
  
  >>> cdll.kernel32.GetModuleHandleA(None)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  ValueError: Procedure probably called with not enough arguments (4 bytes missing)  
  
  
  >>>  
  
  
    
  
  
  >>> windll.msvcrt.printf(b"spam")  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  ValueError: Procedure probably called with too many arguments (4 bytes in excess)  
  
  
  >>>

你必須閱讀這些庫的頭文件或說明文檔來確定它們的正確的調用協議。

在 Windows 中，ctypes 使用 win32 結構化異常處理來防止由于在調用函數時使用非法參數導致的程序崩潰。

 
 
 
   
  
  
  >>> windll.kernel32.GetModuleHandleA(32)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  OSError: exception: access violation reading 0x00000020  
  
  
  >>>

然而，總有許多辦法，通過調用 ctypes 使得 Python 程序崩潰。因此，你必須小心使用。 faulthandler 模塊可以用于幫助診斷程序崩潰的原因。（比如由于錯誤的C庫函數調用導致的段錯誤）。

None, integers, bytes objects and (unicode) strings are the only native Python objects that can directly be used as parameters in these function calls. None is passed as a C NULL pointer, bytes objects and strings are passed as pointer to the memory block that contains their data (char* or wchar_t*). Python integers are passed as the platforms default C int type, their value is masked to fit into the C type.

在我們開始調用函數前，我們必須先了解作為函數參數的 ctypes 數據類型。

基礎數據類型

ctypes 定義了一些和C兼容的基本數據類型：

c_bool

_Bool

bool (1)

c_char

char

單字符字節(jié)串對象

c_wchar

wchar_t

單字符字符串

c_byte

char

int

c_ubyte

unsigned char

int

c_short

short

int

c_ushort

unsigned short

int

c_int

int

c_uint

unsigned int

int

c_long

long

int

c_ulong

unsigned long

int

c_longlong

int64 or long long

int

c_ulonglong

unsigned int64 or unsigned long long

int

c_size_t

size_t

int

c_ssize_t

ssize_t or Py_ssize_t

int

c_float

float

c_double

double

float

c_longdouble

long double

float

c_char_p

char (NUL terminated)

字節(jié)串對象或 None

c_wchar_p

wchar_t (NUL terminated)

字符串或 None

c_void_p

void*

int 或 None

ctypes 類型	C 類型	Python 類型

構造函數接受任何具有真值的對象。

所有這些類型都可以通過使用正確類型和值的可選初始值調用它們來創(chuàng)建:

 
 
 
   
  
  
  >>> c_int()  
  
  
  c_long(0)  
  
  
  >>> c_wchar_p("Hello, World")  
  
  
  c_wchar_p(140018365411392)  
  
  
  >>> c_ushort(-3)  
  
  
  c_ushort(65533)  
  
  
  >>>

由于這些類型是可變的，它們的值也可以在以后更改:

 
 
 
   
  
  
  >>> i = c_int(42)  
  
  
  >>> print(i)  
  
  
  c_long(42)  
  
  
  >>> print(i.value)  
  
  
  42  
  
  
  >>> i.value = -99  
  
  
  >>> print(i.value)  
  
  
  -99  
  
  
  >>>

當給指針類型的對象 c_char_p, c_wchar_p 和 c_void_p 等賦值時，將改變它們所指向的 內存地址，而不是它們所指向的內存區(qū)域的內容 (這是理所當然的，因為 Python 的 bytes 對象是不可變的):

 
 
 
   
  
  
  >>> s = "Hello, World"  
  
  
  >>> c_s = c_wchar_p(s)  
  
  
  >>> print(c_s)  
  
  
  c_wchar_p(139966785747344)  
  
  
  >>> print(c_s.value)  
  
  
  Hello World  
  
  
  >>> c_s.value = "Hi, there"  
  
  
  >>> print(c_s) # the memory location has changed  
  
  
  c_wchar_p(139966783348904)  
  
  
  >>> print(c_s.value)  
  
  
  Hi, there  
  
  
  >>> print(s) # first object is unchanged  
  
  
  Hello, World  
  
  
  >>>

但你要注意不能將它們傳遞給會改變指針所指內存的函數。如果你需要可改變的內存塊，ctypes 提供了 create_string_buffer() 函數，它提供多種方式創(chuàng)建這種內存塊。當前的內存塊內容可以通過 raw 屬性存取，如果你希望將它作為NUL結束的字符串，請使用 value 屬性:

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> p = create_string_buffer(3) # create a 3 byte buffer, initialized to NUL bytes  
  
  
  >>> print(sizeof(p), repr(p.raw))  
  
  
  3 b'\x00\x00\x00'  
  
  
  >>> p = create_string_buffer(b"Hello") # create a buffer containing a NUL terminated string  
  
  
  >>> print(sizeof(p), repr(p.raw))  
  
  
  6 b'Hello\x00'  
  
  
  >>> print(repr(p.value))  
  
  
  b'Hello'  
  
  
  >>> p = create_string_buffer(b"Hello", 10) # create a 10 byte buffer  
  
  
  >>> print(sizeof(p), repr(p.raw))  
  
  
  10 b'Hello\x00\x00\x00\x00\x00'  
  
  
  >>> p.value = b"Hi"  
  
  
  >>> print(sizeof(p), repr(p.raw))  
  
  
  10 b'Hi\x00lo\x00\x00\x00\x00\x00'  
  
  
  >>>

The create_string_buffer() function replaces the old c_buffer() function (which is still available as an alias). To create a mutable memory block containing unicode characters of the C type wchar_t, use the create_unicode_buffer() function.

調用函數，繼續(xù)

注意 printf 將打印到真正標準輸出設備，而*不是* sys.stdout，因此這些實例只能在控制臺提示符下工作，而不能在 IDLE 或 PythonWin 中運行。

 
 
 
   
  
  
  >>> printf = libc.printf  
  
  
  >>> printf(b"Hello, %s\n", b"World!")  
  
  
  Hello, World!  
  
  
  14  
  
  
  >>> printf(b"Hello, %S\n", "World!")  
  
  
  Hello, World!  
  
  
  14  
  
  
  >>> printf(b"%d bottles of beer\n", 42)  
  
  
  42 bottles of beer  
  
  
  19  
  
  
  >>> printf(b"%f bottles of beer\n", 42.5)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  ArgumentError: argument 2: TypeError: Don't know how to convert parameter 2  
  
  
  >>>

正如前面所提到過的，除了整數、字符串以及字節(jié)串之外，所有的 Python 類型都必須使用它們對應的 ctypes 類型包裝，才能夠被正確地轉換為所需的C語言類型。

 
 
 
   
  
  
  >>> printf(b"An int %d, a double %f\n", 1234, c_double(3.14))  
  
  
  An int 1234, a double 3.140000  
  
  
  31  
  
  
  >>>

使用自定義的數據類型調用函數

你也可以通過自定義 ctypes 參數轉換方式來允許自定義類型作為參數。 ctypes 會尋找 _as_parameter_ 屬性并使用它作為函數參數。當然，它必須是數字、字符串或者二進制字符串:

 
 
 
   
  
  
  >>> class Bottles:  
  
  
  ... def __init__(self, number):  
  
  
  ... self._as_parameter_ = number  
  
  
  ...  
  
  
  >>> bottles = Bottles(42)  
  
  
  >>> printf(b"%d bottles of beer\n", bottles)  
  
  
  42 bottles of beer  
  
  
  19  
  
  
  >>>

如果你不想把實例的數據存儲到 _as_parameter_ 屬性。可以通過定義 property 函數計算出這個屬性。

指定必選參數的類型(函數原型)

可以通過設置 argtypes 屬性的方法指定從 DLL 中導出函數的必選參數類型。

argtypes 必須是一個 C 數據類型的序列 (這里的 printf 可能不是個好例子，因為它是變長參數，而且每個參數的類型依賴于格式化字符串，不過嘗試這個功能也很方便):

 
 
 
   
  
  
  >>> printf.argtypes = [c_char_p, c_char_p, c_int, c_double]  
  
  
  >>> printf(b"String '%s', Int %d, Double %f\n", b"Hi", 10, 2.2)  
  
  
  String 'Hi', Int 10, Double 2.200000  
  
  
  37  
  
  
  >>>

指定數據類型可以防止不合理的參數傳遞（就像 C 函數的原型），并且會自動嘗試將參數轉換為需要的類型:

 
 
 
   
  
  
  >>> printf(b"%d %d %d", 1, 2, 3)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  ArgumentError: argument 2: TypeError: wrong type  
  
  
  >>> printf(b"%s %d %f\n", b"X", 2, 3)  
  
  
  X 2 3.000000  
  
  
  13  
  
  
  >>>

如果你想通過自定義類型傳遞參數給函數，必須實現 from_param() 類方法，才能夠將此自定義類型用于 argtypes 序列。from_param() 類方法接受一個 Python 對象作為函數輸入，它應該進行類型檢查或者其他必要的操作以保證接收到的對象是合法的，然后返回這個對象，或者它的 _as_parameter_ 屬性，或者其他你想要傳遞給 C 函數的參數。這里也一樣，返回的結果必須是整型、字符串、二進制字符串、 ctypes 類型，或者一個具有 _as_parameter_ 屬性的對象。

返回類型

By default functions are assumed to return the C int type. Other return types can be specified by setting the restype attribute of the function object.

這是個更高級的例子，它調用了 strchr 函數，這個函數接收一個字符串指針以及一個字符作為參數，返回另一個字符串指針。

 
 
 
   
  
  
  >>> strchr = libc.strchr  
  
  
  >>> strchr(b"abcdef", ord("d"))  
  
  
  8059983  
  
  
  >>> strchr.restype = c_char_p # c_char_p is a pointer to a string  
  
  
  >>> strchr(b"abcdef", ord("d"))  
  
  
  b'def'  
  
  
  >>> print(strchr(b"abcdef", ord("x")))  
  
  
  None  
  
  
  >>>

如果希望避免上述的 ord("x") 調用，可以設置 argtypes 屬性，第二個參數就會將單字符的 Python 二進制字符對象轉換為 C 字符:

 
 
 
   
  
  
  >>> strchr.restype = c_char_p  
  
  
  >>> strchr.argtypes = [c_char_p, c_char]  
  
  
  >>> strchr(b"abcdef", b"d")  
  
  
  'def'  
  
  
  >>> strchr(b"abcdef", b"def")  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  ArgumentError: argument 2: TypeError: one character string expected  
  
  
  >>> print(strchr(b"abcdef", b"x"))  
  
  
  None  
  
  
  >>> strchr(b"abcdef", b"d")  
  
  
  'def'  
  
  
  >>>

如果外部函數返回了一個整數，你也可以使用要給可調用的 Python 對象（比如函數或者類）作為 restype 屬性的值。將會以 C 函數返回的整數對象作為參數調用這個可調用對象，執(zhí)行后的結果作為最終函數返回值。這在錯誤返回值校驗和自動拋出異常等方面比較有用。

 
 
 
   
  
  
  >>> GetModuleHandle = windll.kernel32.GetModuleHandleA  
  
  
  >>> def ValidHandle(value):  
  
  
  ... if value == 0:  
  
  
  ... raise WinError()  
  
  
  ... return value  
  
  
  ...  
  
  
  >>>  
  
  
  >>> GetModuleHandle.restype = ValidHandle  
  
  
  >>> GetModuleHandle(None)  
  
  
  486539264  
  
  
  >>> GetModuleHandle("something silly")  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
   File "", line 3, in ValidHandle  
  
  
  OSError: [Errno 126] The specified module could not be found.  
  
  
  >>>

WinError 函數可以調用 Windows 的 FormatMessage() API 獲取錯誤碼的字符串說明，然后返回一個異常。 WinError 接收一個可選的錯誤碼作為參數，如果沒有的話，它將調用 GetLastError() 獲取錯誤碼。

請注意，使用 errcheck 屬性可以實現更強大的錯誤檢查手段；詳情請見參考手冊。

傳遞指針（或以引用方式傳遞形參）

有時候 C 函數接口可能由于要往某個地址寫入值，或者數據太大不適合作為值傳遞，從而希望接收一個指針作為數據參數類型。這和 傳遞參數引用 類似。

ctypes 暴露了 byref() 函數用于通過引用傳遞參數，使用 pointer() 函數也能達到同樣的效果，只不過 pointer() 需要更多步驟，因為它要先構造一個真實指針對象。所以在 Python 代碼本身不需要使用這個指針對象的情況下，使用 byref() 效率更高。

 
 
 
   
  
  
  >>> i = c_int()  
  
  
  >>> f = c_float()  
  
  
  >>> s = create_string_buffer(b'\000' * 32)  
  
  
  >>> print(i.value, f.value, repr(s.value))  
  
  
  0 0.0 b''  
  
  
  >>> libc.sscanf(b"1 3.14 Hello", b"%d %f %s",  
  
  
  ... byref(i), byref(f), s)  
  
  
  3  
  
  
  >>> print(i.value, f.value, repr(s.value))  
  
  
  1 3.1400001049 b'Hello'  
  
  
  >>>

結構體和聯合

結構體和聯合必須繼承自 ctypes 模塊中的 Structure 和 Union 。子類必須定義 _fields_ 屬性。 _fields_ 是一個二元組列表，二元組中包含 field name 和 field type 。

type 字段必須是一個 ctypes 類型，比如 c_int，或者其他 ctypes 類型: 結構體、聯合、數組、指針。

這是一個簡單的 POINT 結構體，它包含名稱為 x 和 y 的兩個變量，還展示了如何通過構造函數初始化結構體。

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> class POINT(Structure):  
  
  
  ... _fields_ = [("x", c_int),  
  
  
  ... ("y", c_int)]  
  
  
  ...  
  
  
  >>> point = POINT(10, 20)  
  
  
  >>> print(point.x, point.y)  
  
  
  10 20  
  
  
  >>> point = POINT(y=5)  
  
  
  >>> print(point.x, point.y)  
  
  
  0 5  
  
  
  >>> POINT(1, 2, 3)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  TypeError: too many initializers  
  
  
  >>>

當然，你可以構造更復雜的結構體。一個結構體可以通過設置 type 字段包含其他結構體或者自身。

這是以一個 RECT 結構體，他包含了兩個 POINT ，分別叫 upperleft 和 lowerright:

 
 
 
   
  
  
  >>> class RECT(Structure):  
  
  
  ... _fields_ = [("upperleft", POINT),  
  
  
  ... ("lowerright", POINT)]  
  
  
  ...  
  
  
  >>> rc = RECT(point)  
  
  
  >>> print(rc.upperleft.x, rc.upperleft.y)  
  
  
  0 5  
  
  
  >>> print(rc.lowerright.x, rc.lowerright.y)  
  
  
  0 0  
  
  
  >>>

嵌套結構體可以通過幾種方式構造初始化:

 
 
 
   
  
  
  >>> r = RECT(POINT(1, 2), POINT(3, 4))  
  
  
  >>> r = RECT((1, 2), (3, 4))

可以通過類獲取字段 descriptor ，它能提供很多有用的調試信息。

 
 
 
   
  
  
  >>> print(POINT.x)  
  
  
    
  
  
  >>> print(POINT.y)  
  
  
    
  
  
  >>>

警告

ctypes 不支持帶位域的結構體、聯合以值的方式傳給函數。這可能在 32 位 x86 平臺上可以正常工作，但是對于一般情況，這種行為是未定義的。帶位域的結構體、聯合應該總是通過指針傳遞給函數。

結構體/聯合字段對齊及字節(jié)順序

默認情況下，結構體和聯合的字段與 C 的字節(jié)對齊是一樣的。也可以在定義子類的時候指定類的 _pack_ 屬性來覆蓋這種行為。它必須設置為一個正整數，表示字段的最大對齊字節(jié)。這和 MSVC 中的 #pragma pack(n) 功能一樣。

ctypes 中的結構體和聯合使用的是本地字節(jié)序。要使用非本地字節(jié)序，可以使用 BigEndianStructure, LittleEndianStructure, BigEndianUnion, and LittleEndianUnion 作為基類。這些類不能包含指針字段。

結構體和聯合中的位域

結構體和聯合中是可以包含位域字段的。位域只能用于整型字段，位長度通過 _fields_ 中的第三個參數指定:

 
 
 
   
  
  
  >>> class Int(Structure):  
  
  
  ... _fields_ = [("first_16", c_int, 16),  
  
  
  ... ("second_16", c_int, 16)]  
  
  
  ...  
  
  
  >>> print(Int.first_16)  
  
  
    
  
  
  >>> print(Int.second_16)  
  
  
    
  
  
  >>>

數組

數組是一個序列，包含指定個數元素，且必須類型相同。

創(chuàng)建數組類型的推薦方式是使用一個類型乘以一個正數:

 
 
 
   
  
  
  TenPointsArrayType = POINT * 10

下面是一個構造的數據案例，結構體中包含了4個 POINT 和一些其他東西。

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> class POINT(Structure):  
  
  
  ... _fields_ = ("x", c_int), ("y", c_int)  
  
  
  ...  
  
  
  >>> class MyStruct(Structure):  
  
  
  ... _fields_ = [("a", c_int),  
  
  
  ... ("b", c_float),  
  
  
  ... ("point_array", POINT * 4)]  
  
  
  >>>  
  
  
  >>> print(len(MyStruct().point_array))  
  
  
  4  
  
  
  >>>

和平常一樣，通過調用它創(chuàng)建實例:

 
 
 
   
  
  
  arr = TenPointsArrayType()  
  
  
  for pt in arr:  
  
  
   print(pt.x, pt.y)

以上代碼會打印幾行 0 0 ，因為數組內容被初始化為 0.

也能通過指定正確類型的數據來初始化:

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> TenIntegers = c_int * 10  
  
  
  >>> ii = TenIntegers(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
  
  
  >>> print(ii)  
  
  
    
  
  
  >>> for i in ii: print(i, end=" ")  
  
  
  ...  
  
  
  1 2 3 4 5 6 7 8 9 10  
  
  
  >>>

指針

可以將 ctypes 類型數據傳入 pointer() 函數創(chuàng)建指針:

 
 
 
   
  
  
  >>> from ctypes import *  
  
  
  >>> i = c_int(42)  
  
  
  >>> pi = pointer(i)  
  
  
  >>>

指針實例擁有 contents 屬性，它返回指針指向的真實對象，如上面的 i 對象:

 
 
 
   
  
  
  >>> pi.contents  
  
  
  c_long(42)  
  
  
  >>>

注意 ctypes 并沒有 OOR （返回原始對象）, 每次訪問這個屬性時都會構造返回一個新的相同對象:

 
 
 
   
  
  
  >>> pi.contents is i  
  
  
  False  
  
  
  >>> pi.contents is pi.contents  
  
  
  False  
  
  
  >>>

將這個指針的 contents 屬性賦值為另一個 c_int 實例將會導致該指針指向該實例的內存地址:

 
 
 
   
  
  
  >>> i = c_int(99)  
  
  
  >>> pi.contents = i  
  
  
  >>> pi.contents  
  
  
  c_long(99)  
  
  
  >>>

指針對象也可以通過整數下標進行訪問:

通過整數下標賦值可以改變指針所指向的真實內容:

 
 
 
   
  
  
  >>> print(i)  
  
  
  c_long(99)  
  
  
  >>> pi[0] = 22  
  
  
  >>> print(i)  
  
  
  c_long(22)  
  
  
  >>>

使用 0 以外的索引也是合法的，但是你必須確保知道自己為什么這么做，就像 C 語言中: 你可以訪問或者修改任意內存內容。通常只會在函數接收指針是才會使用這種特性，而且你知道這個指針指向的是一個數組而不是單個值。

內部細節(jié), pointer() 函數不只是創(chuàng)建了一個指針實例，它首先創(chuàng)建了一個指針類型。這是通過調用 POINTER() 函數實現的，它接收 ctypes 類型為參數，返回一個新的類型:

 
 
 
   
  
  
  >>> PI = POINTER(c_int)  
  
  
  >>> PI  
  
  
    
  
  
  >>> PI(42)  
  
  
  Traceback (most recent call last):  
  
  
   File "", line 1, in   
  
  
  TypeError: expected c_long instead of int  
  
  
  >>> PI(c_int(42))  
  
  
    
  
  
  >>>

無參調用指針類型可以創(chuàng)建一個 NULL 指針。 NULL 指針的布爾值是 False

 
 
 
   
  
  
  >>> null_ptr = POINTER(c_int)()  
  
  
  >>> print(bool(null_ptr))  
  
  
  False  
  
  
  >>>

解引用指針的時候， ctypes 會幫你檢測是否指針為 NULL (但是解引用無效的非 NULL 指針仍會導致 Python 崩潰):

 
 
 
   
  
  
  >>> null_ptr[0]  
  
  
  Traceback (most recent call last):  
  
  
   ....  
  
  
  ValueError: NULL pointer access  
  
  
  >>>  
  
  
    
  
  
  >>> null_ptr[0] = 1234  
  
  
  Traceback (most recent call last):  
  
  
   ....  
  
  
  ValueError: NULL pointer access  
  
  
  >>>

類型轉換

通常情況下, ctypes 具有嚴格的類型檢查。這代表著, 如果在函數 argtypes 本文名稱：創(chuàng)新互聯Python教程：ctypes —- Python 的外部函數庫標題路徑：http://www.5511xx.com/article/dpccije.html


                                            
                                                
                                                    其他資訊
                                                
                                                
                                                    
                                                        
                                                                詳解使用fastboot為Android刷入原廠鏡像
                                                            

                                                                怎么設置微信主頁皮膚，微信主頁怎么設置皮膚
                                                            

                                                                如何手動刪除SQLServer2000默認實例，命名實例或虛擬實例？（數據庫誤刪-虛擬主機/數據庫問題）
                                                            

                                                                怎么在iis上發(fā)布網站？(iis如何添加網站鏈接)
                                                            

                                                                Ai智能語音機器人（OPPO手機打電話如何設置機器人）

新聞中心

ctypes —- python 的外部函數庫

ctypes 教程

載入動態(tài)連接庫

操作導入的動態(tài)鏈接庫中的函數

調用函數

基礎數據類型

調用函數，繼續(xù)

使用自定義的數據類型調用函數

指定必選參數的類型(函數原型)

返回類型

傳遞指針（或以引用方式傳遞形參）

結構體和聯合

結構體/聯合字段對齊及字節(jié)順序

結構體和聯合中的位域

數組

指針

類型轉換

其他資訊

調用函數，繼續(xù)