struct.error: Déballez nécessite un argument de chaîne de longueur 4

Question

Python dit que je besoin de 4 octets pour un code de format de « BH »:

struct.error: unpack requires a string argument of length 4 

Voici le code, je suis en train en 3 octets que je penser est nécessaire: (!?)

major, minor = struct.unpack("BH", self.fp.read(3)) 

"B" unsigned char (1 octet) + "H" unsigned short (2 octets) = 3 octets

struct.calcsize ("BH") dit 4 octets.

EDIT: Le fichier est ~ 800 Mo et il est dans les premiers octets du fichier, donc je suis assez certain qu'il reste des données à lire.

Answer 1

Le module struct imite les structures C. Il faut plus de cycles CPU pour qu'un processeur lise un mot de 16 bits sur une adresse impaire ou un mot de 32 bits sur une adresse non divisible par 4, donc les structures ajoutent des octets de pad pour que les membres de la structure tombent sur des limites naturelles. Considérons:

struct {     11 
    char a; 
    short b;  ------------ 
    char c;  axbbcxxxdddd 
    int d; 
}; 

Cette structure occupera 12 octets de mémoire (x étant des octets de pad).

Python fonctionne de façon similaire (voir la documentation struct):

>>> import struct 
>>> struct.pack('BHBL',1,2,3,4) 
'\x01\x00\x02\x00\x03\x00\x00\x00\x04\x00\x00\x00' 
>>> struct.calcsize('BHBL') 
12 

Compilateurs ont généralement un moyen d'éliminer le rembourrage. En Python, l'un des = <>! supprimera le remplissage:

>>> struct.calcsize('=BHBL') 
8 
>>> struct.pack('=BHBL',1,2,3,4) 
'\x01\x02\x00\x03\x04\x00\x00\x00' 

Méfiez-vous de laisser le rembourrage struct handle. En C, ces structures:

struct A {  struct B { 
    short a;   int a; 
    char b;   char b; 
};    }; 

sont typiquement 4 et 8 octets, respectivement. Le remplissage se produit à la fin de la structure dans le cas où les structures sont utilisées dans un tableau. Cela maintient les membres 'a' alignés sur les limites correctes pour les structures plus tard dans le tableau. Le module struct Python ne gonflez pas à la fin:

>>> struct.pack('LB',1,2) 
'\x01\x00\x00\x00\x02' 
>>> struct.pack('LBLB',1,2,3,4) 
'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04' 

Answer 2

Par défaut, sur de nombreuses plates-formes, le court sera aligné sur un décalage multiple de 2, de sorte qu'il y aura un octet de remplissage ajouté après le caractère.

Pour désactiver cela, utilisez: struct.unpack("=BH", data). Cela utilisera l'alignement standard, ce qui ne correspond pas padding:

>>> struct.calcsize('=BH') 
3 

Le caractère = utilisera l'ordre des octets natif. Vous pouvez également utiliser < ou > au lieu de = pour forcer l'ordre des octets big-endian ou big-endian, respectivement.