python 中 ctypes 的使用尝试（python和java哪个更值得学）

python 中 ctypes 的使用尝试（python和java哪个更值得学）

最近在看Python的性能优化方面的文章，突然想起ctypes这个模块，对于这个模块一直不是很理解，不过再次看完相关资料有了些新的观点。

ctypes 这个模块个人观点就是提供一个Python类型与C类型数据转换接口或者说是规则的一个模块。ctypes定义的数据类型其实并不是一种数据类型，而更应该说是一种转换规则。ctypes定义的数据类型都是需要和Python数据类型进行关联的，然后传给C函数进行调用，在C函数调用的时候是根据ctypes的数据类型进行转换的，把关联的Python数据类型转换为C数据类型传给C函数。如果是ctypes定义的指针或者地址，其实是将Python变量对应的内存空间地址中的数据与ctypes数据类型进行关联，如果C函数内部对传过来的指针地址对应的变量进行修改，最后是ctypes将修改好的C数据类型转为Python类型数据并将其存入之前Python变量对应的内存空间中。

在调用ctypes时，程序的内存空间其实可以分为Python数据内存空间与C数据类型空间。ctypes定义的数据类型就是提供了一个Python数据类型与C数据类型转换的对应关系。ctypes定义的数据类型都是需要和Python数据类型关联的，在调用C函数的时候在实时的转为C数据类型。其中，Python数据类型存在与Python数据内存空间中，C数据类型存在与C数据内存空间中。

需要注意的一点是，一般情况下C数据内存空间是实时开辟的，用完就及时自动销毁的，当然也有特例，那就是numpy定义的array类型变量等， numpy定义的数据类型其实就是一种经过包装的C数据类型，当然numpy定义的array等类型变量存在于C数据内存空间中，而numpy下的array是可以持续存在的，不会自动销毁。

ctypes 提供了一些基本数据类型用来映射 C 语言和 Python 的类型， 可以这样说 ctypes 是提供的一种数据类型映射关系或是转换关系。

给出ctypes的一些用法代码：

from ctypes import *from platform import * cdll_names = { 'Darwin' : 'libc.dylib', 'Linux' : 'libc.so.6', 'Windows': 'msvcrt.dll' } clib = cdll.LoadLibrary(cdll_names[system()])a = b'a'b = b'b's1 = c_char_p(a)s2 = c_char_p(b)print(id(a), id(b))print('-'*80)print( s1.value, type(s1), id(s1), id(s1.value), type(s1.value) )print( s2.value, type(s2), id(s2), id(s2.value), type(s2.value) )print('*'*80)clib.strcat.argtype = (c_char_p, c_char_p)clib.strcat.restype = c_char_ps3 = clib.strcat(s1,s2)print( s1.value, type(s1), id(s1), id(s1.value), type(s1.value) ) #abprint( s2.value, type(s2), id(s2), id(s2.value), type(s2.value) ) #b#print(s3, type(s3), id(s3) )#print(a, id(a))#print(b, id(b))print("^"*80)s1.value = b'c'print( s1.value, type(s1), id(s1), id(s1.value), type(s1.value) ) #abprint( s2.value, type(s2), id(s2), id(s2.value), type(s2.value) ) #b

结果：

(140474265252848, 140474265252896)

--------------------------------------------------------------------------------

('a', , 140474264436032, 140474265252848, )

('b', , 140474263869200, 140474265252896, )

********************************************************************************

('ab', , 140474264436032, 140474263886368, )

('b', , 140474263869200, 140474265252896, )

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

('c', , 140474264436032, 140474265292896, )

('b', , 140474263869200, 140474265252896, )

用ctypes定义结构体转换规则：（转换为C数据内存空间时为一种链表结构）

from ctypes import *class Test(Structure): passTest._fields_ = [('x', c_int), ('y', c_char), ('next', POINTER(Test))]test = Test(11, 97, None)test2 = Test(12, 98, pointer(test))test3 = Test(13, 99, pointer(test2))print(test)print(type(test))print(test.x, test.y, test.next)print(type(test.x), type(test.y), type(test.next))test2=test3.next.contentsprint(test2)print(type(test2))print(test2.x, test2.y, test2.next)print(type(test2.x), type(test2.y), type(test2.next))print(test3)print(type(test3))print(test3.x, test3.y, test3.next)print(type(test3.x), type(test3.y), type(test3.next))

Test 类相当于把多个python数据类型与C数据类型映射关系打包在一起，是Structure类的继承类。而Test类的对象则是关联好了对应的python数据类型对象，转换时调用Test类的具体对象（如，test1,test2,test3）便会根据打包的python数据类型在C数据内存空间生成对应映射C类型数据。

需要注意的是不论使用ctypes定义数据类型还是结构体，其实都是不换为对应C数据类型开辟内存空间的，ctypes只是提供两者之间的对应关系：

如：

a = 100

b=ctypes.c_int(a)

其中，b是表示将根据Python数据类型int的a转换成C内存空间int的一种关系，当C函数调用b时则自动根据b所定义的规则在C数据内存空间中开辟C语言int类型为100的数据。

