struct模块 — 字节数据打包解包

Python标准库精讲专题 · 加密与编码篇 · 掌握二进制数据操作

专题：Python标准库精讲系统学习

关键词：Python, 标准库, struct, 打包, 解包, pack, unpack, 二进制, 字节序, calcsize, 格式字符串

一、struct模块概述

struct是Python标准库中用于在Python值与C语言结构体之间进行二进制数据转换的核心模块。在网络编程、文件格式解析、硬件通信等底层开发场景中，数据通常以紧凑的二进制格式传输和存储，struct模块提供了将这些原始字节序列与Python整数、浮点数、字节串等数据类型互相转换的能力。

该模块的核心定位可以概括为三个层面：第一，数据打包（Pack），将Python值序列按照指定的格式编码为字节对象；第二，数据解包（Unpack），从字节对象中按照指定格式解析出Python值元组；第三，大小计算（Calcsize），计算特定格式字符串对应的字节长度。这三个操作覆盖了绝大多数二进制数据处理需求。

struct的设计灵感来源于C语言的结构体（struct）定义。当Python程序需要与C语言编写的动态链接库交互、解析网络协议报文、读写二进制文件（如BMP、PNG、WAV等）时，struct往往是首选的工具。它使得Python这种高级语言能够精确控制内存中数据的二进制布局，弥补了高级语言在底层操作上的不足。

与第三方库如construct或bitstring相比，struct的优势在于其零依赖性和极高的执行效率。它是Python的内置模块，开箱即用，底层由C语言实现，性能远优于纯Python方案。其局限性在于格式描述能力相对基础——不支持位域（bit-field）、可变长度编码、条件定义等高级特性，但这也正是其简洁和高效的来源。

使用struct模块的基本模式非常直观：开发者定义一个格式字符串（format string）来描述二进制数据的布局，然后调用对应的函数进行转换。格式字符串的语法虽然简洁，但功能强大——它同时编码了字节序（endianness）、数据类型和对齐方式三方面的信息。

import struct

# 基本使用模式：pack打包 -> bytes，unpack解包 -> tuple
data = struct.pack('>I4s', 42, b'test')
# data = b'\x00\x00\x00*test' (大端序4字节无符号整数 + 4字节字符串)

values = struct.unpack('>I4s', data)
# values = (42, b'test')

二、字节序与对齐

字节序（Endianness）是多字节数据在内存中的排列方式，是二进制数据处理中最容易出错的问题之一。struct模块通过在格式字符串的开头使用特定的前缀字符来指定字节序和对齐规则，从根本上解决了跨平台二进制数据交换的兼容性问题。

2.1 字节序前缀

struct支持五种字节序和对齐模式，每种模式对应一个前缀字符。这些前缀决定了格式字符串后续所有字段的字节排列方式和内存对齐规则。

前缀	字节序	对齐方式	说明
@	本机字节序	本机对齐	默认模式，与C编译器的struct布局一致
=	本机字节序	标准对齐	使用本机字节序但不对齐，没有填充字节
<	小端序	标准对齐	低位字节在低地址（Little-Endian）
>	大端序	标准对齐	高位字节在低地址（Big-Endian），也称网络字节序
!	网络序(=大端)	标准对齐	专用于网络协议，等同于>

2.2 大端序与小端序详解

小端序（Little-Endian）的特点是"低位在前"，即数据的最低有效字节（Least Significant Byte）存储在最低内存地址。这种布局更符合CPU的加法器工作方式，是现代主流处理器（x86、x86-64）采用的模式。例如十六进制值0x12345678在小端序内存中从低地址到高地址依次为：78 56 34 12。

大端序（Big-Endian）的特点是"高位在前"，即数据的最高有效字节（Most Significant Byte）存储在最低内存地址。这种布局更符合人类的阅读习惯，因而是网络协议（TCP/IP、HTTP等）的标准字节序，故又称"网络字节序"。同样的0x12345678在大端序中从低地址到高地址依次为：12 34 56 78。

