Le module de structure dans Python vous permet de travailler avec des données binaires en fournissant des fonctionnalités de conversion entre les valeurs Python et les données binaires de style C. Ceci est particulièrement utile lorsqu'il s'agit de formats de fichiers binaires ou de protocoles réseau. Ses principales fonctionnalités incluent :

• Emballage convertir les valeurs Python en données binaires (octets).
• Déballage reconvertissez les données binaires en valeurs Python.
• Formater les chaînes définir comment les données sont compressées/décompressées à l'aide de codes de format (par exemple i pour les entiers f pour les flottants).

Méthodes dans struct.pack()

1.Struct.pack() : Il convertit les valeurs Python dans un format binaire compressé. La chaîne de format (fmt) spécifie la disposition des données compressées et les valeurs suivantes (v1 v2 ...) sont compressées selon ce format. Syntaxe:

struct.pack(fmt v1 v2 ...)

• fmt : Une chaîne de format qui spécifie comment les données seront compressées.
• v1 v2... : Les valeurs qui seront compressées selon le format spécifié.

   import   struct   # pack values into binary   var   =   struct  .  pack  (  'hhl'     1     2     3  )   print  (  var  )   var   =   struct  .  pack  (  'iii'     1     2     3  )   print  (  var  )   

b'x01x00x02x00x00x00x00x00x03x00x00x00x00x00x00x00' b'x01x00x00x00x02x00x00x00x03x00x00x00'  

Explication : 'hhl' signifie deux entiers courts (h 2 octets chacun) suivis d'un long (l généralement 4 ou 8 octets selon la plate-forme). 'iii' contient trois entiers de 4 octets. La sortie est en octets (b'') représentant le codage binaire des valeurs.

2.struct.unpack() : Il reconvertit les données binaires compressées en valeurs Python. Il prend une chaîne de format (fmt) et une chaîne binaire compressée et renvoie un tuple de valeurs non compressées. Syntaxe:

struct.unpack (chaîne fmt)

• ftm : Chaîne de format qui spécifie comment les données doivent être décompressées.
• chaîne: Les données binaires compressées qui doivent être décompressées.

   import   struct   var   =   struct  .  pack  (  '?hil'     True     2     5     445  )   print  (  var  )   tup   =   struct  .  unpack  (  '?hil'     var  )   print  (  tup  )   var   =   struct  .  pack  (  'qf'     5     2.3  )   print  (  var  )   tup   =   struct  .  unpack  (  'qf'     var  )   print  (  tup  )   

b'x01x00x02x00x05x00x00x00xbdx01x00x00x00x00x00x00' (True 2 5 445) b'x05x00x00x00x00x00x00x0033x13@' (5 2.299999952316284)  

Explication: Cet exemple regroupe d'abord un booléen (?), un court (h), un entier (i) et un long (l) en octets. Ensuite, struct.unpack() est utilisé pour le reconvertir en valeurs Python. La deuxième partie regroupe un entier long (q) et un flottant (f), puis les décompresse. Notez comment 2.3 devient 2.299999952... en raison de la précision float.

3. struct.calcsize() : Il renvoie la taille (en octets) d'une structure correspondant à la chaîne de format. Il est utile pour déterminer la quantité d'espace nécessaire pour stocker les données compressées. Syntaxe:

struct.calcsize(fmt)

• fmt : une chaîne de format qui spécifie la disposition des données.

   import   struct   print  (  struct  .  calcsize  (  '?hil'  ))   print  (  struct  .  calcsize  (  'qf'  ))   

16 12  

Explication : '?hil' nécessite 16 octets et 'qf' a besoin de 12 octets en fonction de l'alignement et de la plate-forme.

4. struct.pack_into() et struct.unpack_from() : Ces méthodes vous permettent de compresser et de décompresser directement des données dans/depuis un tampon en commençant à un décalage donné. Ceux-ci sont particulièrement utiles lorsqu'il s'agit de tampons de mémoire pré-alloués ou lorsque vous travaillez avec des données binaires stockées en mémoire.

Syntaxe pour struct.pack_into() :

struct.pack_into (décalage du tampon fmt v1 v2 ...)

• fmt : une chaîne de format spécifiant la disposition des données.
• buffer : Un tampon inscriptible (par exemple ctypes.create_string_buffer).
• offset : position de départ dans le tampon où commence le compactage.
• v1 v2 ... : les valeurs à emballer dans le tampon.

Syntaxe pour struct.unpack_from() :

struct.unpack_from (offset du tampon fmt = 0)

• ftm : Une chaîne de format spécifiant la disposition des données.
• tampon: Le tampon contenant les données compressées.
• compenser: La position de départ à partir de laquelle commence le déballage (facultatif)

   import   struct   import   ctypes   # Allocate buffer   size   =   struct  .  calcsize  (  'hhl'  )   buff   =   ctypes  .  create_string_buffer  (  size  )   # Pack into buffer   struct  .  pack_into  (  'hhl'     buff     0     2     2     3  )   # Unpack from buffer   res   =   struct  .  unpack_from  (  'hhl'     buff     0  )   print  (  res  )   

(2 2 3)  

Explication: Ici, un tampon est créé à l'aide de ctypes. struct.pack_into() insère les valeurs dans ce tampon au décalage spécifié (0 dans ce cas). struct.unpack_from() lit ensuite les données du tampon.

Effet de l'ordre des formats

L'ordre des caractères de format peut modifier la sortie compressée en raison du remplissage et de l'alignement. Cela affecte à la fois le contenu en octets et la taille du résultat.

   import   struct   var   =   struct  .  pack  (  'bi'     56     0x12131415  )   print  (  var  )   print  (  struct  .  calcsize  (  'bi'  ))   var   =   struct  .  pack  (  'ib'     0x12131415     56  )   print  (  var  )   print  (  struct  .  calcsize  (  'ib'  ))   

b'8x00x00x00x15x14x13x12' 8 b'x15x14x13x128' 5  

Explication : 'bi' (octet int) peut inclure un remplissage après l'octet alors que 'ib' (entier octet) n'en a pas besoin. La différence de taille (8 contre 5) montre comment l'alignement affecte la disposition de la mémoire.

Gestion des erreurs

Si un mauvais type de données est utilisé avec struct.pack(), une erreur struct.error se produit. Utilisez try-sauf pour gérer de tels cas en toute sécurité.

   import   struct   try  :   struct  .  pack  (  'h'     'invalid'  )   # Wrong type 'invalid' is a string but 'h' expects an integer   except   struct  .  error   as   e  :   print  (  f  'Struct Error:   {  e  }  '  )   

Sortir

 Struct Error: required argument is not an integer   
 
    Explication:    Ceci montre la gestion des erreurs lors de l'utilisation de struct. 'h' attend un entier court mais une chaîne ("invalide") est donnée provoquant une struct.error. Le bloc try-sauf capture l'erreur et imprime un message significatif.  
 
 Référence    https://docs.python.org/2/library/struct.html