如何在python中优化有点复杂的二进制算法？

Question

我正在尝试迭代一大块数据，并正确组织这些值。上下文:数据是从原始bye数据解释的一大组整数。整数实际上是密集打包的数据，最重要的是，字节按“小端”顺序排列。因此，为了获得正确的值，我发现我需要读取3个值，提取每个半字节，然后将它们重新排序到正确的方向。

所以，最后来回答我的问题。我如何才能加速或优化这个过程，因为现在从一个文件中获取所有数据需要一分钟多的时间，而且我可能有数千个文件。

for i in range(0, len(data), 3):
            j = struct.pack("=I", data[i])
            p = struct.pack("=I", data[i + 1])
            q = struct.pack("=I", data[i + 2])
            nibble0 = j[1] >> 4
            nibble1 = j[1] & 15
            nibble2 = j[0] >> 4
            nibble3 = j[0] & 15
            nibble4 = j[3] >> 4
            nibble5 = j[3] & 15
            nibble6 = j[2] >> 4
            nibble7 = j[2] & 15
            nibble8 = p[1] >> 4
            nibble9 = p[1] & 15
            nibble10 = p[0] >> 4
            nibble11 = p[0] & 15
            nibble12 = p[3] >> 4
            nibble13 = p[3] & 15
            nibble14 = p[2] >> 4
            nibble15 = p[2] & 15
            nibble16 = q[1] >> 4
            nibble17 = q[1] & 15
            nibble18 = q[0] >> 4
            nibble19 = q[0] & 15
            nibble20 = q[3] >> 4
            nibble21 = q[3] & 15
            nibble22 = q[2] >> 4
            nibble23 = q[2] & 15

k.append((nibble0 << 12) | (nibble1 << 8) | (nibble2 << 4) | 0)

k.append((nibble3 << 12) | (nibble4 << 8) | (nibble5 << 4) | 0)

k.append((nibble6 << 12) | (nibble7 << 8) | (nibble8 << 4) | 0)

k.append((nibble9 << 12) | (nibble10 << 8) | (nibble11 << 4) | 0)

k.append((nibble12 << 12) | (nibble13 << 8) | (nibble14 << 4) | 0)

k.append((nibble15 << 12) | (nibble16 << 8) | (nibble17 << 4) | 0)

k.append((nibble18 << 12) | (nibble19 << 8) | (nibble20 << 4) | 0)

k.append((nibble21 << 12) | (nibble22 << 8) | (nibble23 << 4) | 0)

我希望在不使用Anaconda或Pypy或任何预先构建的python包的情况下做到这一点。

Answer 1

请注意，您仅在调试时才需要半字节，并且可以排除一些操作：

        nibble0 = j[1] >> 4
        nibble1 = j[1] & 15
        nibble2 = j[0] >> 4
        k.append((nibble0 << 12) | (nibble1 << 8) | (nibble2 << 4) | 0)

    is equivalent to 

        k.append((j[1] << 8) | (j[0] % F0))

   and 
       nibble3 = j[0] & 15
       nibble4 = j[3] >> 4
       nibble5 = j[3] & 15
       k.append((nibble3 << 12) | (nibble4 << 8) | (nibble5 << 4) | 0)   

  is equivalent to 

       k.append((j[0] << 12) | (j[3] << 4))

  (if k gets 16-bit values, otherwise clear MSB bits of j[0])