在网络编程中，ntohl()和htonl()等函数的作用正是进行本机字节序和网络字节序之间的转换。struct模块通过统一的格式字符串语法封装了这一过程，开发者只需在格式串开头指定前缀，即可自动完成转换，无需手动处理字节翻转。

2.3 对齐规则与填充字节

对齐（Alignment）是CPU访问内存时的硬件约束——处理器通常要求特定类型的数据存储在地址为类型大小的整数倍的位置。例如4字节整数必须从4的倍数的地址开始读取，否则会导致性能下降甚至总线错误。

当格式字符串使用@前缀（本机对齐）时，struct会按照C编译器的规则在字段之间自动插入填充字节（padding bytes），确保每个字段的起始偏移量满足对齐要求。而标准对齐模式（= < > !）则不会插入填充字节，所有字段紧密排列。这一差异在实际使用中极为重要——不匹配的对齐规则是导致二进制数据解析错误的常见原因。

例如，格式串'@Ib'（本机对齐）表示一个4字节无符号整数后跟一个char。在大字节序本机对齐下，整数占偏移0-3，char占偏移4，总计5字节。但换成'=Ib'（标准对齐）时，如果使用大端序，整数从偏移0开始，char从偏移4开始，结构同样紧凑排列。差异在于后者不会有尾部填充。

import struct

# 本机对齐（@）可能自动插入填充字节
print(struct.calcsize('@I'))  # 输出: 4 (取决于平台，本机字节序int为4字节)
print(struct.calcsize('@b'))  # 输出: 1
print(struct.calcsize('@Ib')) # 输出: 5 (无填充)

# 标准对齐（=）紧密排列，无填充
print(struct.calcsize('>Ib'))  # 输出: 5

核心要点：在跨平台或网络编程中始终显式指定字节序前缀（推荐使用>或<），避免依赖默认的@本机字节序。本机对齐可能导致不同平台解析结果不一致，而网络协议通常固定使用大端序。

三、格式字符串 — 完整格式字符表

格式字符串是struct模块的核心语言。它由一个可选的字节序前缀和一组格式字符组成，每个格式字符对应一种C数据类型，并指定其在二进制中的字节长度和解释方式。理解每个格式字符的精确含义是正确使用struct的基础。

格式字符分为整数类型、浮点类型、字节/字符类型三大类。整数类型还可细分为有符号和无符号、标准大小和平台相关大小。格式字符中的标准大小（Standard Size）是指在使用= < > !前缀时，该类型的字节长度在各平台上保持一致，这对跨平台数据交换至关重要。

3.1 整数类型格式字符

格式字符	C类型	Python类型	标准大小(字节)	说明
x	填充字节	无	1	占位用，跳过对应字节不读写
b	signed char	int	1	有符号单字节整数，范围-128~127
B	unsigned char	int	1	无符号单字节整数，范围0~255
?	_Bool	bool	1	布尔值，0为False，非0为True
h	short	int	2	有符号短整数
H	unsigned short	int	2	无符号短整数
i	int	int	4	有符号整数，最常用的格式之一
I	unsigned int	int	4	无符号整数
l	long	int	4(Windows)或8	有符号长整数，平台相关
L	unsigned long	int	同上	无符号长整数
q	long long	int	8	有符号64位整数
Q	unsigned long long	int	8	无符号64位整数
n	ssize_t	int	平台相关	仅用于@本机对齐模式，存储指针宽度的有符号整数
N	size_t	int	平台相关	仅用于@本机对齐模式，存储指针宽度的无符号整数

3.2 浮点类型格式字符

格式字符	C类型	Python类型	标准大小(字节)	说明
e	无对应C类型	float	2	半精度浮点数（IEEE 754 binary16）
f	float	float	4	单精度浮点数（IEEE 754 binary32）
d	double	float	8	双精度浮点数（IEEE 754 binary64），科学计算常用

