어떻게 파이썬에서 다소 복잡한 이진 알고리즘을 최적화 할 수 있습니까?

Question

큰 덩어리의 데이터를 반복하고 값을 올바로 구성하려고합니다. 컨텍스트 : 데이터는 원시 바이 데이터에서 해석 된 많은 수의 정수입니다. 정수는 실제로 조밀하게 압축 된 데이터이며 그 위에 바이트가 "little endian"순서로 있습니다. 따라서 올바른 값을 얻기 위해 3 가지 값을 읽고 각 니블을 추출한 다음 올바른 방향으로 다시 정렬해야합니다.

결국, 내 질문에. 이 프로세스의 속도를 높이거나 최적화 할 수있는 방법은 현재 하나의 파일에서 모든 데이터를 처리하는 데 1 분 이상 걸리고 잠재적으로 수천 개의 파일을 가질 수 있습니다.

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 또는 미리 만들어진 파이썬 패키지를 사용하지 않고이 작업을 수행하려고합니다. 당신은 단지 디버그 목적으로 니블이 필요하고 일부 작업을 제외 할 수 있습니다

Answer 1

참고 : 코드 한입에 accordigng

 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])