当前位置: 首页>移动开发>正文

python ctypes结构体里存列表 python ctypes 结构体数组

结构数组

在 C 语言中我们可以通过 struct 关键字定义结构类型,结构中的字段占据连续的内存空间,每个结构体占用的内存大小都相同,因此可以很容易地定义结构数组。和 C 语言一样,在 NumPy 中也很容易对这种结构数组进行操作。只要 NumPy 中的结构定义和C语言中的定义相同, NumPy 就可以很方便地读取 C 语言的结构数组的二进制数据,转换为 NumPy 的结构数组。

假设我们需要定义一个结构数组,它的每个元素都有 name , age 和 weight 字段。在 numpy 中可以如下定义:

>>> import numpy as np
>>> persontype = np.dtype({
...     'names': ['name', 'age', 'weight'],
...     'formats': ['S32', 'i', 'f']})
>>>
>>> a = np.array([
...     ('Zhang', 32, 75.5),
...     ('Wang', 24, 65.2),
...     ], dtype=persontype)
>>>
>>> import numpy as np
>>> persontype = np.dtype({
...     'names': ['name', 'age', 'weight'],
...     'formats': ['S32', 'i', 'f']})
>>>
>>> a = np.array([
...     ('Zhang', 32, 75.5),
...     ('Wang', 24, 65.2),
...     ], dtype=persontype)
>>>

先创建一个 dtype 对象 persontype ,通过其字典参数描述结构类型的各个字段。字典有两个关键字:names,formats。每个关键字对应的值都是一个列表。names定义结构中的每个字段名,而 formats 则定义每个字段的类型:

S32 : 32个字节的字符串类型,由于结构中的每个元素的大小必须固定,因此需要指定字符串的长度

i : 32bit的整数类型,相当于 np.int32

f : 32bit的单精度浮点数类型,相当于 np.float32

然后调用 array 函数创建数组,通过关键字参数 dtype=persontype , 指定所创建的数组的元素类型为结构persontype。运行上面程序之后,我们可以在IPython中执行如下的语句查看数组a的元素类型

>>> a
array([(b'Zhang', 32, 75.5), (b'Wang', 24, 65.2)],
      dtype=[('name', 'S32'), ('age', '<i4'), ('weight', '<f4')])
>>> a
array([(b'Zhang', 32, 75.5), (b'Wang', 24, 65.2)],
      dtype=[('name', 'S32'), ('age', '<i4'), ('weight', '<f4')])

这里看到了另外一种描述结构类型的方法: 一个包含多个组元的列表,其中形如 (字段名, 类型描述) 的组元描述了结构中的每个字段。类型描述前面添加了 | , < 等字符,这些字符用来描述字段值的字节顺序:

  • | : 忽视字节顺序
  • < : 低位字节在前
  • > : 高位字节在前

结构数组的存取方式和一般数组相同,通过下标能够取得其中的元素,注意元素的值看上去像是组元,实际上它是一个结构:

dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])
dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])

a[0]是一个结构元素,它和数组a共享内存数据,因此可以通过修改它的字段,改变原始数组中的对应字段:

>>> c = a[1]
>>> c["name"] = "Li"
>>> a[1]["name"]
"Li"
>>> c = a[1]
>>> c["name"] = "Li"
>>> a[1]["name"]
"Li"

结构像字典一样可以通过字符串下标获取其对应的字段值:

>>> a[0]["name"]
'Zhang'
>>> a[0]["name"]
'Zhang'

不但可以获得结构元素的某个字段,还可以直接获得结构数组的字段,它返回的是原始数组的视图,因此可以通过修改b[0]改变 a[0]["age"]

>>> b=a[:]["age"] # 或者a["age"]
>>> b
array([32, 24])
>>> b[0] = 40
>>> a[0]["age"]
40
>>> b=a[:]["age"] # 或者a["age"]
>>> b
array([32, 24])
>>> b[0] = 40
>>> a[0]["age"]
40

通过调用 a.tostring 或者 a.tofile 方法,可以直接输出数组a的二进制形式:

>>> a.tofile("test.bin")
>>> a.tofile("test.bin")

内存描述

内存对齐

C 语言的结构体为了内存寻址方便,会自动的添加一些填充用的字节,这叫做内存对齐。例如如果把下面的name[32] 改为 name[30] 的话,由于内存对齐问题,在 name 和 age 中间会填补两个字节,最终的结构体大小不会改变。因此如果 numpy 中的所配置的内存大小不符合 C 语言的对齐规范的话,将会出现数据错位。为了解决这个问题,在创建 dtype 对象时,可以传递参数 align=True,这样 numpy 的结构数组的内存对齐和C语言的结构体就一致了。