3.3 字节与字符串格式字符

格式字符	C类型	Python类型	说明
s	char[]	bytes	定长字节串。打包时如果输入过短自动填充\x00，过长则截断；解包时精确返回指定长度的bytes
p	char[] (Pascal风格)	bytes	Pascal字符串。第1个字节存储长度（0~255），后续最多255个字节为内容。打包时自动计算长度，解包时只返回实际内容（不含长度字节）
c	char	bytes of length 1	单字节字符，等价于长度为1的s格式

关键提醒：格式字符前的数字表示重复计数，而非字节大小。例如'16s'表示长度为16字节的字符串，'4I'表示4个无符号整数（共16字节）。计数为0时表示该类型占0字节（类似空占位）。格式字符串中空格和制表符会被忽略，可用于提高长格式串的可读性。

3.4 格式字符串编写实战示例

import struct

# 格式字符串的组成： [字节序前缀] + [计数][格式字符] + ...

# 解析一个典型的文件头: 2字节magic + 4字节长度 + 2字节类型 + 16字节名称
header_fmt = '>HHI16s'
print(struct.calcsize(header_fmt))  # 输出: 24 (2+4+2+16)

# 打包
packed = struct.pack(header_fmt, 0x4D42, 1024, 1, b'header_data')

# 解包
magic, length, typ, name = struct.unpack(header_fmt, packed)
print(hex(magic), length, typ, name)
# 输出: 0x4d42 1024 1 b'header_data\x00\x00\x00\x00\x00'

# 使用计数重复: 5个无符号短整数
print(struct.pack('>5H', 1, 2, 3, 4, 5).hex())
# 输出: 00010002000300040005

四、核心函数详解

struct模块提供了四个核心函数和一个辅助函数，覆盖了常见的二进制数据操作场景。这些函数均以格式字符串作为第一个参数，体现了"格式驱动"的设计思想——开发者只需要描述数据布局，模块自动处理底层字节操作。

4.1 pack(format, v1, v2, ...) — 打包为字节流

pack()将Python值序列按照格式字符串编码为字节对象。每个参数必须与对应的格式字符的类型和大小匹配；参数数量必须与格式字符串中非填充（非x）格式字符的数量一致。如果传入的值超出格式字符所能表示的范围，会触发struct.error。

import struct

# 基本打包
packed = struct.pack('<I4s', 256, b'data')
# packed = b'\x00\x01\x00\x00data' (小端序)

# 浮点数打包
packed_f = struct.pack('>2f', 3.14, 2.718)
# packed_f = b'\x40\x48\xf5\xc3\x40\x2d\xf8\xcd'

# 混合类型打包
packed_mixed = struct.pack('>bHIf', -1, 65535, 100000, 1.5)
print(packed_mixed.hex())
# 输出: ff ffff 000186a0 3fc00000

4.2 unpack(format, buffer) — 解包为元组

unpack()是pack()的逆操作，从字节对象中解析出Python值元组。缓冲区大小必须严格等于calcsize(format)，否则抛出struct.error: unpack requires a buffer of X bytes。

import struct

# 基本解包
data = b'\x00\x01\x00\x00data'
num, s = struct.unpack('<I4s', data)
print(num, s)  # 输出: 256 b'data'

# 解包时自动转换字节序
data_be = struct.pack('>I', 258)  # 大端序打包
value = struct.unpack('>I', data_be)[0]
print(value)  # 输出: 258 ✓

# 如果以小端序解包大端序数据，结果错误
wrong = struct.unpack('<I', data_be)[0]
print(wrong)  # 输出: 1006632968 ✗ (字节序不匹配)

经验之谈：unpack始终返回元组，即使只有一个字段。如果确定只需第一个值，可使用struct.unpack('>I', data)[0]解包。Python 3.10+提供了struct.unpack_one()函数，可以直接返回单个值而非元组，但使用范围较窄。

4.3 pack_into(format, buffer, offset, v1, v2, ...) — 写入缓冲区

pack_into()将打包后的数据写入一个可写缓冲区（实现了缓冲区协议的对象，如bytearray、array.array、memoryview等）的指定偏移位置。与pack()不同，它不会创建新的字节对象，而是直接修改已有缓冲区，适用于需要构建大型二进制数据块的场景，避免了多次内存分配的开销。

import struct

# 创建一个容量足够的bytearray
buf = bytearray(16)

# 从偏移0写入整数
struct.pack_into('>I', buf, 0, 0xDEADBEEF)

# 从偏移4写入浮点数
struct.pack_into('>d', buf, 4, 3.141592653589793)

# 查看十六进制表示
print(buf.hex())
# 输出: deadbeef400921f5442d18...

# 构建网络协议报文头部
header = bytearray(20)  # TCP/IP头部长度
struct.pack_into('>HH', header, 0, 0x0800, 64)  # 以太网类型 + 包头长度
struct.pack_into('>II', header, 4, 0xC0A80001, 0xC0A80064)  # 源IP + 目标IP

4.4 unpack_from(format, buffer, offset=0) — 从缓冲区解包

unpack_from()从可读缓冲区的指定偏移位置开始解包，而无需对整个缓冲区进行切片。这一特性在解析复合二进制格式（如网络数据包、文件格式头部等）时极为有用——开发者可以定义不同偏移位置的字段，依次解包而不需要手动管理切片索引。

import struct

# 模拟从网络套接字接收到的数据包
packet = (
    struct.pack('>HBH', 0x1234, 8, 0x56) +  # 头部: 魔数 + 负载类型 + 长度
    struct.pack('>ii', -100, 200) +       # 负载: 两个有符号整数
    struct.pack('>I', 0xFFFFFFFF)          # 尾部: 校验和
)

# 使用 unpack_from 逐步解析，避免手动切片
magic, ptype, plen = struct.unpack_from('>HBH', packet, 0)
print(f'魔数: {hex(magic)}, 类型: {ptype}, 负载长度: {plen}')

# 假设负载开始位置在偏移5处 (3 + 2)
load1, load2 = struct.unpack_from('>ii', packet, 4)
print(f'负载值: {load1}, {load2}')

# 校验和在偏移12处
checksum = struct.unpack_from('>I', packet, 12)[0]
print(f'校验和: {hex(checksum)}')

4.5 calcsize(format) — 计算格式大小

calcsize()返回格式字符串对应的字节大小。这个函数虽然没有直接的数据转换功能，但在实际开发中必不可少——它用于验证预期大小、分配缓冲区、解析复合结构体以及进行断言检查。由于该函数完全基于格式字符串计算，不会检查实际数据内容，因此可以安全地用于预检。

import struct

# 验证格式串大小
fmt = '>HHI32sQ'
expected = struct.calcsize(fmt)
print(f'结构体预期大小: {expected} 字节')  # 输出: 48 (2+4+2+32+8)

# 用于断言检查接收到的数据长度
data = b'\x00' * expected
assert len(data) == struct.calcsize(fmt), '数据长度不匹配'

# 在打包前预分配缓冲区
buf = bytearray(struct.calcsize(fmt))

五、Struct类 — 编译格式字符串提升性能

当需要在循环中反复使用相同的格式字符串执行打包/解包操作时，每次调用struct.pack()都会重新解析格式字符串，造成不必要的性能开销。struct模块提供了Struct类来优化这一场景——它预先编译格式字符串，将解析结果缓存起来，后续调用直接使用编译后的格式信息，显著提升批量操作的性能。

Struct类的设计体现了"编译一次，多次运行"的优化思路。其内部结构包含了格式字符串的详细解析结果，包括每个字段的类型、偏移量、大小和字节序信息。所有核心操作（pack()、unpack()、pack_into()、unpack_from()、calcsize()）都作为Struct实例的方法提供，调用签名与模块级函数完全一致，只是不需要再传入格式字符串参数。

import struct

# 不推荐: 循环中重复传递格式字符串
values = [(1, 2.5, b'A'), (2, 3.6, b'B'), (3, 4.7, b'C')]
packed_list = []
for a, b, c in values:
    packed_list.append(struct.pack('>Ifc', a, b, c))
# 每次循环都重新解析 '>Ifc'

# 推荐: 使用Struct类预编译格式字符串
compiled = struct.Struct('>Ifc')
packed_list2 = []
for a, b, c in values:
    packed_list2.append(compiled.pack(a, b, c))
# 格式字符串只解析一次，后续直接使用编译结果

print(f'结构体大小: {compiled.size}')  # 直接访问，无需调用calcsize
# 输出: 结构体大小: 7

5.1 Struct属性与方法速查

属性/方法	说明
`Struct.format`	格式字符串原文，只读属性
`Struct.size`	结构体字节大小，等价于`calcsize(format)`，只读属性
`Struct.pack(v1, v2, ...)`	打包为bytes，等价于模块级`pack()`
`Struct.unpack(buffer)`	解包为元组，等价于模块级`unpack()`
`Struct.pack_into(buffer, offset, v1, v2, ...)`	写入缓冲区，等价于模块级`pack_into()`
`Struct.unpack_from(buffer, offset=0)`	从缓冲区解包，等价于模块级`unpack_from()`
`Struct.iter_unpack(buffer)`	从缓冲区迭代解包多个相同结构的数据块

5.2 iter_unpack — 批量解包利器

iter_unpack()是Struct类独有的方法，用于从大型缓冲区中连续解包多个相同结构的数据块。它返回一个生成器，每次迭代解包一个结构体，直到缓冲区末尾。这在处理批量记录（如传感器数据日志、数据库页数据、二进制文件中的重复记录）时极为高效。

import struct

# 模拟1000条传感器记录: 时间戳(uint32) + 温度(float) + 湿度(float)
record_fmt = struct.Struct('>Iff')
print(f'每条记录大小: {record_fmt.size} 字节')  # 输出: 12

# 生成模拟数据
raw_data = b''.join(
    record_fmt.pack(1000 + i, 20.0 + i * 0.1, 50.0 + i * 0.5)
    for i in range(1000)
)

# 使用 iter_unpack 高效迭代解析
for timestamp, temperature, humidity in record_fmt.iter_unpack(raw_data):
    if temperature > 100.0:
        print(f'警报! 时间戳={timestamp}, 温度={temperature:.1f}°C')
        break

性能对比：对100万条记录进行解包操作时，使用Struct类比每次传递格式字符串快约30%~50%。在需要处理海量二进制数据的场景中（如解析PCAP网络数据包、读取大型二进制文件），预编译Struct对象是最佳实践。

六、实战案例

理论知识最终需要应用到实际问题中。本节通过两个典型的生产级案例，展示struct模块在真实项目中的使用方式。

6.1 BMP文件头解析

BMP（Bitmap）是Windows平台最基础的图像格式之一，其文件结构简单规整，非常适合作为学习二进制文件解析的入门口。BMP文件由文件头（BITMAPFILEHEADER，14字节）和信息头（BITMAPINFOHEADER，40字节）两部分组成，两者都可以用struct格式字符串精确描述。

import struct

# BMP文件头格式 (所有字段均为小端序)
# BITMAPFILEHEADER (14字节)
#   bfType      (2字节)  — 魔数 'BM'
#   bfSize      (4字节)  — 文件总大小
#   bfReserved1 (2字节)  — 保留
#   bfReserved2 (2字节)  — 保留
#   bfOffBits   (4字节)  — 像素数据偏移
FILE_HEADER_FMT = '<2sIHHi'  # 注意: H(2) + I(4) + H(2) + H(2) + i(4) = 14

