Heading

Le module Python struct est utilisé pour fournir une interface Python simple pour accéder et manipuler le datatype structure du C. Cela peut être un outil pratique si jamais vous avez besoin de traiter du code C et que vous n’avez pas le temps d’écrire des outils en C puisque c’est un langage de bas niveau.

Ce module peut convertir des valeurs Python en une structure C et vice-versa. La structure C est utilisée comme un objet Python bytes puisqu’il n’y a rien appelé objet en C ; seulement des structures de données de la taille d’un octet.

Comprenons comment nous pouvons utiliser ce module pour avoir une interface Python aux structures C.

Méthodes du module struct Python

Dans ce module, puisque nous sommes concernés par les structures C, examinons certaines des fonctions que ce module nous fournit.

struct.pack()

Ceci est utilisé pour empaqueter des éléments dans une chaîne d’octets Python (objet octet). Puisque le mode de stockage est basé sur les octets, les programmes basés sur C peuvent utiliser la sortie de pack(), d’un programme Python.

Format : struct.pack(format, v1, v2, …)

v1v2, … sont les valeurs qui seront empaquetées dans l’objet byte. Elles représentent les valeurs des champs de la structure C. Comme une structure C ayant des champs n doit exactement avoir des valeurs n, les arguments doivent correspondre exactement aux valeurs requises par le format.

Ici, format fait référence au format de l’empaquetage. Cela est nécessaire puisque nous devons spécifier le type de données de la chaîne d’octets, comme il est utilisé avec le code C. Le tableau ci-dessous répertorie les valeurs les plus courantes pour format. Nous avons besoin d’un format par valeur pour préciser son type de données.

Comprenons cela à l’aide de quelques exemples.

Le snippet ci-dessous stocke les 3 entiers 1, 2 et 3 dans un objet octet en utilisant pack(). Comme la taille d’un entier est de 4 octets sur ma machine, vous voyez 3 blocs de 4 octets, qui correspondent à 3 entiers en C.

import struct# We pack 3 integers, so 'iii' is requiredvariable = struct.pack('iii', 1, 2, 3)print(type(variable), variable)variable_2 = struct.pack('iic', 1, 2, b'A')print('\n', variable_2)

Sortie

<class 'bytes'> b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'b'\x01\x00\x00\x00\x02\x00\x00\x00A'

Si le type approprié n’est pas passé, l’exception struct.error sera levée par le module struct de Python.

import struct# Error!! Incorrect datatype assignmentvariable = struct.pack('ccc', 1, 2, 3)print(type(variable), variable)

Sortie

struct.error: char format requires a bytes object of length 1

struct.unpack()

Cette fonction du module struct Python, dépaquette la valeur empaquetée dans sa représentation originale selon un format approprié. Elle renvoie un tuple de taille égale au nombre de valeurs passées depuis que l’objet octet est dépaqueté pour donner les éléments.

Format : struct.unpack(format, string)

Ceci dépaquette l’octet string selon le spécificateur de format format.

C’est l’inverse de struct.pack(). Prenons une des anciennes chaînes d’octets que nous avons produites en utilisant cela et essayons de récupérer les valeurs python qui lui ont été passées en utilisant unpack().

import structbyte_str = b'\x01\x00\x00\x00\x02\x00\x00\x00A'# Using the same format specifier as before, since# we want to get Python values for the same byte-stringtuple_vals = struct.unpack('iic', byte_str)print(tuple_vals)

Sortie

(1, 2, b'A')

Comme vous pouvez le voir, en effet, nous pouvons obtenir pack nos anciennes valeurs Python à partir de ce tuple, à condition d’utiliser le même spécificateur de format pour pack() et unpack().

Struct.calcsize()

Cette fonction renvoie la taille totale de la représentation String de la struct en utilisant un spécificateur de format donné, pour récupérer les types des données et calculer la taille.

Format : struct.calcsize(fmt)

import structprint('C Integer Size in Bytes:', struct.calcsize('i'))print('Size of 3 characters in Bytes:', struct.calcsize('ccc'))

Output

C Integer Size in Bytes: 4Size of 3 characters in Bytes: 3

struct.pack_into()

Cette fonction sert à emballer des valeurs dans un tampon de chaîne Python, disponible dans le module ctypes.

Format : struct.pack_into(fmt, buffer, offset, v1, v2, …)

Ici, fmt fait référence au spécificateur de format, comme toujours. buffer est le tampon de chaîne qui contiendra désormais les valeurs emballées, spécifiées. Vous pouvez également spécifier un offset emplacement de l’adresse de base à partir duquel l’empaquetage se produira.

Cette commande ne renvoie aucune valeur, et stocke simplement les valeurs dans la buffer chaîne de caractères.

import struct import ctypes # We will create a string buffer having a size# equal to that of a struct with 'iic' values.buf_size = struct.calcsize('iic') # Create the string bufferbuff = ctypes.create_string_buffer(buf_size) # struct.pack() returns the packed data struct.pack_into('iic', buff, 0, 1, 2, b'A')print(buff)# Display the contents of the bufferprint(buff)

Sortie

<ctypes.c_char_Array_9 object at 0x7f4bccef1040>b'\x01\x00\x00\x00\x02\x00\x00\x00A'

En effet, nous obtenons nos valeurs emballées dans la chaîne tampon.

struct.unpack_from()

Similaire à unpack(), une contrepartie existe pour déballer les valeurs d’une chaîne tampon. Cela fait l’inverse de struct.pack_into().

Format : struct.unpack_from(fmt, buffer, offset)

Cela retournera un tuple de valeurs, similaire à struct.unpack().

import struct import ctypes # We will create a string buffer having a size# equal to that of a struct with 'iic' values.buf_size = struct.calcsize('iic') # Create the string bufferbuff = ctypes.create_string_buffer(buf_size) # struct.pack() returns the packed data struct.pack_into('iic', buff, 0, 1, 2, b'A')print(struct.unpack_from('iic', buff, 0))

Output

(1, 2, b'A')

Conclusion

Dans cet article, nous avons appris à utiliser le module structure de Python pour traiter des objets de structure de type C.