#include <stdio.h>

struct person
{
    char name[32];
    int age;
    float weight;
};

struct person p[2];

void main ()
{
    FILE *fp;
    int i;
    fp = fopen("test.bin","rb");
    fread(p, sizeof(struct person), 2, fp);
    fclose(fp);
    for(i=0;i<2;i++)
        printf("%s %d %f\n", p[i].name, p[i].age, p[i].weight);
    getchar();
}

结构类型中可以包括其它的结构类型,下面的语句创建一个有一个字段 f1 的结构, f1 的值是另外一个结构,它有字段 f2 ,其类型为 16bit 整数。

>>> np.dtype([('f1', [('f2', np.int16)])])
dtype([('f1', [('f2', '<i2')])])
>>> np.dtype([('f1', [('f2', np.int16)])])
dtype([('f1', [('f2', '<i2')])])

当某个字段类型为数组时,用组元的第三个参数表示,下面描述的 f1 字段是一个 shape 为 (2,3) 的双精度浮点数组:

>>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))])
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
>>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))])
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])

用下面的字典参数也可以定义结构类型,字典的关键字为结构中字段名,值为字段的类型描述,但是由于字典的关键字是没有顺序的,因此字段的顺序需要在类型描述中给出,类型描述是一个组元,它的第二个值给出字段的字节为单位的偏移量,例如age字段的偏移量为25个字节:

>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', '|S25'), ('age', '|u1')])
>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', '|S25'), ('age', '|u1')])
内存结构

如下图所示,关于数组的描述信息保存在一个数据结构中,这个结构引用两个对象:一块用于保存数据的存储区域和一个用于描述元素类型的 dtype 对象。

python ctypes结构体里存列表 python ctypes 结构体数组,python ctypes结构体里存列表 python ctypes 结构体数组_python,第1张

数据存储区域保存着数组中所有元素的二进制数据,dtype 对象则知道如何将元素的二进制数据转换为可用的值。数组的维数、大小等信息都保存在 ndarray 数组对象的数据结构中。图中显示的是如下数组的内存结构:

>>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32)
>>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32)

strides 中保存的是当每个轴的下标增加1时,数据存储区中的指针所增加的字节数。例如图中的 strides 为(12, 4),即第 0 轴的下标增加 1 时,数据的地址增加 12 个字节:即 a[1,0] 的地址比 a[0,0] 的地址要高12个字节,正好是3个单精度浮点数的总字节数;第1轴下标增加1时,数据的地址增加4个字节,正好是单精度浮点数的字节数。

如果 strides 中的数值正好和 对应轴元素 所占据的字节数相同的话,那么数据在内存中是连续存储的。然而数据并不一定都是连续储存的,前面介绍过通过下标范围得到新的数组是原始数组的视图,即它和原始视图共享数据存储区域:

>>> b = a[::2,::2]
>>> b
array([[ 0.,  2.],
       [ 6.,  8.]], dtype=float32)
>>> b.strides
(24, 8)
>>> b = a[::2,::2]
>>> b
array([[ 0.,  2.],
       [ 6.,  8.]], dtype=float32)
>>> b.strides
(24, 8)

由于数组 b 和数组 a 共享数据存储区,而 b 中的第0轴和第1轴都是数组a中隔一个元素取一个,因此数组 b 的 strides 变成了 (24,8),正好都是数组 a 的两倍。 对照前面的图很容易看出数据0和2的地址相差8个字节,而0和6的地址相差24个字节。

元素在数据存储区中的排列格式有两种:C 语言格式和 Fortan 语言格式。在C语言中,多维数组的第0轴是最上位的,即第0轴的下标增加1时,元素的地址增加的字节数最多;而Fortan语言的多维数组的第0轴是最下位的,即第0轴的下标增加1时,地址只增加一个元素的字节数。在 numpy 中,元素在内存中的排列缺省是以 C语言格式存储的,如果你希望改为Fortan格式的话,只需要给数组传递order="F"参数:

>>> c = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32, order="F")
>>> c.strides
(4, 12)
>>> c = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32, order="F")
>>> c.strides
(4, 12)



https://www.xamrdz.com/mobile/4up1925762.html

相关文章: