Python--ctypes(数据类型详细踩坑指南）

INnoVation

Caught in the bug code.

pthon--ctypes包装C语言数据类型

一. ctypes使用介绍

ctypes 是 Python 的外部函数库。它提供了与 C 兼容的数据类型，并允许调用 DLL 或共享库中的函数。可使用该模块以纯 Python 形式对这些库进行封装。这篇文章主要是介绍如何使用ctypes模块对C语言编译的动态链接库要求的数据类型进行封装，主要包括以下几类：

C语言中基础的数据类型(如char, int等)
数组类型
指针类型
结构体类型
嵌套结构体
结构体数组
结构体指针
指针数组
结构体指针数组

1. 动态链接库

（1）下面是测试用的C语言代码

#include <stdio.h>
#include <string.h>
typedef struct student {
    char class;
    int grade;
    long array[3];
    int *point;
}student_t;
typedef struct nest_stu {
    char rank;
    student_t nest_stu;
    student_t strct_array[2];
    student_t *strct_point;
    student_t *strct_point_array[2];
}nest_stu_t;
typedef struct g_student {
    int g_grade;
}g_stu;
g_stu g_stu_t = {11};
int test_func(char char_arg, int int_arg, float float_arg, char *stu_buf, char *nest_stu_buf, char *out_buf)
    //data type test
    printf("char arg: %c\n", char_arg);
    printf("int arg: %d\n", int_arg);
    printf("float arg: %f\n", float_arg);
    student_t *stu_p = NULL;
    nest_stu_t *nest_stu_p = NULL;
    stu_p = (student_t *)stu_buf;
    nest_stu_p = (nest_stu_t *)nest_stu_buf;
    //struct type test
    printf("struct class: %c\n", stu_p->class);
    printf("struct grade: %d\n", stu_p->grade);
    printf("struct array[0]: %d array[1]: %d\n", stu_p->array[0], stu_p->array[1]);
    printf("struct point: %d\n", *(stu_p->point));
    //nest struct test
    printf("nest struct rank: %d\n", nest_stu_p->rank);
    printf("nest struct stu grade: %d\n", nest_stu_p->nest_stu.grade);
    //struct array
    printf("nest struct array[0] grade: %d\n", nest_stu_p->strct_array[0].grade);
    printf("nest struct array[1] grade: %d\n", nest_stu_p->strct_array[1].grade);
    //struct point
    printf("nest struct point grade: %d\n", nest_stu_p->strct_point->grade);
    //struct point array
    printf("nest struct point array[0] grade: %d\n", nest_stu_p->strct_point_array[0]->grade);
    printf("nest struct point array[1] grade: %d\n", nest_stu_p->strct_point_array[1]->grade);
    //out buf test
    memcpy(out_buf, stu_p, sizeof




    
(int)*2);
    return 1;
}

（2）生成动态链接库
使用编译命令 gcc -Wall -g -fPIC -shared -o libstruct.so.0 ctype_code.c 生成动态链接库，可以使用 nm -D <文件名> 查看内部的符号信息，如下图：

还可以使用 readelf -s 查看elf文件内的符号分布。关于动态链接库的更多知识，这里有一篇不错的文章推荐给大家

关于动态链接库的生成、内部符号和数据的定义还是有必要了解一下的，这里限于篇幅就不一一展开了。

2. ctypes的使用

（1）C语言中基础的数据类型
这部分的使用比较简单，直接使用ctypes内置的方法创建对象即可，ctypes提供的方法和C语言对应的数据类型如下表：

使用方法：

# -*- coding: utf-8 -*- from ctypes import * # 字符,仅接受one character bytes, bytearray or integer char_type = c_char(b"a") byte_type = c_char(1) # 字符串 string_type = c_wchar_p("abc") int_type = c_int(2) # 直接打印输出的是对象信息，获取值需要使用value方法 print(char_type, byte_type, int_type) print(char_type.value, byte_type.value, string_type.value, int_type.value)

输出：

c_char(b'a') c_char(b'\x01') c_int(2)
b'a' b'\x01' abc 2

（2）数组类型
数组的创建和C语言的类似，给定数据类型和长度即可，如下：

# 数组 # 定义类型 char_array = c_char * 3 # 初始化 char_array_obj = char_array(b"a", b"b", 2) # 打印只能打印数组对象的信息 print(char_array_obj) # 打印值通过value方法 print(char_array_obj.value)

输出：

< main .c_char_Array_3 object at 0x7f2252e6dc20>
b'ab\x02'

也可以在创建的时候直接进行初始化，如下：

int_array = (c_int * 3)(1, 2, 3) for i in int_array: print(i) char_array_2 = (c_char * 3)(1, 2, 3) print(char_array_2.value)

输出：

1
2
3
b'\x01\x02\x03'

这里需要注意，通过 value 方法获取值只适用于 字符数组 ，其他类型如 print(int_array.value) 的使用会报错：

AttributeError: 'c_int_Array_3' object has no attribute 'value'

（3）指针类型
ctypes提供了pointer()和POINTER()两种方法创建指针，区别在于：

pointer() 用于将对象转化为指针，如下：

# 指针类型 int_obj = c_int(3) int_p = pointer(int_obj) print(int_p) # 使用contents方法访问指针 print(int_p.contents) # 获取指针指向的值 print(int_p[0])

输出：

<__main__.LP_c_int object at 0x7fddbcb1de60>
c_int(3)
3

POINTER() 用于定义某个类型的指针，如下：

# 指针类型 int_p = POINTER(c_int) # 实例化 int_obj = c_int(4) int_p_obj = int_p(int_obj) print(int_p_obj) print(int_p_obj.contents) print(int_p_obj[0])

输出：

<__main__.LP_c_int object at 0x7f47df7f79e0>
c_int(4)
4

如果弄错了初始化的方式会报错， POINTER() 如下：

# 指针类型 int_p = POINTER(c_int) # 实例化 int_obj = c_int(4) int_p_obj = POINTER(int_obj)

报错：

TypeError: must be a ctypes type

pointer() 如下：

# 指针类型 int_p = pointer(c_int)

报错：

TypeError: _type_ must have storage info

创建空指针的方式

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

输出：

False

指针类型的转换
ctypes提供 cast() 方法将一个ctypes实例转换为指向另一个ctypes数据类型的指针， cast() 接受两个参数，一个是ctypes对象，它是或可以转换成某种类型的指针，另一个是ctypes指针类型。它返回第二个参数的一个实例，该实例引用与第一个参数相同的内存块。

int_p = pointer(c_int(4)) print(int_p) char_p_type = POINTER(c_char) print(char_p_type) cast_type = cast(int_p, char_p_type) print(cast_type)

输出：

<__main__.LP_c_int object at 0x7f43e2fcc9e0>
<class 'ctypes.LP_c_char'>
<ctypes.LP_c_char object at 0x7f43e2fcc950>

（4）结构体类型
结构体类型的实现，结构和联合必须派生自ctypes模块中定义的结构和联合基类。每个子类必须定义一个_fields_属性，_fields_必须是一个二元组列表，包含字段名和字段类型。 _pack_ 属性决定结构体的字节对齐方式，默认是4字节对齐，创建时使用 _pack_=1 可以指定1字节对齐。比如初始化 student_t 的方法如下，特别需要注意的是字段名不能和python关键字重名，不然会报错：

# -*- coding: utf-8 -*- from ctypes import * # 学生信息如下 stu_info = [("class", "A"), ("grade", 90), ("array", [1, 2, 3]), ("point", 4)] # 创建结构提类 class Student(Structure): _fields_ = [("class", c_char), ("grade", c_int), ("array", c_long * 3), ("point", POINTER(c_int))] print("sizeof Student: ", sizeof(Student)) # 实例化 long_array = c_long * 3 long_array_obj = long_array(1, 2, 3) int_p = pointer(c_int(4)) stu_info_value = [c_char(b"A"), c_int(90), long_array_obj, int_p] stu_obj = Student(*stu_info_value) # 这样打印报错，因为字段名和python关键字class重名了，这是需要特别注意的点 # print("stu info:", stu_obj.class, stu_obj.grade, stu_obj.array[0], stu_obj.point[0]) print("stu info:", stu_obj.grade, stu_obj.array[0], stu_obj.point[0])

输出：

sizeof Student: 40
stu info: 90 1 4

如果把 _pack_ 改为1，则输出：

sizeof Student: 37
stu info: 90 1 4

（5）嵌套结构体
嵌套结构体的使用需要创建基础结构体的类型，然后将基础结构体的类型作为嵌套结构体的成员， 注意基础结构体所属字段的字段类型是基础结构体的类名 ，如下：

# 创建类型, nest_stu字段的类型为基础结构体的类名 class NestStudent(Structure): _fields_ = [("rank", c_char), ("nest_stu", Student)] # 实例化 nest_stu_info_list = [c_char(b"M"), stu_obj] nest_stu_obj = NestStudent(*nest_stu_info_list) print("nest stu info: ", nest_stu_obj.rank, "basic stu info: ", nest_stu_obj.nest_stu.grade)

输出：

nest stu info: b'M' basic stu info: 90

（6）结构体数组
结构体数组与普通数组的创建类似，需要提前创建结构体的类型，然后使用 struct type * array_length 的方法创建数组。

# 结构体数组 # 创建结构体数组类型 stu_array = Student * 2 # 用Student类的对象实例化结构体数组 stu_array_obj = stu_array(stu_obj, stu_obj) # 增加结构体数组成员 class NestStudent(Structure): _fields_ = [("rank", c_char), ("nest_stu", Student), ("strct_array", Student * 2)] # 实例化 nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj] nest_stu_obj = NestStudent(*nest_stu_info_list) # 打印结构体数组第二个索引的grade字段的信息 print("stu struct array info: ", nest_stu_obj.strct_array[1].grade, nest_stu_obj.strct_array[1].array[0])

输出：

stu struct array info: 90 1

（7）结构体指针
首先创建结构体，然后使用ctype的指针方法包装为指针。