# 信息头格式 (40字节)
# BITMAPINFOHEADER:
#   biSize          (4)  — 本结构体大小(=40)
#   biWidth         (4)  — 图像宽度(像素)
#   biHeight        (4)  — 图像高度(像素)
#   biPlanes        (2)  — 颜色平面数(=1)
#   biBitCount      (2)  — 每像素位数(1/4/8/16/24/32)
#   biCompression   (4)  — 压缩类型
#   biSizeImage     (4)  — 图像数据大小
#   biXPelsPerMeter (4)  — 水平分辨率
#   biYPelsPerMeter (4)  — 垂直分辨率
#   biClrUsed       (4)  — 调色板颜色数
#   biClrImportant  (4)  — 重要颜色数
INFO_HEADER_FMT = '<IiiHHIIiiII'

def parse_bmp(filepath):
    with open(filepath, 'rb') as f:
        data = f.read()

    # 解析文件头
    magic, file_size, _, _, pixel_offset = struct.unpack_from(FILE_HEADER_FMT, data, 0)
    if magic != b'BM':
        raise ValueError('不是有效的BMP文件')

    # 解析信息头
    (hdr_size, width, height, planes, bit_count, compression,
     img_size, x_ppm, y_ppm, clr_used, clr_important) = \
        struct.unpack_from(INFO_HEADER_FMT, data, 14)

    return {
        '文件大小': file_size,
        '宽度': width,
        '高度': height,
        '位深度': bit_count,
        '压缩方式': compression,
        '像素偏移': pixel_offset,
        '图像数据大小': img_size,
    }

# 使用示例 (假设存在test.bmp)
# info = parse_bmp('test.bmp')
# for k, v in info.items():
#     print(f'{k}: {v}')

6.2 TCP数据包头部解析实战

网络协议是struct最经典的应用领域之一。TCP协议头的结构在RFC 793中有明确定义，共20字节（不含选项字段），包含源端口、目的端口、序列号、确认号、标志位等重要信息。使用struct可以精确提取所有字段。

import struct

# TCP头部格式 (大端序网络字节序)
#   src_port     (2) — 源端口
#   dst_port     (2) — 目的端口
#   seq_num      (4) — 序列号
#   ack_num      (4) — 确认号
#   data_offset  (1) — 数据偏移(高4位) + 保留(低4位)
#   flags        (1) — 标志位(URG/ACK/PSH/RST/SYN/FIN)
#   window       (2) — 窗口大小
#   checksum     (2) — 校验和
#   urgent_ptr   (2) — 紧急指针
TCP_HEADER_FMT = '>HHIIBBHHH'
print(f'TCP头部固定部分大小: {struct.calcsize(TCP_HEADER_FMT)} 字节')
# 输出: 20

def parse_tcp_header(packet, offset=0):
    unpacked = struct.unpack_from(TCP_HEADER_FMT, packet, offset)
    src_port, dst_port, seq, ack, data_offset_flags, flags, window, checksum, urg_ptr = unpacked

    # data_offset高4位表示头部长度(单位4字节)
    hdr_len = (data_offset_flags >> 4) * 4

    return {
        '源端口': src_port,
        '目的端口': dst_port,
        '序列号': seq,
        '确认号': ack,
        '头部长度': hdr_len,
        '标志位': {
            'URG': bool(flags & 0x20),
            'ACK': bool(flags & 0x10),
            'PSH': bool(flags & 0x08),
            'RST': bool(flags & 0x04),
            'SYN': bool(flags & 0x02),
            'FIN': bool(flags & 0x01),
        },
        '窗口大小': window,
        '校验和': checksum,
    }

# 模拟解析
simulated_tcp = struct.pack(TCP_HEADER_FMT,
    443,     # 源端口 (HTTPS)
    54321,   # 目的端口
    1000,    # 序列号
    500,     # 确认号
    0x50,    # data_offset=5 (5*4=20字节头部) 保留=0
    0x12,    # SYN+ACK
    65535,   # 窗口大小
    0,       # 校验和 (实际应为正确计算结果)
    0        # 紧急指针
)

