如何用NumPy数组模拟生成10位字长二进制文件的硬件？

嘿，这个需求我刚好折腾过，用NumPy来模拟生成这种非标准字长的二进制文件其实思路很清晰，我给你一步步说清楚：

1. 生成10位整数的NumPy数组 #

首先，10位无符号整数的范围是0到1023（也就是2^10 - 1）。NumPy没有原生的10位整数类型，但我们可以用uint16来存储这些值——它的16位宽度完全能容纳10位数据，而且后续做位操作也方便。

比如生成一组随机的10位整数：

import numpy as np

# 生成100个10位无符号整数（范围0~1023）
num_elements = 100
data = np.random.randint(0, 2**10, size=num_elements, dtype=np.uint16)

2. 将10位整数拼接成连续的二进制位流 #

这是核心步骤，因为标准的文件写入是按字节（8位）对齐的，而我们要的是每个字10位的连续位流。这里的关键是把多个10位的数拼接成字节块：

10和8的最小公倍数是40，也就是说每4个10位整数刚好能凑成5个字节（410=40=58），这样处理起来最方便。如果你的数据总数不是4的倍数，最后剩下的部分可以补零填充到下一个字节边界。

下面是实现位拼接的代码：

def pack_10bit_to_bytes(data):
    # 先把数据转换成uint64，方便做位操作（避免溢出）
    data_64 = data.astype(np.uint64)
    # 计算完整的4元素组数量
    full_groups = len(data) // 4
    # 处理完整的组：每4个10位数拼成5个字节
    packed = np.zeros(full_groups * 5, dtype=np.uint8)
    
    for i in range(full_groups):
        # 取出4个10位的数
        d0, d1, d2, d3 = data_64[i*4 : i*4+4]
        # 拼接成40位的整数
        combined = (d0 << 30) | (d1 << 20) | (d2 << 10) | d3
        # 拆分成5个字节（从高位到低位）
        packed[i*5] = (combined >> 32) & 0xFF
        packed[i*5+1] = (combined >> 24) & 0xFF
        packed[i*5+2] = (combined >> 16) & 0xFF
        packed[i*5+3] = (combined >> 8) & 0xFF
        packed[i*5+4] = combined & 0xFF
    
    # 处理剩余的元素（如果有的话）
    remainder = len(data) % 4
    if remainder > 0:
        rem_data = data_64[-remainder:]
        combined = 0
        for j in range(remainder):
            combined |= rem_data[j] << (10*(remainder - 1 - j))
        # 计算需要的字节数，向上取整
        rem_bytes = (remainder * 10 + 7) // 8
        rem_packed = np.zeros(rem_bytes, dtype=np.uint8)
        for k in range(rem_bytes):
            rem_packed[k] = (combined >> (8*(rem_bytes - 1 - k))) & 0xFF
        # 合并到结果里
        packed = np.concatenate([packed, rem_packed])
    
    return packed

3. 将位流写入二进制文件 #

拿到拼接好的字节数组后，直接用tofile方法写入文件就可以了：

packed_bytes = pack_10bit_to_bytes(data)
packed_bytes.tofile("10bit_data.bin")

额外说明：验证读取（可选） #

如果你需要验证生成的文件是否正确，可以写一个读取函数把二进制文件还原成10位整数数组：

def unpack_bytes_to_10bit(file_path):
    # 读取二进制文件
    packed = np.fromfile(file_path, dtype=np.uint8)
    total_bits = len(packed) * 8
    total_elements = total_bits // 10
    # 把字节转换成64位整数，方便位操作
    combined = np.zeros((len(packed) + 7) // 8, dtype=np.uint64)
    for i in range(len(packed)):
        combined[i//8] |= packed[i] << (8*(7 - i%8))
    
    data = np.zeros(total_elements, dtype=np.uint16)
    for i in range(total_elements):
        # 提取第i个10位的数（从高位到低位）
        shift = total_bits - 10*(i+1)
        data[i] = (combined[shift//64] >> (shift%64)) & 0x3FF  # 0x3FF是10位的掩码
    
    return data

# 验证：读取后和原数据对比（忽略最后补零的部分）
recovered_data = unpack_bytes_to_10bit("10bit_data.bin")
print(np.array_equal(data[:len(recovered_data)], recovered_data))  # 应该输出True

这里要注意的是，如果原数据数量不是4的倍数，最后补的零会被读取出来，所以验证的时候只需要对比前面有效部分即可。

内容的提问来源于stack exchange，提问作者Alex