"struct" — manipulation de données agrégées sous forme binaire comme une séquence d'octets
******************************************************************************************

**Code source :** Lib/struct.py

======================================================================

Ce module effectue des conversions entre des valeurs Python et des
structures C représentées sous la forme de "bytes" (séquences
d'octets) Python. Cela permet, entre autres, de manipuler des données
agrégées sous forme binaire dans des fichiers ou à travers des
connecteurs réseau. Il utilise Chaînes de spécification du format
comme description de l'agencement des structures afin de réaliser les
conversions depuis et vers les valeurs Python.

Note:

  par défaut, le résultat de l'agrégation d'une structure C donnée
  comprend des octets de bourrage afin de maintenir un alignement
  correct des types C sous-jacents ; de la même manière, l'alignement
  est pris en compte lors de la dissociation. Ce comportement a été
  choisi de manière à ce que les octets d'une structure agrégée
  reproduisent exactement l'agencement en mémoire de la structure C
  équivalente. Pour gérer des formats de données indépendants de la
  plateforme ou omettre les octets implicites de bourrage, utilisez la
  taille et l'alignement "standard" en lieu et place de la taille et
  l'alignement "native" (voir Boutisme, taille et alignement pour les
  détails).

Plusieurs fonctions de "struct" (et méthodes de "Struct") prennent un
argument *buffer*. Cet argument fait référence à des objets qui
implémentent Protocole tampon et qui proposent un tampon soit en
lecture seule, soit en lecture-écriture. Les types les plus courants
qui utilisent cette fonctionnalité sont "bytes" et "bytearray", mais
beaucoup d'autres types qui peuvent être considérés comme des tableaux
d'octets implémentent le protocole tampon ; ils peuvent ainsi être lus
ou remplis depuis un objet "bytes" sans faire de copie.


Fonctions et exceptions
=======================

Le module définit les exceptions et fonctions suivantes :

exception struct.error

   Exception levée à plusieurs occasions ; l'argument est une chaîne
   qui décrit ce qui ne va pas.

struct.pack(format, v1, v2, ...)

   Renvoie un objet *bytes* contenant les valeurs *v1*, *v2*… agrégées
   conformément à la chaîne de format *format*. Les arguments doivent
   correspondre exactement aux valeurs requises par le format.

struct.pack_into(format, buffer, offset, v1, v2, ...)

   Agrège les valeurs *v1*, *v2*… conformément à la chaîne de format
   *format* et écrit les octets agrégés dans le tampon *buffer*, en
   commençant à la position *offset*. Notez que *offset* est un
   argument obligatoire.

struct.unpack(format, buffer)

   Dissocie depuis le tampon *buffer* (en supposant que celui-ci a été
   agrégé avec "pack(format, …)") à l'aide de la chaîne de format
   *format*. Le résultat est un n-uplet, qui peut éventuellement ne
   contenir qu'un seul élément. La taille de *buffer* en octets doit
   correspondre à la taille requise par le format, telle que calculée
   par "calcsize()".

struct.unpack_from(format, buffer, offset=0)

   Unpack from *buffer* starting at position *offset*, according to
   the format string *format*.  The result is a tuple even if it
   contains exactly one item.  The buffer's size in bytes, minus
   *offset*, must be at least the size required by the format, as
   reflected by "calcsize()".

struct.iter_unpack(format, buffer)

   Dissocie de manière itérative les éléments du tampon *buffer*
   conformément à la chaîne de format *format*. Cette fonction renvoie
   un itérateur qui lit des morceaux de taille fixe dans le tampon
   jusqu'à ce que tout le contenu ait été consommé. La taille du
   tampon en octets doit être un multiple de la taille requise par le
   format, telle que calculée par "calcsize()".

   Chaque itération produit un n-uplet tel que spécifié par la chaîne
   de format.

   Nouveau dans la version 3.4.

