Ce module est conçu pour compléterPythonValeurs etCStructure linguistiquePythonConversion entre les formes de chaîne.Ceci peut être utilisé pour traiter des données binaires stockées dans des fichiers ou à partir d'une connexion réseau,Et d'autres sources de données.
Objet: InPythonConversion entre le type de données de base et les données binaires
structLe module est disponible pour les chaînes d'octets etPythonFonction de conversion entre les types de données natives,Comme les nombres et les chaînes.
En plus de fournir unStructEn dehors de la classe,Il existe également de nombreuses fonctions au niveau des modules pour traiter les valeurs structurées.Voici un formateur(Format specifiers)Le concept de,.Est la conversion d'un format de chaîne à une représentation compilée,Un traitement similaire à celui des expressions régulières.Généralement instantanéStructCatégorie,Appelez la méthode de classe pour compléter la transformation,Plus efficace que d'appeler directement les fonctions du module.Les exemples suivants sont utilisésStructCatégorie.
StructPrise en charge des donnéespacking(Emballez)String,Et peut être inversé à partir d'une chaîneunpacking(Décompresser)Données de sortie.
Dans ce cas,,Spécificateur de format(specifier)Nécessite un entier ou un long entier,Un double octetstring,Et un flotteur.Les espaces dans les formats sont utilisés pour séparer les indicateurs individuels(indicators),Est ignoré lors de la compilation du format.
import struct
import binascii
values = (1, 'ab'.encode('utf-8'), 2.7)
s = struct.Struct('I 2s f')
packed_data = s.pack(*values)
print('Valeur initiale:', values)
print('Formateur:', s.format)
print('Octets occupés:', s.size)
print('Résultats de l'emballage:', binascii.hexlify(packed_data))
# output
Valeur initiale: (1, b'ab', 2.7)
Formateur: b'I 2s f'
Octets occupés: 12
Résultats de l'emballage: b'0100000061620000cdcc2c40'
Cet exemple convertit une valeur emballée en une séquence d'octets hexadécimaux ,Avecbinascii.hexlify()Méthode d'impression.
Utiliserunpack() Méthode de déballage .
import struct
import binascii
packed_data = binascii.unhexlify(b'0100000061620000cdcc2c40')
s = struct.Struct('I 2s f')
unpacked_data = s.unpack(packed_data)
print(' Résultats du déballage :', unpacked_data)
# output
Résultats du déballage : (1, b'ab', 2.700000047683716)
Passer les valeurs emballées à unpack(), Renvoie essentiellement la même valeur ( Le nombre de points flottants peut varier ).
Par défaut,pack Est d'utiliser local C La bibliothèque est codée dans l'ordre des octets . Le premier caractère de la chaîne formatée peut être utilisé pour représenter l'ordre des octets remplis de données 、Taille et alignement, Comme indiqué dans le tableau ci - dessous :
Si elles ne sont pas définies dans le formateur ,Par défaut @.
L'ordre local des octets signifie que l'ordre des octets est déterminé par le système hôte actuel. .Par exemple,：Intel x86EtAMD64(x86-64) Utiliser un ordre de petits octets ; Motorola 68000Et PowerPC G5 Utiliser l'ordre des grands octets .ARMEtIntel Itanium prend en charge la commutation de l'ordre des octets .Peut être utilisésys.byteorder Afficher l'ordre des octets du système actuel .
Taille locale (Size)Et alignement(Alignment)C'est parcCompilateursizeof Expression déterminée . Il correspond à l'ordre local des octets .
La taille standard est déterminée par le formateur , Les tailles standard pour chaque format sont décrites ci - dessous. .
Exemple:
''' Les problèmes rencontrés dans l'étude n'ont pas été résolus？Le petit compilateur a créé unPythonApprentissage et communicationQQGroupe：711312441 À la recherche de petits amis partageant les mêmes idées,S'entraider,Il y a aussi de bons tutoriels d'apprentissage vidéo etPDFLivres électroniques！ '''
import struct
import binascii
values = (1, 'ab'.encode('utf-8'), 2.7)
print('Valeur initiale : ', values)
endianness = [
('@', 'native, native'),
('=', 'native, standard'),
('<', 'little-endian'),
('>', 'big-endian'),
('!', 'network'),
]
for code, name in endianness:
s = struct.Struct(code + ' I 2s f')
packed_data = s.pack(*values)
print()
print('Formateur : ', s.format, 'for', name)
print('Octets occupés: ', s.size)
print('Résultats de l'emballage: ', binascii.hexlify(packed_data))
print(' Résultats du déballage : ', s.unpack(packed_data))
# output
Valeur initiale : (1, b'ab', 2.7)
Formateur : b'@ I 2s f' for native, native
Octets occupés: 12
Résultats de l'emballage: b'0100000061620000cdcc2c40'
Résultats du déballage : (1, b'ab', 2.700000047683716)
Formateur : b'= I 2s f' for native, standard
Octets occupés: 10
Résultats de l'emballage: b'010000006162cdcc2c40'
Résultats du déballage : (1, b'ab', 2.700000047683716)
Formateur : b'< I 2s f' for little-endian
Octets occupés: 10
Résultats de l'emballage: b'010000006162cdcc2c40'
Résultats du déballage : (1, b'ab', 2.700000047683716)
Formateur : b'> I 2s f' for big-endian
Octets occupés: 10
Résultats de l'emballage: b'000000016162402ccccd'
Résultats du déballage : (1, b'ab', 2.700000047683716)
Formateur : b'! I 2s f' for network
Octets occupés: 10
Résultats de l'emballage: b'000000016162402ccccd'
Résultats du déballage : (1, b'ab', 2.700000047683716)
Le tableau de référence des formats est le suivant: :
L'emballage des données en binaires est souvent utilisé dans des scénarios très exigeants en matière de performance. .
Dans de tels scénarios, vous pouvez optimiser en évitant les frais généraux d'attribution de nouveaux tampons à chaque structure d'emballage .
pack_into()Etunpack_from() La méthode prend en charge l'écriture directe dans les tampons préalloués .
import array
import binascii
import ctypes
import struct
s = struct.Struct('I 2s f')
values = (1, 'ab'.encode('utf-8'), 2.7)
print('Valeur initiale:', values)
print()
print('UtiliserctypesModulestring buffer')
b = ctypes.create_string_buffer(s.size)
print('Originalbuffer :', binascii.hexlify(b.raw))
s.pack_into(b, 0, *values)
print(' Écrire les résultats de l'emballage :', binascii.hexlify(b.raw))
print('Déballage :', s.unpack_from(b, 0))
print()
print('UtiliserarrayModule')
a = array.array('b', b'\0' * s.size)
print('Valeur initiale :', binascii.hexlify(a))
s.pack_into(a, 0, *values)
print(' Package Write :', binascii.hexlify(a))
print('Déballage :', s.unpack_from(a, 0))
# output
Valeur initiale: (1, b'ab', 2.7)
UtiliserctypesModulestring buffer
Originalbuffer : b'000000000000000000000000'
Écrire les résultats de l'emballage : b'0100000061620000cdcc2c40'
Déballage : (1, b'ab', 2.700000047683716)
UtiliserarrayModule
Valeur initiale : b'000000000000000000000000'
Package Write : b'0100000061620000cdcc2c40'
Déballage : (1, b'ab', 2.700000047683716)
