How practical is the struct module? Learn a knowledge point immediately

Hey, everyone, good duck ！ I'm a panda

Today, let me tell you about a very practical python modular ( •̀ ω •́ )*

---

struct The module provides a string of bytes and Python Conversion functions between native data types , Such as numbers and strings .

The function of this module is to complete Python Sum of values C Of language structure Python Conversion between string forms .

This can be used to process binary data stored in files or from network connections , And other data sources .

---

what are you having? python I won't answer the related error report 、 Or source code information / Module installation / Women's clothing bosses are proficient in skills
You can come here ：（https://jq.qq.com/?_wv=1027&k=2Q3YTfym） perhaps +V：python10010 Ask me

1. Module functions and Struct class

In addition to providing a Struct Outside class ,

There are also many module level functions for dealing with structured values .

Here is a formatter (Format specifiers) The concept of ,

It refers to the conversion from string format to compiled representation ,

Similar to regular expression processing .

Usually instantiate Struct class ,

Call class methods to complete the transformation ,

It is much more effective than calling module functions directly .

The following examples all use Struct class .

2. Packing（ pack ） and Unpacking（ Unpack ）

Struct Support the transfer of data packing( pack ) String ,

And can reverse from the string unpacking( decompression ) Data .

In this case , Format specifier (specifier) Need an integer or long integer ,

A two byte string, And a floating point number .

Spaces in the formatter are used to separate indicators (indicators),

It will be ignored when compiling the format .

import struct
python Learning exchange group ：660193417###

import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
s = struct.Struct('I 2s f')
packed_data = s.pack(*values)

print(' Original value :', values)
print(' Format symbol :', s.format)
print(' Occupied bytes :', s.size)
print(' Packing results :', binascii.hexlify(packed_data))

# output
 Original value : (1, b'ab', 2.7)
 Format symbol : b'I 2s f'
 Occupied bytes : 12
 Packing results : b'0100000061620000cdcc2c40'

This example converts the packed value into a hexadecimal byte sequence ,

use binascii.hexlify() Method print out .

Use unpack() How to unpack .

import struct
import binascii

packed_data = binascii.unhexlify(b'0100000061620000cdcc2c40')

s = struct.Struct('I 2s f')
unpacked_data = s.unpack(packed_data)
print(' Unpacking results :', unpacked_data)

# output
 Unpacking results : (1, b'ab', 2.700000047683716)

Pass the packed value to unpack(), Basically return the same value ( Floating point numbers will vary ).

3. Byte order / size / alignment

By default ,pack It's using local C The byte order of the Library .

The first character of the format string can be used to indicate the byte order of the fill data 、 Size and alignment , The following table describes :

If these are not set in the formatter , Then the default will be @.

Local byte order means that the byte order is determined by the current host system .

such as ：Intel x86 and AMD64(x86-64) Use small byte order ;

Motorola 68000 and PowerPC G5 Use large byte order .

ARM and Intel Itanium supports switching byte order .

have access to sys.byteorder Check the byte order of the current system .

Local size (Size) And alignment (Alignment) By c Compiler sizeof The expression determines . It corresponds to the local byte order .

The standard size is determined by the formatter , Next, we will talk about the standard sizes of various formats .

Example :

import struct
import binascii

values = (1, 'ab'.encode('utf-8'), 2.7)
print(' Original value   : ', values)

endianness = [
    ('@', 'native, native'),
    ('=', 'native, standard'),
    ('<', 'little-endian'),
    ('>', 'big-endian'),
    ('!', 'network'),
]

for code, name in endianness:
    s = struct.Struct(code + ' I 2s f')
    packed_data = s.pack(*values)
    print()
    print(' Format symbol   : ', s.format, 'for', name)
    print(' Occupied bytes : ', s.size)
    print(' Packing results : ', binascii.hexlify(packed_data))
    print(' Unpacking results : ', s.unpack(packed_data))

# output
 Original value   :  (1, b'ab', 2.7)

 Format symbol   :  b'@ I 2s f' for native, native
 Occupied bytes :  12
 Packing results :  b'0100000061620000cdcc2c40'
 Unpacking results :  (1, b'ab', 2.700000047683716)

 Format symbol   :  b'= I 2s f' for native, standard
 Occupied bytes :  10
 Packing results :  b'010000006162cdcc2c40'
 Unpacking results :  (1, b'ab', 2.700000047683716)

 Format symbol   :  b'< I 2s f' for little-endian
 Occupied bytes :  10
 Packing results :  b'010000006162cdcc2c40'
 Unpacking results :  (1, b'ab', 2.700000047683716)

 Format symbol   :  b'> I 2s f' for big-endian
 Occupied bytes :  10
 Packing results :  b'000000016162402ccccd'
 Unpacking results :  (1, b'ab', 2.700000047683716)

 Format symbol   :  b'! I 2s f' for network
 Occupied bytes :  10
 Packing results :  b'000000016162402ccccd'
 Unpacking results :  (1, b'ab', 2.700000047683716)

4. Format symbol

The comparison table of format characters is as follows :

5. buffer

Packaging data into binary is usually used in scenarios that require high performance .

In such scenarios, it can be optimized by avoiding the overhead of allocating new buffers for each packaging structure .

pack_into() and unpack_from() Method supports writing directly to the pre allocated buffer .

---

That's all for today's knowledge , I hope this article can help you ~

I'm a panda , See you in the next article (*◡‿◡)