Python `ctypes` 模块：直接调用 C 动态链接库函数

好的，各位观众老爷，欢迎来到“Python ctypes：C语言大哥，带带我！”特别节目。今天咱们就来聊聊Python这个小弟，怎么抱上C语言大哥的大腿，直接调用C动态链接库里的函数。

开场白：Python与C语言的爱恨情仇

话说Python这门语言，优雅是优雅，简洁是简洁，但是遇到一些性能要求极高的任务，或者需要直接操作硬件的时候，就有点力不从心了。这时候，就得请出咱们的老大哥——C语言。C语言效率高，可以直接操控内存，简直是性能怪兽。

但是，Python毕竟是Python，它有自己的坚持，不可能完全抛弃自己去拥抱C语言。于是，ctypes模块就应运而生，它就像一个翻译官，让Python可以听懂C语言，直接调用C语言编译出来的动态链接库（DLL或SO）里的函数。

ctypes：连接Python与C的桥梁

ctypes是Python自带的一个外部函数库，它提供了一套兼容C语言的数据类型，并且允许Python程序调用DLL或共享库中的函数。简单来说，ctypes就是Python和C语言之间的桥梁。

准备工作：先来个简单的C语言动态链接库

咱们先写一个简单的C语言程序，编译成动态链接库，给Python调用。

// my_library.c
#include <stdio.h>

// 一个简单的加法函数
int add(int a, int b) {
  return a + b;
}

// 一个打印字符串的函数
void print_message(const char *message) {
  printf("C says: %sn", message);
}

//一个可以修改参数值的函数
void modify_value(int *value) {
  *value = *value * 2;
}

//返回结构体的函数
typedef struct {
    int x;
    int y;
} Point;

Point create_point(int x, int y) {
    Point p;
    p.x = x;
    p.y = y;
    return p;
}

//接受结构体指针的函数
int distance(Point *p1, Point *p2) {
    int dx = p1->x - p2->x;
    int dy = p1->y - p2->y;
    return dx * dx + dy * dy;
}

接下来，咱们用GCC把它编译成动态链接库。

• Linux/macOS:

  gcc -shared -o my_library.so my_library.c

• Windows: (假设你已经安装了MinGW)

  gcc -shared -o my_library.dll my_library.c -Wl,--export-all-symbols

编译完成后，你就得到了一个my_library.so（Linux/macOS）或者my_library.dll（Windows）文件。这个就是咱们要给Python调用的C语言动态链接库。

Python登场：ctypes的使用方法

接下来，就轮到Python出场了。咱们用ctypes模块来加载这个动态链接库，并调用里面的函数。

import ctypes
import os

# 加载动态链接库
# 根据操作系统选择不同的库文件
if os.name == 'nt':  # Windows
    my_lib = ctypes.CDLL('./my_library.dll')
else:  # Linux/macOS
    my_lib = ctypes.CDLL('./my_library.so')

# 告诉ctypes add函数的参数类型和返回类型
my_lib.add.argtypes = [ctypes.c_int, ctypes.c_int]
my_lib.add.restype = ctypes.c_int

# 调用add函数
result = my_lib.add(10, 20)
print(f"10 + 20 = {result}")

# 告诉ctypes print_message函数的参数类型
my_lib.print_message.argtypes = [ctypes.c_char_p]
my_lib.print_message.restype = None #void

# 调用print_message函数
message = "Hello from Python!".encode('utf-8') # 需要编码成bytes
my_lib.print_message(message)

# 告诉ctypes modify_value 函数的参数类型
my_lib.modify_value.argtypes = [ctypes.POINTER(ctypes.c_int)]
my_lib.modify_value.restype = None

# 调用 modify_value函数
value = ctypes.c_int(5)
print(f"Before modify: {value.value}")
my_lib.modify_value(ctypes.byref(value)) # 传入指针
print(f"After modify: {value.value}")

#定义结构体
class Point(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int),
                ("y", ctypes.c_int)]

# 设置create_point 函数的返回类型
my_lib.create_point.restype = Point

# 调用 create_point 函数
p = my_lib.create_point(1, 2)
print(f"Point: x={p.x}, y={p.y}")

# 设置distance函数的参数类型和返回类型
my_lib.distance.argtypes = [ctypes.POINTER(Point), ctypes.POINTER(Point)]
my_lib.distance.restype = ctypes.c_int

# 创建两个Point对象
p1 = Point(1, 2)
p2 = Point(4, 6)

# 调用distance函数
dist = my_lib.distance(ctypes.byref(p1), ctypes.byref(p2))
print(f"Distance between points: {dist}")

代码解释：

1. 加载动态链接库：

   my_lib = ctypes.CDLL('./my_library.so') #Linux/macOS
   # 或者
   my_lib = ctypes.CDLL('./my_library.dll') #windows

   这行代码告诉Python，去加载my_library.so (Linux/macOS) 或 my_library.dll (Windows) 这个动态链接库。ctypes.CDLL 就是用来加载C语言风格的动态链接库的。

2. 指定函数参数类型和返回类型：

   my_lib.add.argtypes = [ctypes.c_int, ctypes.c_int]
   my_lib.add.restype = ctypes.c_int

   这非常重要！Python需要知道C语言函数的参数类型和返回类型，才能正确地调用它。ctypes.c_int 表示C语言的int类型。 如果你的C函数没有返回值（void），那么restype设置为None。

3. 调用C函数：

   result = my_lib.add(10, 20)
   print(f"10 + 20 = {result}")

   现在，你就可以像调用普通的Python函数一样，调用C语言的add函数了。

4. 字符串处理:

   C中的字符串是char*类型，Python中需要用encode('utf-8') 将字符串转换成字节类型，然后通过ctypes.c_char_p传递。

5. 指针处理:

   C中的指针在Python中需要使用ctypes.POINTER来表示，并且使用ctypes.byref()获取变量的指针。

6. 结构体处理:

   在Python中使用ctypes.Structure来定义C语言中的结构体，并通过_fields_属性指定结构体的成员变量和类型。

ctypes数据类型：Python与C语言的翻译官

ctypes提供了一系列与C语言数据类型相对应的数据类型，方便Python与C语言进行数据交换。下面是一些常用的数据类型对应关系：

C语言数据类型	ctypes数据类型	Python类型
int	ctypes.c_int	整数
float	ctypes.c_float	浮点数
double	ctypes.c_double	浮点数
char	ctypes.c_char	字符串（长度为1）
char *	ctypes.c_char_p	字节串
void *	ctypes.c_void_p	整数
int *	ctypes.POINTER(ctypes.c_int)	/
struct	ctypes.Structure	/

高级技巧：指针、结构体和回调函数

ctypes的功能远不止调用简单的函数，它还可以处理指针、结构体和回调函数等高级特性。

1. 指针

   C语言的灵魂是指针，ctypes当然也支持指针。你可以使用ctypes.POINTER(type)来定义一个指针类型，然后用ctypes.byref(obj)来获取对象的指针。

   # C代码
   // void increment(int *value) {
   //   (*value)++;
   // }
   
   # Python代码
   import ctypes
   
   # 加载动态链接库
   my_lib = ctypes.CDLL('./my_library.so')
   
   # 定义函数参数类型
   my_lib.increment.argtypes = [ctypes.POINTER(ctypes.c_int)]
   my_lib.increment.restype = None
   
   # 创建一个整数
   value = ctypes.c_int(10)
   
   # 调用C函数，传递指针
   my_lib.increment(ctypes.byref(value))
   
   # 打印结果
   print(f"Value after increment: {value.value}")

