Der schnellste Weg, um eine Liste von Fließkommazahlen in Python in Bytes zu packen

Habe ich eine Liste von sagen wir 100k schwimmt und ich möchten, konvertieren Sie ihn in einen Byte-buffer.

buf = bytes()
for val in floatList:
   buf += struct.pack('f', val)
return buf

Dies ist ziemlich langsam. Wie kann ich es machen schneller nur mit standard-Python 3.x-Bibliotheken.

InformationsquelleAutor der Frage That Umbrella Guy | 2012-03-30

  1. 38

    Nur sagen struct wie viele floats, die Sie haben. 100k schwimmt dauert etwa eine 1/100stel einer Sekunde auf meinen langsamen laptop.

    import random
import struct

floatlist = [random.random() for _ in range(10**5)]
buf = struct.pack('%sf' % len(floatlist), *floatlist)

    InformationsquelleAutor der Antwort agf

  2. 5

    Können Sie ctypes, und ein double-array (oder float-array) genau so, als würden Sie in C , anstatt zu halten Sie Ihre Daten in einer Liste. Dies ist eine faire niedrigen Niveau, ist aber eine Empfehlung, wenn Sie brauchen, große Leistung, und wenn Ihre Liste ist eine Feste Größe.

    Können Sie erstellen, die den Gegenwert einer C
    double array[100];
    in Python by doing:

    array = (ctypes.c_double * 100)()

    Den ctypes.c_double * 100 Ausdruck ergibt eine Python-Klasse für ein array von Double, 100 Elemente lang. Auf Draht es zu einer Datei, können Sie einfach buffer zu seiner Inhalt:

    >>> f = open("bla.dat", "wb")
>>> f.write(buffer(array))

    Wenn Ihre Daten bereits in einer Python-Liste, packen es in ein double array kann oder kann nicht schneller sein als der Aufruf structals Agf die akzeptierten Antworten - ich lass Messen, die ist schneller als Hausaufgabe, aber alle der code, den Sie brauchen, ist diese:

    >>> import ctypes
>>> array = (ctypes.c_double * len(floatlist))(*floatlist)

    Sehen es als einen string, nur: str(buffer(array)) - der einzige Nachteil hier ist, dass Sie haben zu kümmern, Schwimmer Größe (float vs double) und CPU-abhängig Typ "float" - das struct-Modul können übernehmen diese Arbeit für Sie.

    Den großen Gewinn ist, dass Sie mit einem float-array-können Sie immer noch die Elemente als zahlen, die durch den Zugriff auf dann, gerade als ob es wo einen einfachen Python-Liste, während mit dann bereitwillig zur Verfügung, als ein planar-Speicher region mit buffer.

    InformationsquelleAutor der Antwort jsbueno

  3. 2

    Als mit strings, mit .join() schneller sein wird als kontinuierlich zu verketten. Eg:

    import struct
b = bytes()
floatList = [5.4, 3.5, 7.3, 6.8, 4.6]
b = b.join((struct.pack('f', val) for val in floatList))

    Ergebnisse in:

    b'\xcd\xcc\xac@\x00\x00`@\x9a\x99\xe9@\x9a\x99\xd9@33\x93@'

    InformationsquelleAutor der Antwort Gareth Latty

  4. 1

    Funktionieren sollte:

    return struct.pack('f' * len(floatList), *floatList)

    InformationsquelleAutor der Antwort katzenversteher

  5. 1

    Array von single-precision-float gibt es zwei Möglichkeiten: die Verwendung struct oder array.

    In[103]: import random
import struct
from array import array

floatlist = [random.random() for _ in range(10**5)]

In[104]: %timeit struct.pack('%sf' % len(floatlist), *floatlist)
100 loops, best of 3: 2.86 ms per loop

In[105]: %timeit array('f', floatlist).tostring()
100 loops, best of 3: 4.11 ms per loop

    So struct ist schneller.

    InformationsquelleAutor der Antwort Sklavit

  6. 0

    Meisten der Langsamkeit wird sein, dass Sie immer wieder Anhängen ein bytestring. Kopiert den bytestring jeder Zeit. Verwenden Sie stattdessen b''.join():

    import struct
packed = [struct.pack('f', val) for val in floatList]
return b''.join(packed)

    InformationsquelleAutor der Antwort craigds

  7. 0

    Wie Sie sagen, dass Sie wirklich tun wollen single-precision - 'f' schwebt, möchten Sie vielleicht, um zu versuchen, die array-Modul (in der standard-Bibliothek seit dem 1.x).

    >>> mylist = []
>>> import array
>>> myarray = array.array('f')
>>> for guff in [123.45, -987.654, 1.23e-20]:
...    mylist.append(guff)
...    myarray.append(guff)
...
>>> mylist
[123.45, -987.654, 1.23e-20]
>>> myarray
array('f', [123.44999694824219, -987.6539916992188, 1.2299999609665927e-20])
>>> import struct
>>> mylistb = struct.pack(str(len(mylist)) + 'f', *mylist)
>>> myarrayb = myarray.tobytes()
>>> myarrayb == mylistb
True
>>> myarrayb
b'f\xe6\xf6B\xdb\xe9v\xc4&Wh\x1e'

    Dies kann sparen Sie eine Tasche-laden des Speichers, während immer noch eine variable-Länge-container, mit die meisten von der Liste Methoden. Das array.array-Ansatz nimmt 4 Byte pro single-precision-float. Die Liste Ansatz verbraucht einen Zeiger auf ein Python-float-Objekt (4 oder 8 Byte) plus der Größe des Objekts; auf einem 32-bit-CPython-Implementierung, 16:

    >>> import sys
>>> sys.getsizeof(123.456)
16

    Insgesamt: 20 Byte pro Element im besten Fall für eine list 4 bytes pro Element, immer für eine array.array('f').

    InformationsquelleAutor der Antwort John Machin

Schreibe einen Kommentar