给出Python官方给出的 ctypes 使用说明：

​​变量a:

a变量------------>对应内存地址空间（13521458792）-------------------------->该空间存储的Python数据为Python类型的999。

上面的关系是由定义   a=999  生成的， 其中id(a)=13521458792  。

========================================================

为了更清楚的证明ctypes只是提供映射关系，可以看下面代码：

import ctypesimport randomd=ctypes.c_double*100000000data=[]for i in range(100000000): data.append(random.random())#上半部分##################################下半部分c_data=d(*data)

在ide中执行上面代码（分步执行）：

执行完上部分代码，查看内存使用情况：

执行完下部分代码，再次查看内存使用情况：

可以看出 ctypes 并没有提供数据类型的转换，而是提供了数据转换时对应的映射关系。

如果cytpes 定义的数据类型会直接生成对应的C类型数据在C类型的内存空间中那么执行下部分代码后的内存占用应该是 24.2%  以上，而实际只是从 12.1% 提高到了14.5%，多占用2.4%的内存，而这2.4%的内存不可能是转换后的C类型数据只能是其对应的映射关系。

===============================================================================

参考文章：

ctypes 中的指针：

==================================================================

本文的前部分说Python程序中C语言类型的数据空间并不会持续存在，会随着用完自动销毁，其实这个说法并不准确，如果我们将C数据内存空间下的数据给以一定方式保存（某种数据结构的形式保存在堆或栈中），也是可以进行持续保存的，当然这种保存是只在C类型内存空间中，如果要转回Python类型空间还是需要再转换的。

给出一个 C语言代码：

//test.c#include #include // Point 结构体struct Point{ int x; char y; struct Point *p;};static struct Point* head = NULL;static struct Point* current = NULL;static struct Point* walk = NULL;void new_point(struct Point *p){ if (p) { if(current==NULL) //是第一个element { head=p; current=p; printf("first add !!! \n"); } else //不是第一个element { current->p=p; current=p; printf("not first add !!! \n"); } // }}void print_point(){ walk=head; if(walk==NULL) { printf("error, it is a empty list!!! \n"); } else { while(walk!=current) { printf("x: %d, y: %c \n", walk->x, walk->y); walk=walk->p; } if(walk!=NULL) { printf("x: %d, y: %c \n", walk->x, walk->y); } }}void main(){ struct Point a; a.x=97; a.y='a'; a.p=NULL; struct Point b; b.x=98; b.y='b'; b.p=NULL; struct Point c; c.x=99; c.y='c'; c.p=NULL; struct Point d; d.x=100; d.y='d'; d.p=NULL; struct Point e; e.x=101; e.y='e'; e.p=NULL; new_point(&a); new_point(&b); new_point(&c); new_point(&d); new_point(&e); print_point();}

该文件命名为  test.c  。

在Ubuntu18.04系统中编译并执行：

gcc test.c

编译成动态链接库：

gcc -fPIC -shared test.c -o test.so

有了动态链接库，我们就可以使用ctypes模块将Python数据转为C类型数据并调用C语言下链接库的函数，给出代码：

import ctypesfrom ctypes import c_int, c_char, Structure, POINTER, pointer, cdllclass Point(Structure): passPoint._fields_ = [('x', c_int), ('y', c_char), ('next', POINTER(Point))]a=Point(97, b'a', None)b=Point(98, b'b', None)c=Point(99, b'c', None)d=Point(100, b'd', None)e=Point(101, b'e', None)a.next=pointer(b)b.next=pointer(c)c.next=pointer(d)d.next=pointer(e)clib = cdll.LoadLibrary('./test.so')clib.new_point.argtype = POINTER(Point)clib.new_point.restype = Noneclib.print_point.argtype = Noneclib.print_point.restype = Noneclib.new_point(pointer(a))clib.new_point(pointer(b))clib.new_point(pointer(c))clib.new_point(pointer(d))clib.new_point(pointer(e))print("-"*50)clib.print_point()print("-"*50)clib.print_point()

该Python代码命名为  test.py  文件。

运行结果：

可以看到我们用ctypes定义好映射规则，即：Point 类的对象 ： a, b, c, d, e

a, b, c, d, e 对象关联好了Python命名空间下的Python数据类型，当调用c语言库函数时将按照a,b,c,d,e对象所定义的映射在C语言内存空间下生成对应的C语言数据类型。

两次调用C库中的clib.print_point()函数均可以打印C内存空间下的栈中的数据，这充分说明本文前述内容的不充分的地方。C语言内存空间下的数据只要我们加载的动态链接库的接口变量，这里是 clib ，还存在，就是可以一直调用的。

如果我们申请完C语言内存空间后如果删除clib会不会自动释放内存呢？？？

代码：

import ctypesfrom ctypes import c_int, c_char, Structure, POINTER, pointer, cdll, byrefclass Point(Structure): passPoint._fields_ = [('x', c_int), ('y', c_char), ('next', POINTER(Point))]clib = cdll.LoadLibrary('./test.so')clib.new_point.argtype = POINTER(Point)clib.new_point.restype = Noneclib.print_point.argtype = Noneclib.print_point.restype = Nonel = []for i in range(10000*10000): l.append( Point(i, b'a', None) ) clib.new_point(byref(l[-1]))

