>>> from ctypes import *
>>> print(windll.kernel32)
<WinDLL 'kernel32', handle ... at ...>
>>> print(cdll.msvcrt)
<CDLL 'msvcrt', handle ... at ...>
>>> libc = cdll.msvcrt
Windows 会自动添加通常的 .dll 文件扩展名。
通过 cdll.msvcrt 调用的标准 C 函数，可能会导致调用一个过时的，与当前 Python 所不兼容的函数。因此，请尽量使用标准的 Python 函数，而不要使用 msvcrt 模块。
在 Linux 中，要求指定文件名 包括 扩展名来加载库，因此不能使用属性访问的方式来加载库。 你应当使用 dll 加载器的 LoadLibrary() 方法，或是应当通过调用构造器创建 CDLL 的实例来加载库:
>>> cdll.LoadLibrary("libc.so.6")
<CDLL 'libc.so.6', handle ... at ...>
>>> libc = CDLL("libc.so.6")
<CDLL 'libc.so.6', handle ... at ...>
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.GetModuleHandleA)
<_FuncPtr object at 0x...>
>>> print(windll.kernel32.MyOwnFunction)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "ctypes.py", line 239, in __getattr__
func = _StdcallFuncPtr(name, self)
AttributeError: function 'MyOwnFunction' not found
请注意 win32 系统的动态库如 kernel32 和 user32 通常会同时导出一个函数的 ANSI 版本和 UNICODE 版本。 UNICODE 版本导出时会在名称后加上 W，而 ANSI 版本导出时会在名称后加上 A。 win32 GetModuleHandle 函数会为给定的模块名称返回一个 模块句柄，它具有以下的 C 原型，以及一个被用来根据是否定义了 UNICODE 将其中之一暴露为 GetModuleHandle 的宏:
/* ANSI version */
HMODULE GetModuleHandleA(LPCSTR lpModuleName);
/* UNICODE version */
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);
windll 不会通过这样的魔法手段来帮你决定选择哪一种函数，你必须显式的调用 GetModuleHandleA 或 GetModuleHandleW，并分别使用字节对象或字符串对象作参数。
有时候，dlls的导出的函数名不符合 Python 的标识符规范，比如 "??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 "<stdin>", line 1, in <module>
File "ctypes.py", line 310, in __getitem__
func = _StdcallFuncPtr(name, self)
AttributeError: function ordinal 0 not found
调用函数
你可以像任何其它 Python 可调用对象一样调用这些函数。 这个例子使用了 rand() 函数，它不接收任何参数并返回一个伪随机整数:
>>> print(libc.rand())
1804289383
在 Windows 上，你可以调用 GetModuleHandleA() 函数，它返回一个 win32 模块句柄 (将 None 作为唯一参数传入以使用 NULL 指针来调用它):
>>> print(hex(windll.kernel32.GetModuleHandleA(None)))
0x1d000000
如果你用 cdecl 调用方式调用 stdcall 约定的函数，则会甩出一个异常 ValueError。反之亦然。
>>> cdll.kernel32.GetModuleHandleA(None)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Procedure probably called with not enough arguments (4 bytes missing)
>>> windll.msvcrt.printf(b"spam")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
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 "<stdin>", line 1, in <module>
OSError: exception: access violation reading 0x00000020
然而，总有许多办法，通过调用 ctypes 使得 Python 程序崩溃。因此，你必须小心使用。 faulthandler 模块可以用于帮助诊断程序崩溃的原因。（比如由于错误的C库函数调用导致的段错误）。
None、整数、字节串对象和（Unicode）字符串是仅有的可以直接作为这些函数调用的形参的原生 Python 对象。 None 将作为 C NULL 指针传入，字节串对象和字符串将作为指向包含其数据 (char* 或 wchar_t*) 的内存块的指针传入。 Python 整数将作为平台默认的 C int 类型传入，它们的值会被截断以适应 C 类型的长度。
在我们开始调用函数前，我们必须先了解作为函数参数的 ctypes 数据类型。
基础数据类型
ctypes 定义了一些和C兼容的基本数据类型：
ctypes 类型
Python 类型
c_bool
_Bool
bool (1)
c_char
单字符字节串对象
c_wchar
wchar_t
单字符字符串
c_byte
c_ubyte
unsigned char
c_short
short
c_ushort
unsigned short
c_int
c_int8
int8_t
c_int16
int16_t
c_int32
int32_t
c_int64
int64_t
c_uint
unsigned int
c_uint8
uint8_t
c_uint16
uint16_t
c_uint32
uint32_t
c_uint64
uint64_t
c_long
c_ulong
unsigned long
c_longlong
__int64 或 long long
c_ulonglong
unsigned __int64 或 unsigned long long
c_size_t
size_t
c_ssize_t
ssize_t 或 Py_ssize_t
c_time_t
time_t
c_float
float
float
c_double
double
float
c_longdouble
long double
float
c_char_p
char* (以 NUL 结尾)
字节串对象或 None
c_wchar_p
wchar_t* (以 NUL 结尾)
字符串或 None
c_void_p
void*
int 或 None
给指针类型的实例Assigning a new value to instances of the pointer types c_char_p, c_wchar_p 和 c_void_p 赋新值会改变它们所指向的 内存位置，而不是内存块的 内容 (当然不是，因为 Python 字符串对象是不可变的):
>>> 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) # 内存分配已改变
c_wchar_p(139966783348904)
>>> print(c_s.value)
Hi, there
>>> print(s) # 第一个对象未改变
Hello, World
但你要注意不能将它们传递给会改变指针所指内存的函数。如果你需要可改变的内存块，ctypes 提供了 create_string_buffer() 函数，它提供多种方式创建这种内存块。当前的内存块内容可以通过 raw 属性存取，如果你希望将它作为NUL结束的字符串，请使用 value 属性:
>>> from ctypes import *
>>> p = create_string_buffer(3) # 创建一个 3 字节的缓冲区，初始化为 NUL 字节
>>> print(sizeof(p), repr(p.raw))
3 b'\x00\x00\x00'
>>> p = create_string_buffer(b"Hello") # 创建一个包含以 NUL 结束的字符串的缓冲区
>>> print(sizeof(p), repr(p.raw))
6 b'Hello\x00'
>>> print(repr(p.value))
b'Hello'
>>> p = create_string_buffer(b"Hello", 10) # 创建一个 10 字节的缓冲区
>>> 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'
create_string_buffer() 函数取代了旧了 c_buffer() 函数（后者仍可作为别名使用）。 要创建一个包含 C 类型 wchar_t 的 unicode 字符的可变内存块，请使用 create_unicode_buffer() 函数。
调用函数，继续
注意 printf 将打印到真正标准输出设备，而*不是* sys.stdout，因此这些实例只能在控制台提示符下工作，而不能在 IDLE 或 PythonWin 中运行。
>>> printf = libc.printf
>>> printf(b"Hello, %s\n", b"World!")
Hello, World!
>>> printf(b"Hello, %S\n", "World!")
Hello, World!
>>> printf(b"%d bottles of beer\n", 42)
42 bottles of beer
>>> printf(
b"%f bottles of beer\n", 42.5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ctypes.ArgumentError: argument 2: TypeError: Don't know how to convert parameter 2
正如前面所提到过的，除了整数、字符串以及字节串之外，所有的 Python 类型都必须使用它们对应的 ctypes 类型包装，才能够被正确地转换为所需的C语言类型。
>>> printf(b"An int %d, a double %f\n", 1234, c_double(3.14))
An int 1234, a double 3.140000
调用可变函数
在许多平台上通过 ctypes 调用可变函数与调用带有固定数量形参的函数是完全一样的。 在某些平台，特别是针对 Apple 平台的 ARM64 上，可变函数的调用约定与常规函数则是不同的。
在这些平台上要求为常规、非可变函数参数指定 argtypes 属性：
libc.printf.argtypes = [ctypes.c_char_p]
因为指定该属性不会影响可移植性所以建议总是为所有可变函数指定 argtypes。
使用自定义的数据类型调用函数
您也可以通过自定义 ctypes 参数转换方式来允许将你自己的类实例作为函数参数。 ctypes 会寻找 _as_parameter_ 属性并使用它作为函数参数。 属性必须是整数、字符串、字节串、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
如果你不想将实例数据存储在 _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
指定数据类型可以防止不合理的参数传递（就像 C 函数的原型），并且会自动尝试将参数转换为需要的类型:
>>> printf(b"%d %d %d", 1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ctypes.ArgumentError: argument 2: TypeError: 'int' object cannot be interpreted as ctypes.c_char_p
>>> printf(b"%s %d %f\n", b"X", 2, 3)
X 2 3.000000
如果你定义了自己的类并将其传递给函数调用，则你必须为它们实现 from_param() 类方法才能够在 argtypes 序列中使用它们。 from_param() 类方法接受传递给函数调用的 Python 对象，它应该进行类型检查或者其他必要的操作以确保这个对象是可接受的，然后返回对象本身、它的 _as_parameter_ 属性，或在此情况下作为 C 函数参数传入的任何东西。 同样，结果应该是整数、字符串、字节串、ctypes 实例或是具有 _as_parameter_ 属性的对象。
返回类型
在默认情况下都会假定函数返回 C int 类型。 其他返回类型可通过设置函数对象的 setting the restype 属性来指定。
time() 的 C 原型是 time_t time(time_t *)。 由于 time_t 的类型可能不同于默认返回类型 int，你应当指定 restype 属性:
>>> libc.time.restype = c_time_t
参数类型可以使用 argtypes 来指定:
>>> libc.time.argtypes = (POINTER(c_time_t),)
调用该函数时如果要将 NULL 指针作为第一个参数，请使用 None:
>>> print(libc.time(None))
1150640792
下面是一个更高级的示例，它使用了 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")))
如果你想要避免上面的 ord("x") 调用，你可以设置 argtypes 属性，第二个参数将从单字符 Python 字节串对象转换为 C char：
>>> strchr.restype = c_char_p
>>> strchr.argtypes = [c_char_p, c_char]
>>> strchr(b"abcdef", b"d")
b'def'
>>> strchr(b"abcdef", b"def")
Traceback (most recent call last):
ctypes.ArgumentError: argument 2: TypeError: one character bytes, bytearray or integer expected
>>> print(strchr(b"abcdef", b"x"))
>>> strchr(b"abcdef", b"d")
b'def'
如果外部函数返回一个整数，你也可以使用一个 Python 可调用对象（例如函数或类）作为 restype 属性。 该可调用对象被调用时将附带 C 函数返回的 整数，其调用结果将被用作函数调用的结果值。 这对于检查错误返回值并自动引发异常来说很有用处:
>>> 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 "<stdin>", line 1, in <module>
File "<stdin>", 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)
>>> print(i.value, f.value, repr(s.value))
1 3.1400001049 b'Hello'
结构体和联合
结构体和联合必须派生自 Structure 和 Union 基类，这两个基类是在 ctypes 模块中定义的。 每个子类都必须定义 _fields_ 属性。 _fields_ 必须是一个 2元组 的列表，其中包含一个 字段名称 和一个 字段类型。
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)
>>> POINT(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
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)
>>> print(rc.lowerright.x, rc.lowerright.y)
嵌套结构体可以通过几种方式构造初始化:
>>> r = RECT(POINT(1, 2), POINT(3, 4))
>>> r = RECT((1, 2), (3, 4))
可以通过 类 获取字段 descriptor ，它能提供很多有用的调试信息。
>>> print(POINT.x)
<Field type=c_long, ofs=0, size=4>
>>> print(POINT.y)
<Field type=c_long, ofs=4, size=4>
结构体/联合字段对齐及字节顺序
在默认情况下，Structure 和 Union 字段使用与 C 编译器一样的方式进行对齐。 可以通过在子类定义中指定 _pack_ 类属性来覆盖此行为。 该属性必须被设为一个正整数来指明字段的最大对齐值。 这也是 #pragma pack(n) 在 MSVC 中所做的事情。 还可以使用与. It is also possible to set a minimum alignment for how the subclass itself is packed in the same way #pragma align(n) 在 MSVC 中一样的方式来设置子类本身数据打包的最小对齐值。 这可以通过在子类定义中指定 _align_ 类属性来实现。
ctypes 中的结构体和联合使用的是本地字节序。要使用非本地字节序，可以使用 BigEndianStructure, LittleEndianStructure, BigEndianUnion, and LittleEndianUnion 作为基类。这些类不能包含指针字段。
结构体和联合中的位域
可以创建包含位字段的结构体和联合。 位字段只适用于整数字段，位宽度是由 _fields_ 元组中的第三项来指定的:
>>> class Int(Structure):
... _fields_ = [("first_16", c_int, 16),
... ("second_16", c_int, 16)]
>>> print(Int.first_16)
<Field type=c_long, ofs=0:0, bits=16>
>>> print(Int.second_16)
<Field type=c_long, ofs=0:16, bits=16>
>>> 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))
和平常一样，通过调用它创建实例:
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)
<c_long_Array_10 object at 0x...>
>>> for i in ii: print(i, end=" ")
1 2 3 4 5 6 7 8 9 10
使用 0 以外的索引也是合法的，但是你必须确保知道自己为什么这么做，就像 C 语言中: 你可以访问或者修改任意内存内容。 通常只会在函数接收指针是才会使用这种特性，而且你 知道 这个指针指向的是一个数组而不是单个值。
内部细节, pointer() 函数不只是创建了一个指针实例，它首先创建了一个指针 类型 。这是通过调用 POINTER() 函数实现的，它接收 ctypes 类型为参数，返回一个新的类型:
>>> PI = POINTER(c_int)
<class 'ctypes.LP_c_long'>
>>> PI(42)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: expected c_long instead of int
>>> PI(c_int(42))
<ctypes.LP_c_long object at 0x...>
无参调用指针类型可以创建一个 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 列表中有 POINTER(c_int) 或在结构体定义中将其用作成员字段的类型，则只接受完全相同类型的实例。 此规则也有一些例外情况，在这些情况下 ctypes 可以接受其他对象。 例如，你可以传入兼容的数组实例而不是指针类型。 因此，对于 POINTER(c_int)，ctypes 接受一个 c_int 数组:
>>> class Bar(Structure):
... _fields_ = [("count", c_int), ("values", POINTER(c_int))]
>>> bar = Bar()
>>> bar.values = (c_int * 3)(1, 2, 3)
>>> bar.count = 3
>>> for i in range(bar.count):
... print(bar.values[i])
此外，如果一个函数参数在 argtypes 中显式地声明为指针类型 (如 POINTER(c_int))，则可以向该函数传递所指向的类型的对象 (在本例 中为 c_int)。 在这种情况下，ctypes 将自动应用所需的 byref() 转换。conversion in this case automatically.
可以给指针内容赋值为 None 将其设置为 Null
>>> bar.values = None
有时候你拥有一个不兼容的类型。 在 C 中，你可以将一个类型强制转换为另一个。 ctypes 中的 a cast() 函数提供了相同的功能。 上面的结构体 Bar 的 value 字段接收 POINTER(c_int) 指针或者 c_int 数组，但是不能接受其他类型的实例:
>>> bar.values = (c_byte * 4)()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: incompatible types, c_byte_Array_4 instance instead of LP_c_long instance
这种情况下, 需要手动使用 cast() 函数。
cast() 函数可以将一个指针实例强制转换为另一种 ctypes 类型。 cast() 接收两个参数，一个 ctypes 指针对象或者可以被转换为指针的其他类型对象，和一个 ctypes 指针类型。 返回第二个类型的一个实例，该返回实例和第一个参数指向同一片内存空间:
>>> a = (c_byte * 4)()
>>> cast(a, POINTER(c_int))
<ctypes.LP_c_long object at ...>
所以 cast() 可以用来给结构体 Bar 的 values 字段赋值:
>>> bar = Bar()
>>> bar.values = cast((c_byte * 4)(), POINTER(c_int))
>>> print(bar.values[0])
直接翻译成 ctypes 的代码如下，但是这行不通:
>>> class cell(Structure):
... _fields_ = [("name", c_char_p),
... ("next", POINTER(cell))]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in cell
NameError: name 'cell' is not defined
因为新的 class cell 在 class 语句本身中是不可用的。 在 ctypes 中，我们可以定义 cell 类再在 class 语句之后设置 _fields_ 属性:
>>> from ctypes import *
>>> class cell(Structure):
... pass
>>> cell._fields_ = [("name", c_char_p),
... ("next", POINTER(cell))]
让我们试试。我们定义两个 cell 实例，让它们互相指向对方，然后通过指针链式访问几次:
>>> c1 = cell()
>>> c1.name = b"foo"
>>> c2 = cell()
>>> c2.name = b"bar"
>>> c1.next = pointer(c2)
>>> c2.next = pointer(c1)
>>> p = c1
>>> for i in range(8):
... print(p.name, end=" "
)
... p = p.next[0]
foo bar foo bar foo bar foo bar
回调函数
ctypes 允许创建一个指向 Python 可调用对象的 C 函数。它们有时候被称为 回调函数 。
首先，你必须为回调函数创建一个类，这个类知道调用约定，包括返回值类型以及函数接收的参数类型及个数。
CFUNCTYPE() 工厂函数使用 cdecl 调用约定创建回调函数类型。在 Windows 上， WINFUNCTYPE() 工厂函数使用 stdcall 调用约定为回调函数创建类型。
这些工厂函数的第一个参数是返回值类型，回调函数的参数类型作为剩余参数。
这里展示一个使用标准 C 库的 qsort() 函数例子，使用它在一个回调函数的协助下对条目进行排序。 qsort() 将被用来给一个整数的数组排序:
>>> IntArray5 = c_int * 5
>>> ia = IntArray5(5, 1, 7, 33, 99)
>>> qsort = libc.qsort
>>> qsort.restype = None
qsort() 被调用时必须传入一个指向要排序的数据的指针、数据数组中的条目数、每条目的大小以及一个指向比较函数即回调函数的指针。 回调函数将附带两个指向条目的指针进行调用，如果第一个条目小于第二个条目则它必须返回一个负整数，如果两者相等则返回零，在其他情况下则返回一个正整数。
所以，我们的回调函数要接收两个整数指针，返回一个整数。首先我们创建回调函数的 类型
>>> CMPFUNC = CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
首先，这是一个简单的回调，它会显示传入的值:
>>> def py_cmp_func(a, b):
... print("py_cmp_func", a[0], b[0])
... return 0
>>> cmp_func = CMPFUNC(py_cmp_func)
>>> qsort(ia, len(ia), sizeof(c_int), cmp_func)
py_cmp_func 5 1
py_cmp_func 33 99
py_cmp_func 7 33
py_cmp_func 5 7
py_cmp_func 1 7
现在我们可以比较两个元素并返回有用的结果了:
>>> def py_cmp_func(a, b):
... print("py_cmp_func", a[0], b[0])
... return a[0] - b[0]
>>> qsort(ia, len(ia), sizeof(c_int), CMPFUNC(py_cmp_func))
py_cmp_func 5 1
py_cmp_func 33 99
py_cmp_func 7 33
py_cmp_func 1 7
py_cmp_func 5 7
我们可以轻易地验证，现在数组是有序的了:
>>> for i in ia: print(i, end=" ")
1 5 7 33 99
这些工厂函数可以当作装饰器工厂，所以可以这样写:
>>> @CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
... def py_cmp_func(a, b):
... print("py_cmp_func", a[0], b[0])
... return a[0] - b[0]
>>> qsort(ia, len(ia), sizeof(c_int), py_cmp_func)
py_cmp_func 5 1
py_cmp_func 33 99
py_cmp_func 7 33
py_cmp_func 1 7
py_cmp_func 5 7
请确保你维持的 CFUNCTYPE() 对象的引用周期与它们在 C 代码中的使用期一样长。 ctypes 不会确保这一点，如果不这样做，它们可能会被垃圾回收，导致程序在执行回调函数时发生崩溃。
注意，如果回调函数在Python之外的另外一个线程使用(比如，外部代码调用这个回调函数)， ctypes 会在每一次调用上创建一个虚拟 Python 线程。这个行为在大多数情况下是合理的，但也意味着如果有数据使用 threading.local 方式存储，将无法访问，就算它们是在同一个 C 线程中调用的 。
访问 dll 的导出变量
某些共享库不仅会导出函数，还会导出变量。 一个例子就是 Python 库本身的 Py_Version，Python 运行时版本号被编码为单个整数常量。
ctypes 可以通过类型的 in_dll() 类方法访问这样的值。 pythonapi 是一个用于访问 Python C api 预定义符号:
>>> version = ctypes.c_int.in_dll(ctypes.pythonapi, "Py_Version")
>>> print(hex(version.value))
0x30c00a0
一个扩展例子, 同时也展示了使用指针访问 Python 导出的 PyImport_FrozenModules 指针对象。
对文档中这个值的解释说明
该指针被初始化为指向一个 _frozen 记录的数组，以一个所有成员均为 NULL 或零的记录表示结束。 当一个冻结模块被导入时，它将在此表中被搜索。 第三方代码可以利用此方式来提供动态创建的冻结模块集。
这足以证明修改这个指针是很有用的。为了让实例大小不至于太长，这里只展示如何使用 ctypes 读取这个表:
>>> from ctypes import *
>>> class struct_frozen(Structure):
... _fields_ = [("name", c_char_p),
... ("code", POINTER(c_ubyte)),
... ("size", c_int),
... ("get_code", POINTER(c_ubyte)), # 函数指针
... ]
我们定义了 _frozen 数据类型，所以我们可以获取表的指针:
>>> FrozenTable = POINTER(struct_frozen)
>>> table = FrozenTable.in_dll(pythonapi, "_PyImport_FrozenBootstrap")
由于 table 是指向 struct_frozen 数组的 指针 ，我们可以遍历它，只不过需要自己判断循环是否结束，因为指针本身并不包含长度。它早晚会因为访问到野指针或者什么的把自己搞崩溃，所以我们最好在遇到 NULL 后就让它退出循环:
>>> for item in table:
... if item.name is None:
... break
... print(item.name.decode("ascii"), item.size)
_frozen_importlib 31764
_frozen_importlib_external 41499
zipimport 12345
Python 的冻结模块和冻结包(由负 size 成员表示)并不是广为人知的事情，它们仅仅用于实验。例如，可以使用 import __hello__ 尝试一下这个功能。
ctypes 也有自己的边界，有时候会发生一些意想不到的事情。
比如下面的例子:
>>> from ctypes import *
>>> class POINT(Structure):
... _fields_ = ("x", c_int), ("y", c_int)
>>> class RECT(Structure):
... _fields_ = ("a", POINT), ("b", POINT)
>>> p1 = POINT(1, 2)
>>> p2 = POINT(3, 4)
>>> rc = RECT(p1, p2)
>>> print(rc.a.x, rc.a.y, rc.b.x, rc.b.y)
1 2 3 4
>>> # 现在交换这两个
>>> rc.a, rc.b = rc.b, rc.a
>>> print(rc.a.x, rc.a.y, rc.b.x, rc.b.y)
3 4 3 4
嗯。我们预想应该打印 3 4 1 2 。但是为什么呢? 这是 rc.a, rc.b = rc.b, rc.a 这行代码展开后的步骤:
>>> temp0, temp1 = rc.b, rc.a
>>> rc.a = temp0
>>> rc.b = temp1
注意 temp0 和 temp1 对象始终引用了对象 rc 的内容。然后执行 rc.a = temp0 会把 temp0 的内容拷贝到 rc 的空间。这也改变了 temp1 的内容。最终导致赋值语句 rc.b = temp1 没有产生预想的效果。
记住，访问被包含在结构体、联合、数组中的对象并不会将其 复制 出来，而是得到了一个代理对象，它是对根对象的内部内容的一层包装。
下面是另一个可能和预期有偏差的例子:
>>> s = c_char_p()
>>> s.value = b"abc def ghi"
>>> s.value
b'abc def ghi'
>>> s.value is s.value
False
使用