struct.calcsize(format)

   Renvoie la taille de la structure (et donc celle de l'objet *bytes*
   produit par "pack(format, ...)") correspondant à la chaîne de
   format *format*.


Chaînes de spécification du format
==================================

Les chaînes de spécification du format servent à définir l'agencement
lors de l'agrégation et la dissociation des données. Elles sont
construites à partir de Caractères de format, qui spécifient le type
de donnée à agréger-dissocier. De plus, il existe des caractères
spéciaux pour contrôler Boutisme, taille et alignement.


Boutisme, taille et alignement
------------------------------

Par défaut, les types C sont représentés dans le format et le boutisme
natifs de la machine ; ils sont alignés correctement en sautant des
octets si nécessaire (en fonction des règles utilisées par le
compilateur C).

Cependant, le premier caractère de la chaîne de format peut être
utilisé pour indiquer le boutisme, la taille et l'alignement des
données agrégées, conformément à la table suivante :

+-------------+--------------------------+------------+-------------+
| Caractère   | Boutisme                 | Taille     | Alignement  |
|=============|==========================|============|=============|
| "@"         | natif                    | natif      | natif       |
+-------------+--------------------------+------------+-------------+
| "="         | natif                    | standard   | aucun       |
+-------------+--------------------------+------------+-------------+
| "<"         | petit-boutiste           | standard   | aucun       |
+-------------+--------------------------+------------+-------------+
| ">"         | gros-boutiste            | standard   | aucun       |
+-------------+--------------------------+------------+-------------+
| "!"         | réseau (= gros-boutiste) | standard   | aucun       |
+-------------+--------------------------+------------+-------------+

Si le premier caractère n'est pas dans cette liste, le module se
comporte comme si "'@'" avait été indiqué.

Le boutisme natif est gros-boutiste ou petit-boutiste, en fonction de
la machine sur laquelle s'exécute le programme. Par exemple, les Intel
x86 et les AMD64 (x86-64) sont petit-boutistes ; les Motorola 68000 et
les *PowerPC G5* sont gros-boutistes ; les ARM et les Intel Itanium
peuvent changer de boutisme. Utilisez "sys.byteorder" pour vérifier le
boutisme de votre système.

La taille et l'alignement natifs sont déterminés en utilisant
l'expression "sizeof" du compilateur C. Leur valeur est toujours
combinée au boutisme natif.

La taille standard dépend seulement du caractère du format ; référez-
vous au tableau dans la section Caractères de format.

Notez la différence entre "'@'" et "'='" : les deux utilisent le
boutisme natif mais la taille et l'alignement du dernier sont
standards.

La forme "'!'" existe pour les têtes en l'air qui prétendent ne pas se
rappeler si le boutisme réseau est gros-boutiste ou petit-boutiste.