# 结构体指针 # # 创建结构体数组类型 stu_array = Student * 2 # # 用Student类的对象实例化结构体数组 stu_array_obj = stu_array(stu_obj, stu_obj) # 曾接结构体指针成员,注意使用类型初始化指针是POINTER() class NestStudent(Structure): _fields_ = [("rank", c_char), ("nest_stu", Student), ("strct_array", Student * 2), ("strct_point", POINTER(Student))] # 实例化,对Student的对象包装为指针使用pointer() nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj, pointer(stu_obj)] nest_stu_obj = NestStudent(*nest_stu_info_list) # 结构体指针指向Student的对象 print("stu struct point info: ", nest_stu_obj.strct_point.contents) # 访问Student对象的成员 print("stu struct point info: ", nest_stu_obj.strct_point.contents.grade)

输出：

stu struct point info: <__main__.Student object at 0x7f8d80e70200> # 结构体指针指向的对象信息
stu struct point info: 90 # Student结构体grade成员

（8）结构体指针数组
创建结构体指针数组的顺序为先创建结构体，然后包装为指针，最后再创建数组，用结构体指针去实例化数组。

# 结构体指针数组 # 创建结构体数组类型 stu_array = Student * 2 # # 用Student类的对象实例化结构体数组 stu_array_obj = stu_array(stu_obj, stu_obj) # 创建结构体指针数组 stu_p_array = POINTER(Student) * 2 # 使用pointer()初始化 stu_p_array_obj = stu_p_array(pointer(stu_obj), pointer(stu_obj)) # 曾接结构体指针成员,注意使用类型初始化指针是POINTER() class NestStudent(Structure): _fields_ = [("rank", c_char), ("nest_stu", Student), ("strct_array", Student * 2), ("strct_point", POINTER(Student)), ("strct_point_array", POINTER(Student) * 2)] # 实例化,对Student的对象包装为指针使用pointer() nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj, pointer(stu_obj), stu_p_array_obj] nest_stu_obj = NestStudent(*nest_stu_info_list) # 数组第二索引为结构体指针 print(nest_stu_obj.strct_point_array[1]) # 指针指向Student的对象 print(nest_stu_obj.strct_point_array[1].contents) # Student对象的grade字段 print(nest_stu_obj.strct_point_array[1].contents.grade)

输出：

<__main__.LP_Student object at 0x7f3f9a8e6200>
<__main__.Student object at 0x7f3f9a8e6290>
90

二. 调用动态链接库

ctypes导出了 cdll 对象，在Windows系统中还导出了 windll 和 oledll 对象用于载入动态连接库。通过操作这些对象的属性，你可以载入外部的动态链接库。 cdll 载入按标准的 cdecl 调用协议导出的函数，而 windll 导入的库按 stdcall 调用协议调用其中的函数。 oledll 也按 stdcall 调用协议调用其中的函数，并假定该函数返回的是 Windows HRESULT 错误代码，并当函数调用失败时，自动根据该代码甩出一个 OSError 异常。

1. 快速创建内存区域的方法

ctypes提供了 create_string_buffer() 函数创建一定长度的内存区域。当前的内存块内容可以通过 raw 属性存取，如果是创建NULL结束的字符串，使用 value 属性获取内存块的值。

>>> 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'

2. 调用动态链接库

使用方法如下：

# 结构体指针数组 # 创建结构体数组类型 stu_array = Student * 2 # # 用Student类的对象实例化结构体数组 stu_array_obj = stu_array(stu_obj, stu_obj) # 创建结构体指针数组 stu_p_array = POINTER(Student) * 2 # 使用pointer()初始化 stu_p_array_obj = stu_p_array(pointer(stu_obj), pointer(stu_obj)) # 曾接结构体指针成员,注意使用类型初始化指针是POINTER() class NestStudent(Structure): _fields_ = [("rank", c_char), ("nest_stu", Student), ("strct_array", Student * 2), ("strct_point", POINTER(Student)), ("strct_point_array", POINTER(Student) * 2)] # 实例化,对Student的对象包装为指针使用pointer() nest_stu_info_list = [c_char(b"M"), stu_obj, stu_array_obj, pointer(stu_obj), stu_p_array_obj] nest_stu_obj = NestStudent(*nest_stu_info_list) # # 数组第二索引为结构体指针 # print(nest_stu_obj.strct_point_array[1]) # # 指针指向Student的对象 # print(nest_stu_obj.strct_point_array[1].contents) # # Student对象的grade字段 # print(nest_stu_obj.strct_point_array[1].contents.grade) # 实例化动态链接库的载入对象 so_obj = cdll.LoadLibrary("./libstruct.so.0") # 准备入参 char_arg = c_char(b"Z") int_arg = c_int(13) float_arg = c_float(3.14159) # 准备出参 out_buf = create_string_buffer(b"", sizeof(Student)) # 注意C语言源码中入参要求是指针，所以这里需要再次使用pointer() # rest = so_obj.test_func(char_arg, int_arg, float_arg, pointer(stu_obj), pointer(nest_stu_obj), out_buf) # 或者使用ctypes.bryef()方法自动转换，更快一点 rest = so_obj.test_func(char_arg, int_arg, float_arg, byref(stu_obj), byref(nest_stu_obj), out_buf)