Empaquetado de enteros de tamaño arbitrario eficiente en Python

Question

La función struct.pack() permite convertir enteros de hasta 64 bits a cadenas de bytes. ¿Cuál es la forma más eficiente de empacar un número entero aún mayor? Prefiero no agregar una dependencia en módulos no estándar como PyCrypto (que proporciona num_to_bytes()).

Answer 1

Según lo sugerido por S.Lott en un comentario, simplemente convierta el número en una cadena y empaquete esa cadena. Por ejemplo,

x = 2 ** 12345 
struct.pack("40s", str(x)) 

Answer 2

Suponiendo que el cartel paquete de un entero grande como una cadena binaria, es decir, no utilizar un byte de almacenamiento por dígito del número. Una forma de hacer esto parece ser:

import marshal 

a = 47L 
print marshal.dumps(a) 

Esta impresora:

'l\x01\x00\x00\x00/\x00' 

No puedo decir que entiendo cómo interpretar estos bits, en este momento ...

Answer 3

I tómelo, ¿quiere decir que solo quiere usar tantos bytes como necesite para representar el número? p.ej. si el número es:

• 255 o menos tendrá que utilizar solamente 1 byte
• 65535 o menos 2 bytes
• 16777215 o menos 3 bytes
• , etc, etc

Por Psion PDA por lo general tienen algunos de los planes de empaque en los que lee el primer byte, detecta si tiene el bit más alto establecido y luego lee otro byte si lo tiene. De esta forma, seguirías leyendo los bytes hasta que leas el número "completo". Ese sistema funciona bastante bien si la mayoría de los números con los que se trata son bastante pequeños, ya que normalmente solo usará uno o dos bytes por número.

La alternativa es tener uno (o más) bytes que representen la cantidad total de bytes utilizados, pero en ese punto, básicamente, es una cadena en Python. es decir, es una cadena de dígitos base-256.

Answer 4

Qué quiere decir algo así:

def num_to_bytes(num): 
    bytes = [] 
    num = abs(num) # Because I am unsure about negatives... 
    while num > 0: 
     bytes.append(chr(num % 256)) 
     num >>= 8 
    return ''.join(reversed(bytes)) 

def bytes_to_num(bytes): 
    num = 0 
    for byte in bytes: 
     num <<= 8 
     num += ord(byte) 
    return num 

for n in (1, 16, 256, 257, 1234567890987654321): 
    print n, 
    print num_to_bytes(n).encode('hex'), 
    print bytes_to_num(num_to_bytes(n)) 

que devuelve:

1 01 1 
16 10 16 
256 0100 256 
257 0101 257 
1234567890987654321 112210f4b16c1cb1 1234567890987654321 

que no estoy seguro de qué hacer con los negativos ... No soy tan familiarizados con un poco de twidling

EDIT: Otra solución (que se extiende alrededor del 30% más rápido por mis pruebas):

def num_to_bytes(num): 
    num = hex(num)[2:].rstrip('L') 
    if len(num) % 2: 
     return ('0%s' % num).decode('hex') 
    return num.decode('hex') 

def bytes_to_num(bytes): 
    return int(bytes.encode('hex'), 16) 

Answer 5

Esto es un poco hacky, pero se puede ir a través de la representación de cadena hexadecimal, y no a binario con el códec hexagonal:

>>> a = 2**60 
>>> a 
1152921504606846976L 
>>> hex(a) 
'0x1000000000000000L' 
>>> hex(a).rstrip("L")[2:].decode('hex') 
'\x10\x00\x00\x00\x00\x00\x00\x00'  # 8bytes, as expected. 

>>> int(_.encode('hex'), 16) 
1152921504606846976L 

se rompe un poco porque el códec hexagonal requiere un número par de dígitos, por lo que tendrá a la almohadilla para eso, y usted tendrá que establecer un indicador para manejar números negativos.He aquí un paquete genérico/deshacer las maletas:

def pack(num): 
    if num <0: 
     num = (abs(num) << 1) | 1 # Hack - encode sign as lowest bit. 
    else: 
     num = num << 1 
    hexval = hex(num).rstrip("L")[2:] 
    if len(hexval)%2 ==1: hexval = '0' + hexval 
    return hexval.decode('hex') 

def unpack(s): 
    val = int(s.encode('hex'), 16) 
    sign = -1 if (val & 1) else 1 
    return sign * (val>>1) 


for i in [10,4534,23467, 93485093485, 2**50, 2**60-1, -1, -20, -2**60]: 
    assert unpack(pack(i)) == i 

Con todo el tocar el violín para el relleno etc requerido, no estoy seguro de que es mucho mejor que una solución hecha a mano sin embargo.