2. 结构体

   C语言的结构体是一种复合数据类型，ctypes也提供了ctypes.Structure来定义结构体。你需要定义一个类，继承ctypes.Structure，然后定义一个_fields_属性，指定结构体的成员变量和类型。

   # C代码
   // typedef struct {
   //   int x;
   //   int y;
   // } Point;
   
   # Python代码
   import ctypes
   
   # 定义结构体
   class Point(ctypes.Structure):
       _fields_ = [("x", ctypes.c_int),
                   ("y", ctypes.c_int)]
   
   # 创建一个Point对象
   p = Point(10, 20)
   
   # 访问结构体成员
   print(f"Point: x={p.x}, y={p.y}")

3. 回调函数

   C语言的回调函数是指，你把一个函数的指针传递给另一个函数，让它在适当的时候调用。ctypes也支持回调函数，你需要使用ctypes.CFUNCTYPE来定义一个函数类型，然后创建一个Python函数，把它转换成C函数指针，传递给C函数。

   # C代码
   // typedef void (*callback_func)(int);
   
   // void call_callback(callback_func callback, int value) {
   //   callback(value);
   // }
   
   # Python代码
   import ctypes
   
   # 定义回调函数类型
   CallbackFunc = ctypes.CFUNCTYPE(None, ctypes.c_int)
   
   # 定义Python回调函数
   def my_callback(value):
       print(f"Python callback: value={value}")
   
   # 创建C函数指针
   c_callback = CallbackFunc(my_callback)
   
   # 加载动态链接库
   my_lib = ctypes.CDLL('./my_library.so')
   
   # 定义函数参数类型
   my_lib.call_callback.argtypes = [CallbackFunc, ctypes.c_int]
   my_lib.call_callback.restype = None
   
   # 调用C函数，传递回调函数指针
   my_lib.call_callback(c_callback, 100)

注意事项：ctypes的坑与技巧

1. 类型匹配： 一定要确保Python和C语言的数据类型匹配，否则可能会导致程序崩溃或者产生不可预料的结果。
2. 内存管理： C语言需要手动管理内存，而Python有自动垃圾回收机制。在使用ctypes的时候，需要注意内存管理的问题，避免内存泄漏。
3. 字符串编码： C语言的字符串是char *类型，Python的字符串是Unicode类型。在传递字符串的时候，需要进行编码和解码，确保编码方式一致。一般来说，使用UTF-8编码比较安全。
4. 异常处理： C语言的错误处理方式和Python不同。在使用ctypes调用C函数的时候，需要注意C函数的错误码，并进行相应的处理。
5. 平台差异： 不同平台的动态链接库的后缀名不同（.so、.dll、.dylib），需要根据平台选择正确的动态链接库。

ctypes的应用场景

1. 调用C语言库： 这是ctypes最常见的应用场景。你可以使用ctypes调用各种C语言库，例如图形库、音频库、数学库等，扩展Python的功能。
2. 访问硬件： ctypes可以直接调用底层的C函数，因此可以用来访问硬件，例如串口、USB接口等。
3. 性能优化： 如果你的Python程序中有一些性能瓶颈，你可以用C语言实现这些部分，然后用ctypes调用它们，提高程序的性能。
4. 逆向工程： ctypes可以用来分析和修改二进制文件，例如DLL文件、EXE文件等。

总结：ctypes的魅力与挑战

ctypes是一个强大的工具，它让Python可以轻松地调用C语言代码，扩展了Python的功能，提高了程序的性能。但是，ctypes也有一些挑战，例如类型匹配、内存管理、字符串编码等。你需要仔细学习ctypes的用法，才能充分发挥它的威力。

总而言之，ctypes就像一位经验丰富的翻译官，它让Python和C语言这对好基友可以无障碍地交流，共同完成各种任务。掌握ctypes，你就掌握了一项强大的技能，可以让你在编程的世界里更加游刃有余。

好了，今天的“Python ctypes：C语言大哥，带带我！”特别节目就到这里。感谢各位观众老爷的收看，咱们下期再见！