Konvertieren variable-sized-byte-array zu einem integer/long

Python nicht traditionell viel Einsatz für "zahlen im big-endian-C layout" zu groß sind C. (Wenn man sich mit 2-byte, 4-byte oder 8-byte-zahlen, dann struct.unpack ist die Antwort.)

Aber genug Leute, die krank von es nicht eine offensichtliche Weg, dies zu tun, die Python 3.2 Hinzugefügt eine Methode int.from_bytesdas genau das tut, was Sie wollen:

int.from_bytes(b, byteorder='big', signed=False)

Leider, wenn Sie eine ältere version von Python, die Sie nicht haben. Also, welche Optionen Sie haben? (Neben den offensichtlichen one: update auf 3.2, oder, besser, 3.4...)

Ersten, da ist dein code. Ich denke binascii.hexlify ist eine bessere Art und Weise zu buchstabieren es als .encode('hex')weil "encode" hat immer schien ein wenig seltsam für ein Verfahren auf byte-Zeichenfolgen (im Gegensatz zu Unicode-strings), und es ist in der Tat verbannt in Python 3. Aber ansonsten scheint es ziemlich gut lesbar und offensichtlich zu mir. Und es sollte Recht schnell gehen—ja, es ist zum erstellen einer temporären string, aber es tut allen einen looping und Arithmetik in C (zumindest CPython), die im Allgemeinen eine um eine Größenordnung oder zwei schneller als in Python. Es sei denn, Ihr bytearray ist so groß, dass die Zuordnung der Zeichenfolge selbst wird kostspielig werden, ich würde nicht sorgen über die performance hier.

Alternativ könnte man es machen, in einer Schleife. Aber das ist Ausführlicher und, zumindest in CPython, viel langsamer.

Könnten Sie versuchen, zu beseitigen, die explizite Schleife für eine implizite, aber die offensichtliche Funktion zu tun, ist reducedie als un-Pythonic, die ein Teil der Gemeinschaft—und es ist natürlich zu verlangen, dass Sie eine Funktion aufrufen, die für jedes byte.

Könnten Sie entrollen der Schleife oder reduce durch das brechen Sie in Stücke von 8 bytes und Schleifen über struct.unpack_from oder nur dabei eine große struct.unpack('Q'*len(b)//8 + 'B' * len(b)%8) - und looping über, aber das macht es viel weniger lesbar und wahrscheinlich auch nicht viel schneller.

Könnten Sie NumPy... aber wenn Sie größer als 64 oder vielleicht 128 bit, es wird am Ende alles konvertieren zu Python-Objekten sowieso.

So, ich denke, deine Antwort ist die beste option.

Hier sind einige timings zu vergleichen das offensichtlichste manuelle Konvertierung:

import binascii
import functools
import numpy as np

def hexint(b):
    return int(binascii.hexlify(b), 16)

def loop1(b):
    def f(x, y): return (x<<8)|y
    return functools.reduce(f, b, 0)

def loop2(b):
    x = 0
    for c in b:
        x <<= 8
        x |= c
    return x

def numpily(b):
    n = np.array(list(b))
    p = 1 << np.arange(len(b)-1, -1, -1, dtype=object)
    return np.sum(n * p)

In [226]: b = bytearray(range(256))

In [227]: %timeit hexint(b)
1000000 loops, best of 3: 1.8 µs per loop

In [228]: %timeit loop1(b)
10000 loops, best of 3: 57.7 µs per loop

In [229]: %timeit loop2(b)
10000 loops, best of 3: 46.4 µs per loop

In [283]: %timeit numpily(b)
10000 loops, best of 3: 88.5 µs per loop

Zum Vergleich in Python 3.4:

In [17]: %timeit hexint(b)
1000000 loops, best of 3: 1.69 µs per loop

In [17]: %timeit int.from_bytes(b, byteorder='big', signed=False)
1000000 loops, best of 3: 1.42 µs per loop

Also, Ihre Methode ist immer noch ziemlich schnell...

InformationsquelleAutor der Antwort abarnert