其中，test.so 链接库为本文前面所给。

在IDE执行：

删除 clib 后查看内存情况：

可以发现前面说的又有不对的地方，如果删除clib变量了，但是C语言内存空间还是没有释放，看来最终的答案是C语言内存空间如果申请了就需要设置相应的C函数进行释放，如果没有进行C函数释放那么在Python程序的生命周期内C语言内存空间所申请的空间都是会一直存在的。

于是再次改test.c的代码增加free_point函数:

void new_point(struct Point *p){ if (p) { if(current==NULL) //是第一个element { head=p; current=p; printf("first add !!! \n"); } else //不是第一个element { current->p=p; current=p; printf("not first add !!! \n"); } // }}

完整的test.c 代码：

//test.c#include #include // Point 结构体struct Point{ int x; char y; struct Point *p;};static struct Point* head = NULL;static struct Point* current = NULL;static struct Point* walk = NULL;void new_point(struct Point *p){ if (p) { if(current==NULL) //是第一个element { head=p; current=p; printf("first add !!! \n"); } else //不是第一个element { current->p=p; current=p; printf("not first add !!! \n"); } // }}void print_point(){ walk=head; if(walk==NULL) { printf("error, it is a empty list!!! \n"); } else { while(walk!=current) { printf("x: %d, y: %c \n", walk->x, walk->y); walk=walk->p; } if(walk!=NULL) { printf("x: %d, y: %c \n", walk->x, walk->y); } }}void free_point(){ while(head!=NULL) { walk=head; head=head->p; printf("begin delete one element !!! \n"); printf("x: %d, y: %c \n", walk->x, walk->y); free(walk); printf("success delete one element !!! \n"); //printf(" %x \n", walk); }}void main(){ struct Point a; a.x=97; a.y='a'; a.p=NULL; struct Point b; b.x=98; b.y='b'; b.p=NULL; struct Point c; c.x=99; c.y='c'; c.p=NULL; struct Point d; d.x=100; d.y='d'; d.p=NULL; struct Point e; e.x=101; e.y='e'; e.p=NULL; new_point(&a); new_point(&b); new_point(&c); new_point(&d); new_point(&e); print_point();}

View Code

完整的test.py代码：

import ctypesfrom ctypes import c_int, c_char, Structure, POINTER, pointer, cdll, byrefclass Point(Structure): passPoint._fields_ = [('x', c_int), ('y', c_char), ('next', POINTER(Point))]clib = cdll.LoadLibrary('./test.so')clib.new_point.argtype = POINTER(Point)clib.new_point.restype = Noneclib.print_point.argtype = Noneclib.print_point.restype = Noneclib.free_point.argtype = Noneclib.free_point.restype = Nonel = []for i in range(10000): l.append( Point(i, b'a', None) ) clib.new_point(byref(l[-1]))print("-"*50)#clib.print_point()clib.free_point()

View Code

这个释放内存的函数逻辑十分的清晰，但是运行起来却报错。

错误的提示也很明白，那就是不能用free来释放这块内存，查了好久的C语言语法发现这么写没有语法问题，虽然C语言已经是10多年前学的东西了，不过这么简单的逻辑不应该出错，这也是十分的不解。

最后在网上看到有人总结了这么一句C语言释放堆内存的解释，十分受用，那就是——“谁申请，谁释放”

在前面的操作中我们删出了clib变量，那么就是不能再利用C语言动态链接库文件中定义的函数来操作数据了，但是此时并不会释放C内存空间中的内存，那我们如果把和C内存空间相关联的ctypes变量删除，那就是说我们利用ctypes变量映射Python变量的方式使用隐方式生成C语言内存空间下对应的变量（调用动态链接库中的函数自动映射的在C内存空间下生成的数据），那么我们删除掉这个映射关系，Python中的ctypes会不会本身就存在垃圾回收函数，在Python的垃圾回收机制下自动的回收在C内存空间下生成的堆空间呢？？？

于是操作：

最终发现，设置ctypes下的数据类型虽然只是定义了一种映射关系，并不能在C语言内存空间下生成对应的变量，最后还是需要调用C内存空间下的函数才能生成对应的C类型数据变量，但是由于C内存空间与Python内存空间是隔离的，我们不能直接操作C内存空间下的数据，而C内存下的数据本身又遵守“谁生成谁销毁”的原则，这又导致我们无法利用C语言下的free函数来释放对应的变量空间（这些变量空间是ctypes下定义的数据类型在调用C动态库中函数自动由Python的ctypes生成的），因此，我们只有利用Python的语言机制和ctypes的语言机制来对C内存空间下的变量进行释放了，于是我们删除掉对应的ctypes数据变量也就是删除了Python变量与C变量的关联，这样自然就可以触发Python语言下的垃圾回收机制来释放内存。最后的总结还是那句，C语言下的内存申请就是谁申请谁负责释放。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。