python 中 ctypes 的使用尝试

最近在看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_p
s3 = clib.strcat(s1,s2)

print( s1.value, type(s1), id(s1), id(s1.value), type(s1.value) ) #ab
print( 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) ) #ab
print( s2.value, type(s2), id(s2), id(s2.value), type(s2.value) ) #b

结果：

(140474265252848, 140474265252896)
--------------------------------------------------------------------------------
('a', <class 'ctypes.c_char_p'>, 140474264436032, 140474265252848, <type 'str'>)
('b', <class 'ctypes.c_char_p'>, 140474263869200, 140474265252896, <type 'str'>)
********************************************************************************
('ab', <class 'ctypes.c_char_p'>, 140474264436032, 140474263886368, <type 'str'>)
('b', <class 'ctypes.c_char_p'>, 140474263869200, 140474265252896, <type 'str'>)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
('c', <class 'ctypes.c_char_p'>, 140474264436032, 140474265292896, <type 'str'>)
('b', <class 'ctypes.c_char_p'>, 140474263869200, 140474265252896, <type 'str'>)

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

from ctypes import *

class Test(Structure):
    pass

Test._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.contents
print(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 使用说明：

https://docs.python.org/zh-cn/3/library/ctypes.html

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

举例说明Python变量与Python数据内存空间的关系：

Python 变量a:

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

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

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

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

import ctypes
import random

d=ctypes.c_double*100000000
data=[]
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类型数据只能是其对应的映射关系。

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

参考文章：

https://www.cnblogs.com/night-ride-depart/p/4907613.html

ctypes 中的指针：

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

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

给出一个 C语言代码：

//test.c

#include <stdio.h>
#include <stdlib.h>

// 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 ctypes
from ctypes import c_int, c_char, Structure, POINTER, pointer, cdll

class Point(Structure):
    pass

Point._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 = None

clib.print_point.argtype = None
clib.print_point.restype = None

clib.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 ctypes
from ctypes import c_int, c_char, Structure, POINTER, pointer, cdll, byref

class Point(Structure):
    pass

Point._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 = None

clib.print_point.argtype = None
clib.print_point.restype = None

l = []
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 <stdio.h>
#include <stdlib.h>

// 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();

}

完整的test.py代码：

import ctypes
from ctypes import c_int, c_char, Structure, POINTER, pointer, cdll, byref

class Point(Structure):
    pass

Point._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 = None

clib.print_point.argtype = None
clib.print_point.restype = None

clib.free_point.argtype = None
clib.free_point.restype = None

l = []
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()

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

错误的提示也很明白，那就是不能用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语言下的内存申请就是谁申请谁负责释放。

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