result = parse_tcp_header(simulated_tcp)
print(f'连接: {result["源端口"]} → {result["目的端口"]}')
print(f'标志: {result["标志位"]}')
print(f'窗口: {result["窗口大小"]}')

进阶提示：在生产级网络分析工具（如Scapy、dpkt）中，struct是底层解析引擎的核心依赖。理解struct的用法不仅有助于直接处理二进制数据，更是理解这些高级工具内部工作原理的基础。在解析复合协议时，通常的做法是先用struct提取固定长度的头部，再根据头部中的字段值动态解析变长负载。

七、核心总结

7.1 知识体系总览

struct模块围绕"格式字符串"这一核心抽象，提供了一套简洁而强大的二进制数据转换框架。其知识体系可以分为三个层次：底层是字节序和内存对齐规则，中间层是格式字符串语法和格式字符表，上层是四个核心函数和Struct类。理解这三个层次的递进关系，是掌握struct模块的关键。

7.2 关键最佳实践

始终显式指定字节序：不要依赖@默认值，在网络编程中使用>（大端序），在x86平台本地文件格式中使用<（小端序），在解析已知字节序的第三方数据时按规范选择。显式指定让代码意图清晰，也避免了跨平台移植时的隐晦bug。
善用Struct类提升性能：在循环或批量处理场景中，将格式字符串编译为Struct对象可节省约30%至50%的执行时间。对于处理百万级记录的应用，这一优化常常是性能瓶颈的关键解。
验证数据长度：在调用unpack()之前使用calcsize()验证缓冲区大小，可以有效避免运行时错误。在解析外部数据时，这一检查也是安全性的第一道防线。
优先使用unpack_from：在解析复合二进制结构时，unpack_from()比手动切片更安全、更高效。它可以避免创建中间切片对象，减少内存分配，同时让代码更具可读性。
注意标准大小与平台大小的差异：i/I/l/L等类型在@模式下大小取决于平台，在=<>!模式下使用标准大小。跨平台数据交换时务必使用标准大小的格式字符。

7.3 常见陷阱与注意事项

字节序错误：最常见的struct使用错误。记住：你看到的十六进制字节顺序是打印顺序，而不是内存顺序。
对齐填充：@模式下的自动填充可能导致意料之外的字节偏移。如果调试发现解析结果错位，首先检查是否为对齐填充所致。
字符串长度：s格式必须指定长度（如4s、32s），否则默认为1s。打包时字符串过短会自动补\x00，过长则截断。
整数溢出：当Python整数超出格式字符能表示的范围时（如用h存储大于32767的值），会抛出struct.error。使用前需确认数值范围。
缓冲区溢出：pack_into不会自动扩展缓冲区大小，确保目标缓冲区有足够容量，否则可能导致内存访问错误。

7.4 应用场景速查

应用场景	推荐方案	说明
简单数据结构打包	struct.pack()	快速将少数Python值转为字节
二进制文件解析	Struct + unpack_from	预先编译格式，支持偏移解析
网络协议处理	Struct + unpack_from	大端序(>)，分步解析头部和负载
批量记录解析	Struct.iter_unpack()	高效迭代相同结构的记录块
构建大型二进制数据	bytearray + pack_into	预分配缓冲区，避免多次内存分配
与C语言交互(ctypes)	配合ctypes.Structure	struct定义数据结构，ctypes描述布局
高性能场景	Struct类预编译	格式字符串只解析一次，大幅减少开销

倪海厦式比喻：struct模块就像是二进制世界的"翻译官"——它让Python这门高级语言能够和底层系统说同样的语言。如果说Python是文人墨客的优雅辞章，struct就是能把辞章一字不差刻在甲骨上的工匠。没有它，Python就永远是空中楼阁，无法触及硬件和网络的底层世界。学会struct，你就掌握了打通Python上下限的关键钥匙。