Python: Daten als signed oder unsigned interpretieren

[Kaj G. (Firma: RUB) (bloody)]

Hallo Leute,

ich stehe gerade voll auf dem Schlauch :-/

Folgende Gesichte:
Ich moechte mit einem Python-Script Binaerdaten einlesen und 
entsprechend interpretieren.

Als Beispiel koennte man hier den Header einer BMP-Datei nehmen:
https://de.wikipedia.org/wiki/Windows_Bitmap

Dort gibt es Felder die als signed oder unsigned interpetiert werden 
sollten.

Und jetzt meine Frage: Wie mach ich denn sowas in Python?


Nehmen wir einfach mal als Beispiel das Datum: 0xFFFF

Jetzt kann ich sowas machen:

#!/usr/bin/env python

import struct

def main():
  x = struct.unpack('h', struct.pack('H', 0xFFFF))[0]
  y = struct.unpack('H', struct.pack('H', 0xFFFF))[0]
  print('x = {0} | y = {1}'.format(x, y))


if __name__ == '_main__':
  main()

Dann ist x = -1 und y = 65535. Soweit sogut.
Aber ich finde diese Loesung mega haesslich und umstaendlich.

Gibt es da was einfacheres/schoeneres?

Gruesse

[Mark B. (markbrandis)]

Sollte das in Python nicht einfach zu machen sein, dann wäre es legitim 
die Frage zu stellen, ob man an der Stelle nicht eine andere 
Programmiersprache verwenden sollte.

Der Grundsatz ist immer: Wähle ein Werkzeug, das zur Aufgabenstellung 
passt.

[Bernd K. (prof7bit)]

Kaj G. schrieb:

> x = struct.unpack(fmt, data)

> Aber ich finde diese Loesung mega haesslich und umstaendlich.

was ist daran hässlich? Eleganter und einfacher gehts doch kaum noch?

[Florian F. (flof3000)]

Wenn man nicht alles in eine Zeile kneult und struct.unpack aliast wird 
das auch kurz und bündig...

Bspw

def read_whatever(bytes):
  su = struct.unpack
  x = su('h', bytes[:4])
  y = su('H', bytes[4:8])
  return x, y

fined ich jetzt nicht hässlich...

[Sven B. (scummos)]

Florian F. schrieb:
> und struct.unpack aliast
Eeh, dadurch wird der Code definitiv viel lesbarer. Nicht.

Nein, eine bessere Lösung als mit struct gibt es m.W. nicht, aber wie 
schon gesagt wurde ist das doch auch ganz in Ordnung. Wie stellst du es 
dir denn vor?

[Yalu X. (yalu) (Moderator)]

Mark B. schrieb:
> Sollte das in Python nicht einfach zu machen sein, dann wäre es legitim
> die Frage zu stellen, ob man an der Stelle nicht eine andere
> Programmiersprache verwenden sollte.

Ich kenne keine Programmiersprache, in der das Extrahieren von Integer-
und Floating-Point-Zahlen, Zeichen und Strings bei gemischten Datentypen
auf portable Weise einfacher ginge als in Python.

Kaj G. schrieb:
> Als Beispiel koennte man hier den Header einer BMP-Datei nehmen:
> https://de.wikipedia.org/wiki/Windows_Bitmap

So geht's:

bfType, bfSize, bfOffBits, iSize, biWidth, biHeight,          \
  biPlanes, biBitCount, biCompression, biSizeImage,           \
  biXPelsPerMeter, biYPelsPerMeter, biClrUsed, biClrImportant \
  = struct.unpack('<2sI4xIIiiHHIIiiII', bmpHeader)

Hier werden alle Elemente des 54-Byte-Headers einzelnen Variablen
zugewisen, wobei bfReserved übersprungen wird, weil es nicht von
Interesse ist. Selbst in C tippt man dafür deutlich mehr Code.

Die Funktionen struct.pack und struct.unpack sind sozusagen das sprintf
und sscanf für Binärdaten.

[Kaj G. (Firma: RUB) (bloody)]

Okay, wie so oft: Das Problem sitzt vor dem Monitor :-/

Mein Problem bestand darin, dass ich die Daten zusammen geshiftet hatte:

f = open(dateiname, 'rb')
fc = f.read()

x = (fc[1] << 8) | fc[0]

Damit war es kein Byte-Object mehr, und deswegen geht das nicht direkt 
mit struct.unpack, sondern nur ueber den umweg mit 
struct.unpack(struct.pack(...)).

Lass ich dass mit der Shifterei funktioniert es direkt mit 
struct.unpack.
Damit gefaellt mir das auch schon viel besser :)
Danke euch.

Es gaebe wohl noch die Moeglichkeit mit ctypes:

import ctypes

