浅析Python中的struct模块

时间 2019-12-11

原文原文链接

最近在学习python网络编程这一块，在写简单的socket通讯代码时，遇到了struct这个模块的使用，当时不太清楚这到底有和做用，后来查阅了相关资料大概了解了，在这里作一下简单的总结。python

了解c语言的人，必定会知道struct结构体在c语言中的做用，它定义了一种结构，里面包含不一样类型的数据(int,char,bool等等)，方便对某一结构对象进行处理。而在网络通讯当中，大多传递的数据是以二进制流（binary data）存在的。当传递字符串时，没必要担忧太多的问题，而当传递诸如int、char之类的基本数据的时候，就须要有一种机制将某些特定的结构体类型打包成二进制流的字符串而后再网络传输，而接收端也应该能够经过某种机制进行解包还原出原始的结构体数据。python中的struct模块就提供了这样的机制，该模块的主要做用就是对python基本类型值与用python字符串格式表示的C struct类型间的转化（This module performs conversions between Python values and C structs represented as Python strings.）。stuct模块提供了很简单的几个函数，下面写几个例子。编程

一、基本的pack和unpackapi

struct提供用format specifier方式对数据进行打包和解包（Packing and Unpacking）。例如:网络

 
        import  
        struct 
       
        import  
        binascii 
       
        values  
        =  
        ( 
        1 
        ,  
        'abc' 
        ,  
        2.7 
        ) 
       
        s  
        =  
        struct.Struct( 
        'I3sf' 
        ) 
       
        packed_data  
        =  
        s.pack( 
        * 
        values) 
       
        unpacked_data  
        =  
        s.unpack(packed_data) 
       
        print  
        'Original values:' 
        , values 
       
        print  
        'Format string :' 
        , s. 
        format 
       
        print  
        'Uses :' 
        , s.size,  
        'bytes' 
       
        print  
        'Packed Value :' 
        , binascii.hexlify(packed_data) 
       
        print  
        'Unpacked Type :' 
        ,  
        type 
        (unpacked_data),  
        ' Value:' 
        , unpacked_data

输出：socket

Original values: (1, 'abc', 2.7)
Format string : I3sf
Uses : 12 bytes
Packed Value : 0100000061626300cdcc2c40
Unpacked Type : <type 'tuple'> Value: (1, 'abc', 2.700000047683716)函数

代码中，首先定义了一个元组数据，包含int、string、float三种数据类型，而后定义了struct对象，并制定了format‘I3sf’，I 表示int，3s表示三个字符长度的字符串，f 表示 float。最后经过struct的pack和unpack进行打包和解包。经过输出结果能够发现，value被pack以后，转化为了一段二进制字节串，而unpack能够把该字节串再转换回一个元组，可是值得注意的是对于float的精度发生了改变，这是由一些好比操做系统等客观因素所决定的。打包以后的数据所占用的字节数与C语言中的struct十分类似。定义format能够参照官方api提供的对照表：性能

二、字节顺序学习

另外一方面，打包的后的字节顺序默认上是由操做系统的决定的，固然struct模块也提供了自定义字节顺序的功能，能够指定大端存储、小端存储等特定的字节顺序，对于底层通讯的字节顺序是十分重要的，不一样的字节顺序和存储方式也会致使字节大小的不一样。在format字符串前面加上特定的符号便可以表示不一样的字节顺序存储方式，例如采用小端存储 s = struct.Struct(‘<I3sf’)就能够了。官方api library 也提供了相应的对照列表：spa

三、利用buffer，使用pack_into和unpack_from方法操作系统

使用二进制打包数据的场景大部分都是对性能要求比较高的使用环境。而在上面提到的pack方法都是对输入数据进行操做后从新建立了一个内存空间用于返回，也就是说咱们每次pack都会在内存中分配出相应的内存资源，这有时是一种很大的性能浪费。struct模块还提供了pack_into() 和 unpack_from()的方法用来解决这样的问题，也就是对一个已经提早分配好的buffer进行字节的填充，而不会每次都产生一个新对象对字节进行存储。

 
        import  
        struct 
       
        import  
        binascii 
       
        import  
        ctypes 
       
        values  
        =  
        ( 
        1 
        ,  
        'abc' 
        ,  
        2.7 
        ) 
       
        s  
        =  
        struct.Struct( 
        'I3sf' 
        ) 
       
        prebuffer  
        =  
        ctypes.create_string_buffer(s.size) 
       
        print  
        'Before :' 
        ,binascii.hexlify(prebuffer) 
       
        s.pack_into(prebuffer, 
        0 
        , 
        * 
        values) 
       
        print  
        'After pack:' 
        ,binascii.hexlify(prebuffer) 
       
        unpacked  
        =  
        s.unpack_from(prebuffer, 
        0 
        ) 
       
        print  
        'After unpack:' 
        ,unpacked

输出：

Before : 000000000000000000000000
After pack: 0100000061626300cdcc2c40
After unpack: (1, 'abc', 2.700000047683716)
对比使用pack方法打包，pack_into 方法一直是在对prebuffer对象进行操做，没有产生多余的内存浪费。另外须要注意的一点是，pack_into和unpack_from方法均是对string buffer对象进行操做，并提供了offset参数，用户能够经过指定相应的offset，使相应的处理变得更加灵活。例如，咱们能够把多个对象pack到一个buffer里面，而后经过指定不一样的offset进行unpack：

 
        import  
        struct 
       
        import  
        binascii 
       
        import  
        ctypes 
       
        values1  
        =  
        ( 
        1 
        ,  
        'abc' 
        ,  
        2.7 
        ) 
       
        values2  
        =  
        ( 
        'defg' 
        , 
        101 
        ) 
       
        s1  
        =  
        struct.Struct( 
        'I3sf' 
        ) 
       
        s2  
        =  
        struct.Struct( 
        '4sI' 
        ) 
       
        prebuffer  
        =  
        ctypes.create_string_buffer(s1.size 
        + 
        s2.size) 
       
        print  
        'Before :' 
        ,binascii.hexlify(prebuffer) 
       
        s1.pack_into(prebuffer, 
        0 
        , 
        * 
        values1) 
       
        s2.pack_into(prebuffer,s1.size, 
        * 
        values2) 
       
        print  
        'After pack:' 
        ,binascii.hexlify(prebuffer) 
       
        print  
        s1.unpack_from(prebuffer, 
        0 
        ) 
       
        print  
        s2.unpack_from(prebuffer,s1.size)

输出：

Before : 0000000000000000000000000000000000000000 After pack: 0100000061626300cdcc2c406465666765000000 (1, 'abc', 2.700000047683716) ('defg', 101)