# 7.1. `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.

## 7.1.1. 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`(fmt, v1, v2, ...)

  Return a bytes object containing the values v1, v2, … packed according to the format string fmt. The arguments must match the values required by the format exactly.

`struct.``pack_into`(fmt, buffer, offset, v1, v2, ...)

  Pack the values v1, v2, … according to the format string fmt and write the packed bytes into the writable buffer buffer starting at position offset. Note that offset is a required argument.

`struct.``unpack`(fmt, buffer)

  Unpack from the buffer buffer (presumably packed by `pack(fmt, ...)`) according to the format string fmt. The result is a tuple even if it contains exactly one item. The buffer’s size in bytes must match the size required by the format, as reflected by `calcsize()`.

`struct.``unpack_from`(fmt, buffer, offset=0)

  Unpack from buffer starting at position offset, according to the format string fmt. 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`(fmt, buffer)

  Iteratively unpack from the buffer buffer according to the format string fmt. This function returns an iterator which will read equally-sized chunks from the buffer until all its contents have been consumed. The buffer’s size in bytes must be a multiple of the size required by the format, as reflected by `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`(fmt)

  Return the size of the struct (and hence of the bytes object produced by `pack(fmt, ...)`) corresponding to the format string fmt.

## 7.1.2. 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.

### 7.1.2.1. 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.

### 7.1.2.2. 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 d’octets) de taille 1 | 1 |
`b` | `signed char` | int (entier) | 1 | (1),(3)
`B` | `unsigned char` | int (entier) | 1 | (3)
`?` | `_Bool` | bool (booléen) | 1 | (1)
`h` | `short` | int (entier) | 2 | (3)
`H` | `unsigned short` | int (entier) | 2 | (3)
`i` | `int` | int (entier) | 4 | (3)
`I` | `unsigned int` | int (entier) | 4 | (3)
`l` | `long` | int (entier) | 4 | (3)
`L` | `unsigned long` | int (entier) | 4 | (3)
`q` | `long long` | int (entier) | 8 | (2), (3)
`Q` | `unsigned long long` | int (entier) | 8 | (2), (3)
`n` | `ssize_t` | int (entier) |  | (4)
`N` | `size_t` | int (entier) |  | (4)
`e` | (7) | float (nombre à virgule flottante) | 2 | (5)
`f` | `float` | float (nombre à virgule flottante) | 4 | (5)
`d` | `double` | float (nombre à virgule flottante) | 8 | (5)
`s` | `char[]` | bytes (séquence d’octets) |  |
`p` | `char[]` | bytes (séquence d’octets) |  |
`P` | `void *` | int (entier) |  | (6)

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. The `'q'` and `'Q'` conversion codes are available in native mode only if the platform C compiler supports C `long long`, or, on Windows, `__int64`. They are always available in standard modes.

3. 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.

4. 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.

5. 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.

6. 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.

7. 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`.

### 7.1.2.3. 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.

## 7.1.3. 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.

  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.

  `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`.