f = open(dateiname, 'rb')
fc = f.read()

x = ctypes.c_int16((fc[1] << 8) | fc[0])

Aber die ctypes bringen wieder andere Probleme mit sich.

Tja, kaum hat man drueber gesprochen, loest sich dass Problem wie von 
selbst. :)


Yalu X. schrieb:
> So geht's:
...ist mir zu kryptisch :(
Ich mach es mir dann doch etwas aufwaendiger:

import copy
import struct

HEADER = {
        'bfType'            : None,
        'bfSize'            : None,
        'bfReserved'        : None,
        'bfOffBits'         : None,
        'biSize'            : None,
        'biWidth'           : None,
        'biHeight'          : None,
        'biPlanes'          : None,
        'biBitCount'        : None,
        'biCompression'     : None,
        'biSizeImage'       : None,
        'biXPelsPerMeter'   : None,
        'biYPelsPerMeter'   : None,
        'biClrUsed'         : None,
        'biClrImportand'    : None
    }

def get_header(bmp_file):
  header = copy.deepcopy(HEADER)
  
  header['bfType'         ] = struct.unpack('<H', bmp_file[ 0: 2])[0]
  header['bfSize'         ] = struct.unpack('<I', bmp_file[ 2: 6])[0]
  header['bfReserved'     ] = struct.unpack('<I', bmp_file[ 6:10])[0]
  header['bfOffBits'      ] = struct.unpack('<I', bmp_file[10:14])[0]
  header['biSize'         ] = struct.unpack('<I', bmp_file[14:18])[0]
  header['biWidth'        ] = struct.unpack('<i', bmp_file[18:22])[0]
  header['biHeight'       ] = struct.unpack('<i', bmp_file[22:26])[0]
  header['biPlanes'       ] = struct.unpack('<H', bmp_file[26:28])[0]
  header['biBitCount'     ] = struct.unpack('<H', bmp_file[28:30])[0]
  header['biCompression'  ] = struct.unpack('<I', bmp_file[30:34])[0]
  header['biSizeImage'    ] = struct.unpack('<I', bmp_file[34:38])[0]
  header['biXPelsPerMeter'] = struct.unpack('<i', bmp_file[38:42])[0]
  header['biYPelsPerMeter'] = struct.unpack('<i', bmp_file[42:46])[0]
  header['biClrUsed'      ] = struct.unpack('<I', bmp_file[46:50])[0]
  header['biClrImportand' ] = struct.unpack('<I', bmp_file[50:54])[0]

  return header

Aber das ist geschmackssache.
Was mich gestoert hatte, war die verschachtelung von 
struct.unpack(struct.pack(...)), die aber nur noetig war, weil ich die 
Daten von Hand zusammengeshiftet hatte.

Naja, Problem erkannt, Problem gebannt. :)

[Sven B. (scummos)]

Ist halt unfassbar viel langsamer als wenn du es in einen einzelnen 
Aufruf tust aber jo, immerhin lesbar und funktioniert ;)

[Mark B. (markbrandis)]

Yalu X. schrieb:
> Ich kenne keine Programmiersprache, in der das Extrahieren von Integer-
> und Floating-Point-Zahlen, Zeichen und Strings bei gemischten Datentypen
> auf portable Weise einfacher ginge als in Python.

Vielleicht habe ich den Threadersteller ja falsch verstanden. Ging es 
ausschließlich um das Extrahieren, oder darum wie man im weiteren 
Verlauf mit den Daten umgeht? Nach meinem Verständis behandelt Python 
bei arithmetischen Operationen eine Ganzzahl immer als 
vorzeichenbehaftet. Korrigier mich gerne wenn ich falsch liege.

[Yalu X. (yalu) (Moderator)]

Mark B. schrieb:
> Vielleicht habe ich den Threadersteller ja falsch verstanden. Ging es
> ausschließlich um das Extrahieren, oder darum wie man im weiteren
> Verlauf mit den Daten umgeht?

IMHO ersteres, aber genau weiß es nur Kaj ;-)

> Nach meinem Verständis behandelt Python bei arithmetischen Operationen
> eine Ganzzahl immer als vorzeichenbehaftet. Korrigier mich gerne wenn
> ich falsch liege

Richtig. Wobei das normalerweise kein Problem ist, da es in Python keine
Integer-Überläufe gibt.

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Besonders elegant ist bei Python natürlich auch die Behandlung der 
Endianess gelöst. Man gibt in der Formatangabe bei struct.pack bzw 
struct.unpack einfach einen Endianess-Qualifizierer an, siehe:

https://docs.python.org/3/library/struct.html#struct.calcsize

Die Endianess des Systems, auf dem ein Programm läuft, lässt sich auch 
direkt per sys.byteorder bestimmen.