Python：如何优雅处理非2倍数长度二进制数据并高效访问任意位

太懂这种感受了——当byte数组变成长度20的大块时，手动写一堆移位、掩码、切片的代码，不仅写的时候要反复数位数，过几天再看自己都不知道哪段对应哪部分，完全是维护噩梦。而且struct确实帮不上忙，它只擅长处理整字节或者2^n位的字段，任意长度的位段得自己搞个靠谱的工具。

我推荐封装一个轻量的位访问类，用它来统一处理任意起始位置、任意长度的位提取，既保证性能，又让代码直观易读。核心思路是通过计算起始字节和偏移位，用位运算直接提取目标位段，避免冗余操作：

class BitAccessor:
    def __init__(self, byte_data: bytearray):
        self.byte_data = byte_data
        self.total_bits = len(byte_data) * 8

    def get_bits(self, start_bit: int, bit_length: int) -> int:
        # 边界检查
        if start_bit < 0 or bit_length < 0:
            raise ValueError("Start bit and bit length must be non-negative")
        if start_bit + bit_length > self.total_bits:
            raise ValueError("Requested bits exceed the length of the byte array")
        if bit_length == 0:
            return 0

        start_byte = start_bit // 8
        start_offset = start_bit % 8
        result = 0

        # 提取第一个字节的部分位（如果起始位不在字节开头）
        if start_offset != 0:
            take_from_first = min(8 - start_offset, bit_length)
            # 生成掩码：保留目标位，其余置0
            mask = ((1 << take_from_first) - 1) << (8 - start_offset - take_from_first)
            # 提取并移位到正确位置
            result = (self.byte_data[start_byte] & mask) >> (8 - start_offset - take_from_first)
            bit_length -= take_from_first
            start_byte += 1

        # 提取中间完整的字节（一次取8位）
        while bit_length >= 8:
            result = (result << 8) | self.byte_data[start_byte]
            start_byte += 1
            bit_length -= 8

        # 提取最后一个字节的部分位（如果还有剩余位数）
        if bit_length > 0:
            mask = (1 << bit_length) - 1
            result = (result << bit_length) | (self.byte_data[start_byte] & mask)

        return result

使用示例 #

用你给出的测试数据来验证：

byte_arr = bytearray([255, 239, 124])
bit_accessor = BitAccessor(byte_arr)

# A对应前6位（索引0-5）
a = bit_accessor.get_bits(0, 6)
# B对应接下来的2位（索引6-7）
b = bit_accessor.get_bits(6, 2)
# C对应接下来的9位（索引8-16）
c = bit_accessor.get_bits(8, 9)

print(f"A: {a} (二进制: {bin(a)})")  # 输出: A: 63 (二进制: 0b111111)
print(f"B: {b} (二进制: {bin(b)})")  # 输出: B: 3 (二进制: 0b11)
print(f"C: {c} (二进制: {bin(c)})")  # 输出: C: 478 (二进制: 0b111011110)

性能与可读性优势 #

1. 可读性拉满：不用再手动计算字节偏移、移位位数，get_bits(start, length)直接表达意图，哪怕是20字节的数组，提取任意位段都是一行清晰的代码。
2. 性能高效：全程用位运算和简单循环（循环次数仅为跨完整字节的数量），没有多余的内存拷贝或复杂操作，和手动写移位代码的性能几乎一致，但维护成本低得多。
3. 边界安全：内置了边界检查，避免越界访问导致的bug。

如果需要频繁提取固定位置的位段，还可以在类里封装成属性（比如@property），进一步简化代码：

@property
def field_a(self):
    return self.get_bits(0, 6)

@property
def field_b(self):
    return self.get_bits(6, 2)

# 使用时直接调用属性
a = bit_accessor.field_a

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