Il n'y a pas de moyen de spécifier le boutisme contraire au boutisme
natif (c'est-à-dire forcer la permutation des octets) ; utilisez le
bon caractère entre "'<'" et "'>'".

Notes :

1. Le bourrage (*padding* en anglais) n'est automatiquement ajouté
   qu'entre les membres successifs de la structure. Il n'y a pas de
   bourrage au début ou à la fin de la structure agrégée.

2. Il n'y a pas d'ajout de bourrage lorsque vous utilisez une taille
   et un alignement non-natifs, par exemple avec *<*, *'>', `=* ou
   *!*.

3. Pour aligner la fin d'une structure à l'alignement requis par un
   type particulier, terminez le format avec le code du type voulu et
   une valeur de répétition à zéro. Référez-vous à Exemples.


Caractères de format
--------------------

Les caractères de format possèdent les significations suivantes ; la
conversion entre les valeurs C et Python doit être évidente compte
tenu des types concernés. La colonne « taille standard » fait
référence à la taille en octets de la valeur agrégée avec
l'utilisation de la taille standard (c'est-à-dire lorsque la chaîne de
format commence par l'un des caractères suivants : "'<'", "'>'", "'!'"
ou "'='"). Si vous utilisez la taille native, la taille de la valeur
agrégée dépend de la plateforme.

+----------+----------------------------+----------------------+------------------+--------------+
| Format   | Type C                     | Type Python          | Taille standard  | Notes        |
|==========|============================|======================|==================|==============|
| "x"      | octet de bourrage          | pas de valeur        |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "c"      | "char"                     | *bytes* (suite       | 1                |              |
|          |                            | d'octets) de taille  |                  |              |
|          |                            | 1                    |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "b"      | "signed char"              | *int* (entier)       | 1                | (1), (2)     |
+----------+----------------------------+----------------------+------------------+--------------+
| "B"      | "unsigned char"            | *int* (entier)       | 1                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "?"      | "_Bool"                    | *bool* (booléen)     | 1                | (1)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "h"      | "short"                    | *int* (entier)       | 2                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "H"      | "unsigned short"           | *int* (entier)       | 2                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "i"      | "int"                      | *int* (entier)       | 4                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "I"      | "unsigned int"             | *int* (entier)       | 4                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "l"      | "long"                     | *int* (entier)       | 4                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "L"      | "unsigned long"            | *int* (entier)       | 4                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "q"      | "long long"                | *int* (entier)       | 8                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "Q"      | "unsigned long long"       | *int* (entier)       | 8                | (2)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "n"      | "ssize_t"                  | *int* (entier)       |                  | (3)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "N"      | "size_t"                   | *int* (entier)       |                  | (3)          |
+----------+----------------------------+----------------------+------------------+--------------+
| "e"      | (6)                        | *float* (nombre à    | 2                | (4)          |
|          |                            | virgule flottante)   |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "f"      | "float"                    | *float* (nombre à    | 4                | (4)          |
|          |                            | virgule flottante)   |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "d"      | "double"                   | *float* (nombre à    | 8                | (4)          |
|          |                            | virgule flottante)   |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "s"      | "char[]"                   | *bytes* (séquence    |                  |              |
|          |                            | d'octets)            |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "p"      | "char[]"                   | *bytes* (séquence    |                  |              |
|          |                            | d'octets)            |                  |              |
+----------+----------------------------+----------------------+------------------+--------------+
| "P"      | "void *"                   | *int* (entier)       |                  | (5)          |
+----------+----------------------------+----------------------+------------------+--------------+

Modifié dans la version 3.3: ajouté la gestion des formats "'n'" et
"'N'".

Modifié dans la version 3.6: ajouté la gestion du format "'e'".

Notes :

1. Le code de conversion "'?'" correspond au type "_Bool" de C99. Si
   ce type n'est pas disponible, il est simulé en utilisant un "char".
   Dans le mode standard, il est toujours représenté par un octet.

2. Lorsque vous essayez d'agréger un non-entier en utilisant un code
   de conversion pour un entier, si ce non-entier possède une méthode
   "__index__()" alors cette méthode est appelée pour convertir
   l'argument en entier avant l'agrégation.

   Modifié dans la version 3.2: utilisation de la méthode
   "__index__()" pour les non-entiers.

3. Les codes de conversion "'n'" et "'N'" ne sont disponibles que pour
   la taille native (choisie par défaut ou à l'aide du caractère de
   boutisme "'@'"). Pour la taille standard, vous pouvez utiliser
   n'importe quel format d'entier qui convient à votre application.

4. Pour les codes de conversion "'f'", "'d'" et "'e'", la
   représentation agrégée utilise respectivement le format IEEE 754
   *binaire32*, *binaire64* ou *binaire16* (pour "'f'", "'d'" ou "'e'"
   respectivement), quel que soit le format des nombres à virgule
   flottante de la plateforme.

5. Le caractère de format "'P'" n'est disponible que pour le boutisme
   natif (choisi par défaut ou à l'aide du caractère "'@'" de
   boutisme). Le caractère de boutisme "'='" choisit d'utiliser un
   petit ou un gros en fonction du système hôte. Le module *struct* ne
   l'interprète pas comme un boutisme natif, donc le format "'P'"
   n'est pas disponible.

6. Le type IEEE 754 *binaire16* « demie-précision » a été introduit en
   2008 par la révision du standard IEEE 754. Il comprend un bit de
   signe, un exposant sur 5 bits et une précision de 11 bits (dont 10
   bits sont explicitement stockés) ; il peut représenter les nombres
   entre environ "6.1e-05" et "6.5e+04" avec une précision maximale.
   Ce type est rarement pris en charge par les compilateurs C : sur
   une machine courante, un *unsigned short* (entier court non signé)
   peut être utilisé pour le stockage mais pas pour les opérations
   mathématiques. Lisez la page Wikipédia (NdT : non traduite en
   français) half-precision floating-point format pour davantage
   d'informations.

Un caractère de format peut être précédé par un entier indiquant le
nombre de répétitions. Par exemple, la chaîne de format "'4h'" a
exactement la même signification que "'hhhh'".

Les caractères d'espacement entre les indications de format sont
ignorés ; cependant, le nombre de répétitions et le format associé ne
doivent pas être séparés par des caractères d'espacement.

Pour le caractère de format "'s'", un nombre en tête est interprété
comme la longueur du *bytes* et non comme le nombre de répétitions
comme pour les autres caractères de format ; par exemple, "'10s'"
signifie une seule chaîne de 10 octets alors que "'10c'" signifie 10
caractères. Si aucun nombre n'est indiqué, la valeur par défaut est 1.
Pour l'agrégation, la chaîne est tronquée ou bourrée avec des octets
nuls pour atteindre la taille souhaitée. Pour la dissociation, l'objet
*bytes* résultant possède le nombre exact d'octets spécifiés. Un cas
particulier est "'0s'" qui signifie une chaîne (et une seule) vide
(alors que "'0c'" signifie zéro caractère).

Lors de l'agrégation d'une valeur "x" en utilisant l'un des formats
pour les entiers ("'b'", "'B'", "'h'", "'H'", "'i'", "'I'", "'l'",
"'L'", "'q'", "'Q'"), si "x" est en dehors de l'intervalle du format
spécifié, une "struct.error" est levée.

Modifié dans la version 3.1: auparavant, certains formats d'entiers
absorbaient les valeurs en dehors des intervalles valides et levaient
une "DeprecationWarning" au lieu d'une "struct.error".

Le caractère de format "'p'" sert à encoder une « chaîne Pascal »,
c'est-à-dire une courte chaîne de longueur variable, stockée dans un
*nombre défini d'octets* dont la valeur est définie par la répétition.
Le premier octet stocké est la longueur de la chaîne (dans la limite
maximum de 255). Les octets composant la chaîne suivent. Si la chaîne
passée à "pack()" est trop longue (supérieure à la valeur de la
répétition moins 1), seuls les "count-1" premiers octets de la chaîne
sont stockés. Si la chaîne est plus courte que "count-1", des octets
de bourrage nuls sont insérés de manière à avoir exactement *count*
octets au final. Notez que pour "unpack()", le caractère de format
"'p'" consomme "count" octets mais que la chaîne renvoyée ne peut pas
excéder 255 octets.

Pour le caractère de format "'?'", la valeur renvoyée est "True" ou
"False". Lors de l'agrégation, la valeur de vérité de l'objet argument
est utilisée. La valeur agrégée est 0 ou 1 dans la représentation
native ou standard et, lors de la dissociation, n'importe quelle
valeur différente de zéro est renvoyée "True".


Exemples
--------

Note:

  tous les exemples présentés supposent que l'on utilise le boutisme,
  la taille et l'alignement natifs sur une machine gros-boutiste.

Un exemple de base d'agrégation et dissociation de trois entiers :

   >>> from struct import *
   >>> pack('hhl', 1, 2, 3)
   b'\x00\x01\x00\x02\x00\x00\x00\x03'
   >>> unpack('hhl', b'\x00\x01\x00\x02\x00\x00\x00\x03')
   (1, 2, 3)
   >>> calcsize('hhl')
   8

Les champs dissociés peuvent être nommés en leur assignant des
variables ou en encapsulant le résultat dans un n-uplet nommé :

   >>> record = b'raymond   \x32\x12\x08\x01\x08'
   >>> name, serialnum, school, gradelevel = unpack('<10sHHb', record)

   >>> from collections import namedtuple
   >>> Student = namedtuple('Student', 'name serialnum school gradelevel')
   >>> Student._make(unpack('<10sHHb', record))
   Student(name=b'raymond   ', serialnum=4658, school=264, gradelevel=8)

L'ordre des caractères de format peut avoir un impact sur la taille
puisque le bourrage nécessaire pour réaliser l'alignement est
différent :

   >>> pack('ci', b'*', 0x12131415)
   b'*\x00\x00\x00\x12\x13\x14\x15'
   >>> pack('ic', 0x12131415, b'*')
   b'\x12\x13\x14\x15*'
   >>> calcsize('ci')
   8
   >>> calcsize('ic')
   5

Le format suivant "'llh0l'" spécifie deux octets de bourrage à la fin,
considérant que les entiers longs sont alignés sur des espacements de
4 octets :

   >>> pack('llh0l', 1, 2, 3)
   b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00'

Ceci ne fonctionne que quand la taille et l'alignement natifs sont
utilisés ; la taille et l'alignement standards ne forcent aucun
alignement.

Voir aussi:

  Module "array"
     Stockage agrégé binaire de données homogènes.

  Module "xdrlib"
     Agrégation et dissociation de données XDR.


Classes
=======

Le module "struct" définit aussi le type suivant :

class struct.Struct(format)

   Renvoie un nouvel objet Struct qui écrit et lit des données
   binaires conformément à la chaîne de format *format*. Créer une
   fois pour toutes un objet Struct puis appeler ses méthodes est plus
   efficace que d'appeler les fonctions de "struct" avec le même
   format puisque la chaîne de format n'est compilée qu'une seule
   fois.

   Note:

     les versions compilées des dernières chaînes de format passées à
     "Struct" et aux fonctions de niveau module sont mises en cache,
     de manière à ce que les programmes qui n'utilisent que quelques
     chaînes de format n'aient pas à se préoccuper de n'utiliser
     qu'une seule instance de "Struct".

   Les objets "Struct" compilés gèrent les méthodes et attributs
   suivants :

   pack(v1, v2, ...)

      Identique à la fonction "pack()", en utilisant le format compilé
      ("len(result)" vaut "size").

   pack_into(buffer, offset, v1, v2, ...)

      Identique à la fonction "pack_into()", en utilisant le format
      compilé.

   unpack(buffer)

      Identique à la fonction "unpack()", en utilisant le format
      compilé. La taille du tampon *buffer* en octets doit valoir
      "size".

   unpack_from(buffer, offset=0)

      Identical to the "unpack_from()" function, using the compiled
      format. The buffer's size in bytes, minus *offset*, must be at
      least "size".

   iter_unpack(buffer)

      Identique à la fonction "iter_unpack()", en utilisant le format
      compilé. La taille du tampon *buffer* en octets doit être un
      multiple de "size".

      Nouveau dans la version 3.4.

   format

      La chaîne de format utilisée pour construire l'objet *Struct*.

      Modifié dans la version 3.7: la chaîne de format est maintenant
      de type "str" au lieu de "bytes".

   size

      La taille calculée de la structure agrégée (et donc de l'objet
      *bytes* produit par la méthode "pack()") correspondante à
      "format".
