struct — Binärdaten als gepackte Binärdaten interpretieren

Quellcode: Lib/struct.py

Dieses Modul konvertiert Python-Werte und C-Strukturen, die als Python bytes-Objekte repräsentiert werden. Kompakte Formatzeichenketten beschreiben die beabsichtigten Konvertierungen zu/von Python-Werten. Die Funktionen und Objekte des Moduls können für zwei weitgehend unterschiedliche Anwendungen verwendet werden: Datenaustausch mit externen Quellen (Dateien oder Netzwerkverbindungen) oder Datentransfer zwischen der Python-Anwendung und der C-Schicht.

Hinweis

Wenn kein Präfixzeichen angegeben wird, ist der native Modus der Standard. Er packt oder entpackt Daten basierend auf der Plattform und dem Compiler, auf dem der Python-Interpreter erstellt wurde. Das Ergebnis des Packens einer gegebenen C-Struktur enthält Füllbytes, die die korrekte Ausrichtung für die beteiligten C-Typen beibehalten; ebenso wird die Ausrichtung beim Entpacken berücksichtigt. Im Gegensatz dazu ist der Programmierer beim Austausch von Daten mit externen Quellen für die Definition der Byte-Reihenfolge und der Füllung zwischen den Elementen verantwortlich. Details finden Sie unter Byte-Reihenfolge, Größe und Ausrichtung.

Mehrere struct-Funktionen (und Methoden von Struct) nehmen ein Puffer-Argument entgegen. Dies bezieht sich auf Objekte, die das Puffer-Protokoll implementieren und entweder einen lesbaren oder les-/schreibbaren Puffer bereitstellen. Die häufigsten dafür verwendeten Typen sind bytes und bytearray, aber viele andere Typen, die als Byte-Array betrachtet werden können, implementieren das Puffer-Protokoll, sodass sie ohne zusätzliche Kopien von einem bytes-Objekt gelesen/befüllt werden können.

Funktionen und Ausnahmen

Das Modul definiert die folgende Ausnahme und Funktionen

exception struct.error

Ausnahme, die bei verschiedenen Gelegenheiten ausgelöst wird; das Argument ist eine Zeichenkette, die beschreibt, was falsch ist.

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

Gibt ein Bytes-Objekt zurück, das die Werte v1, v2, … enthält, gepackt gemäß der Formatzeichenkette format. Die Argumente müssen exakt den von der Formatierung geforderten Werten entsprechen.

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

Packt die Werte v1, v2, … gemäß der Formatzeichenkette format und schreibt die gepackten Bytes ab Position offset in den beschreibbaren Puffer buffer. Beachten Sie, dass offset ein obligatorisches Argument ist.

struct.unpack(format, buffer)

Entpackt aus dem Puffer buffer (vermutlich gepackt von pack(format, ...)) gemäß der Formatzeichenkette format. Das Ergebnis ist ein Tupel, auch wenn es nur ein einziges Element enthält. Die Größe des Puffers in Bytes muss der von der Formatierung geforderten Größe entsprechen, wie sie von calcsize() reflektiert wird.

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

Entpackt aus dem Puffer buffer beginnend bei Position offset, gemäß der Formatzeichenkette format. Das Ergebnis ist ein Tupel, auch wenn es nur ein einziges Element enthält. Die Größe des Puffers in Bytes muss, beginnend bei Position offset, mindestens der von der Formatierung geforderten Größe entsprechen, wie sie von calcsize() reflektiert wird.

struct.iter_unpack(format, buffer)

Entpackt iterativ aus dem Puffer buffer gemäß der Formatzeichenkette format. Diese Funktion gibt einen Iterator zurück, der gleich große Blöcke aus dem Puffer liest, bis alle seine Inhalte verbraucht sind. Die Größe des Puffers in Bytes muss ein Vielfaches der von der Formatierung geforderten Größe sein, wie sie von calcsize() reflektiert wird.

Jede Iteration liefert ein Tupel wie durch die Formatzeichenkette angegeben.

Hinzugefügt in Version 3.4.

struct.calcsize(format)

Gibt die Größe der Struktur (und damit des von pack(format, ...) erzeugten Bytes-Objekts) zurück, die der Formatzeichenkette format entspricht.

Formatzeichenketten

Formatzeichenketten beschreiben das Datenlayout beim Packen und Entpacken von Daten. Sie werden aus Formatzeichen aufgebaut, die den Typ der zu packenden/entpackenden Daten angeben. Zusätzlich steuern Sonderzeichen die Byte-Reihenfolge, Größe und Ausrichtung. Jede Formatzeichenkette besteht aus einem optionalen Präfixzeichen, das die allgemeinen Eigenschaften der Daten beschreibt, und einem oder mehreren Formatzeichen, die die tatsächlichen Datenwerte und Füllungen beschreiben.

Byte-Reihenfolge, Größe und Ausrichtung

Standardmäßig werden C-Typen im nativen Format und Byte-Reihenfolge des Systems und mit korrekter Ausrichtung durch Überspringen von Füllbytes bei Bedarf (gemäß den Regeln des C-Compilers) dargestellt. Dieses Verhalten wird so gewählt, dass die Bytes einer gepackten Struktur exakt dem Speicherlayout der entsprechenden C-Struktur entsprechen. Ob native Byte-Reihenfolge und Füllung verwendet werden sollen oder Standardformate, hängt von der Anwendung ab.

Alternativ kann das erste Zeichen der Formatzeichenkette verwendet werden, um die Byte-Reihenfolge, Größe und Ausrichtung der gepackten Daten gemäß der folgenden Tabelle anzugeben

Zeichen

Byte-Reihenfolge

Größe

Ausrichtung

@

nativ

nativ

nativ

=

nativ

standard

keine

<

Little-Endian

standard

keine

>

Big-Endian

standard

keine

!

Netzwerk (= Big-Endian)

standard

keine

Wenn das erste Zeichen nicht eines davon ist, wird '@' angenommen.

Hinweis

Die Zahl 1023 (im Hexadezimalformat 0x3ff) hat die folgenden Byte-Darstellungen

  • 03 ff in Big-Endian (>)

  • ff 03 in Little-Endian (<)

Python-Beispiel

>>> import struct
>>> struct.pack('>h', 1023)
b'\x03\xff'
>>> struct.pack('<h', 1023)
b'\xff\x03'

Die native Byte-Reihenfolge ist Big-Endian oder Little-Endian, abhängig vom Host-System. Zum Beispiel sind Intel x86, AMD64 (x86-64) und Apple M1 Little-Endian; IBM z und viele ältere Architekturen sind Big-Endian. Verwenden Sie sys.byteorder, um die Endianness Ihres Systems zu überprüfen.

Native Größe und Ausrichtung werden mit dem sizeof-Ausdruck des C-Compilers bestimmt. Dies wird immer mit nativer Byte-Reihenfolge kombiniert.

Die Standardgröße hängt nur vom Formatzeichen ab; siehe die Tabelle im Abschnitt Formatzeichen.

Beachten Sie den Unterschied zwischen '@' und '=': Beide verwenden native Byte-Reihenfolge, aber die Größe und Ausrichtung des letzteren sind standardisiert.

Die Form '!' repräsentiert die Netzwerk-Byte-Reihenfolge, die gemäß IETF RFC 1700 immer Big-Endian ist.

Es gibt keine Möglichkeit, eine nicht-native Byte-Reihenfolge anzuzeigen (Byte-Swapping erzwingen); verwenden Sie die entsprechende Wahl von '<' oder '>'.

Hinweise

  1. Füllbytes werden nur automatisch zwischen aufeinanderfolgenden Strukturmitgliedern eingefügt. Am Anfang oder Ende der kodierten Struktur werden keine Füllbytes eingefügt.

  2. Beim Verwenden von nicht-nativen Größen und Ausrichtungen, z.B. mit „<“, „>“, „=“ und „!“, werden keine Füllbytes eingefügt.

  3. Um das Ende einer Struktur auf die Ausrichtungsanforderung eines bestimmten Typs auszurichten, beenden Sie die Formatierung mit dem Code für diesen Typ mit einem Wiederholungszähler von Null. Siehe Beispiele.

Formatzeichen

Formatzeichen haben die folgende Bedeutung; die Konvertierung zwischen C- und Python-Werten sollte aufgrund ihrer Typen offensichtlich sein. Die Spalte „Standardgröße“ bezieht sich auf die Größe des gepackten Werts in Bytes bei Verwendung der Standardgröße; das heißt, wenn die Formatzeichenkette mit einem der Zeichen '<', '>', '!' oder '=' beginnt. Bei Verwendung nativer Größe ist die Größe des gepackten Werts plattformabhängig.

Format

C-Typ

Python Typ

Standardgröße

Hinweise

x

Füllbyte

kein Wert

(7)

c

char

Bytes der Länge 1

1

b

signed char

Ganzzahl

1

(1), (2)

B

unsigned char

Ganzzahl

1

(2)

?

_Bool

bool

1

(1)

h

short

Ganzzahl

2

(2)

H

unsigned short

Ganzzahl

2

(2)

i

int

Ganzzahl

4

(2)

I

unsigned int

Ganzzahl

4

(2)

l

long

Ganzzahl

4

(2)

L

unsigned long

Ganzzahl

4

(2)

q

long long

Ganzzahl

8

(2)

Q

unsigned long long

Ganzzahl

8

(2)

n

ssize_t

Ganzzahl

(3)

N

size_t

Ganzzahl

(3)

e

(6)

float

2

(4)

f

float

float

4

(4)

d

double

float

8

(4)

F

float complex

komplex

8

(10)

D

double complex

komplex

16

(10)

s

char[]

bytes

(9)

p

char[]

bytes

(8)

P

void*

Ganzzahl

(5)

Geändert in Version 3.3: Unterstützung für die Formate 'n' und 'N' hinzugefügt.

Geändert in Version 3.6: Unterstützung für das Format 'e' hinzugefügt.

Geändert in Version 3.14: Unterstützung für die Formate 'F' und 'D' hinzugefügt.

Hinweise

  1. Der Konvertierungscode '?' entspricht dem Typ _Bool, der in C-Standards seit C99 definiert ist. Im Standardmodus wird er durch ein Byte repräsentiert.

  2. Beim Versuch, eine Nicht-Ganzzahl mit einem der Ganzzahl-Konvertierungscodes zu packen, wird, wenn die Nicht-Ganzzahl eine Methode __index__() hat, diese Methode aufgerufen, um das Argument vor dem Packen in eine Ganzzahl zu konvertieren.

    Geändert in Version 3.2: Verwendung der Methode __index__() für Nicht-Ganzzahlen hinzugefügt.

  3. Die Konvertierungscodes 'n' und 'N' sind nur für die native Größe verfügbar (ausgewählt als Standard oder mit dem Byte-Order-Zeichen '@'). Für die Standardgröße können Sie einen der anderen Ganzzahlformate verwenden, der für Ihre Anwendung geeignet ist.

  4. Für die Konvertierungscodes 'f', 'd' und 'e' verwendet die gepackte Darstellung das IEEE 754 binary32-, binary64- bzw. binary16-Format (für 'f', 'd' bzw. 'e'), unabhängig vom vom System verwendeten Gleitkommaformat.

  5. Das Formatzeichen 'P' ist nur für die native Byte-Reihenfolge verfügbar (ausgewählt als Standard oder mit dem Byte-Order-Zeichen '@'). Das Byte-Order-Zeichen '=' wählt die Little- oder Big-Endian-Reihenfolge basierend auf dem Host-System. Das struct-Modul interpretiert dies nicht als native Reihenfolge, daher ist das Format 'P' nicht verfügbar.

  6. Der IEEE 754 binäre 16-Bit-Typ „Half Precision“ wurde in der Überarbeitung des IEEE 754-Standards von 2008 eingeführt. Er hat ein Vorzeichenbit, einen 5-Bit-Exponenten und eine Genauigkeit von 11 Bits (mit 10 explizit gespeicherten Bits) und kann Zahlen zwischen ungefähr 6.1e-05 und 6.5e+04 bei voller Genauigkeit darstellen. Dieser Typ wird von C-Compilern nicht weit verbreitet unterstützt: Auf einem typischen System kann ein unsigned short zur Speicherung verwendet werden, aber nicht für mathematische Operationen. Weitere Informationen finden Sie auf der Wikipedia-Seite zum Format der Halbwerts-Gleitkommazahl.

  7. Beim Packen fügt 'x' ein NUL-Byte ein.

  8. Das Formatzeichen 'p' kodiert einen „Pascal-String“, was einen kurzen, variabel langen String bedeutet, der in einer *festen Anzahl von Bytes* gespeichert wird, die durch die Zählung angegeben wird. Das erste gespeicherte Byte ist die Länge des Strings oder 255, je nachdem, welcher Wert kleiner ist. Die Bytes des Strings folgen. Wenn der an pack() übergebene String zu lang ist (länger als die Zählung minus 1), werden nur die führenden count-1 Bytes des Strings gespeichert. Wenn der String kürzer als count-1 ist, wird er mit Null-Bytes aufgefüllt, sodass insgesamt genau count Bytes verwendet werden. Beachten Sie, dass für unpack() das Formatzeichen 'p' count Bytes verbraucht, aber der zurückgegebene String niemals mehr als 255 Bytes enthalten kann.

  9. Für das Formatzeichen 's' wird die Zählung als Länge der Bytes interpretiert, nicht als Wiederholungszähler wie bei den anderen Formatzeichen; zum Beispiel bedeutet '10s' einen einzelnen 10-Byte-String, der zu oder von einem einzelnen Python-Byte-String abgebildet wird, während '10c' 10 separate Ein-Byte-Zeichenelemente bedeutet (z.B. cccccccccc), die zu oder von zehn verschiedenen Python-Byte-Objekten abgebildet werden. (Siehe Beispiele für eine konkrete Demonstration des Unterschieds.) Wenn keine Zählung angegeben wird, ist der Standardwert 1. Beim Packen wird der String gekürzt oder mit Null-Bytes aufgefüllt, um ihn anzupassen. Beim Entpacken hat das resultierende Bytes-Objekt immer genau die angegebene Anzahl von Bytes. Als Sonderfall bedeutet '0s' einen einzelnen, leeren String (während '0c' 0 Zeichen bedeutet).

  10. Für die Formatzeichen 'F' und 'D' verwendet die gepackte Darstellung das IEEE 754 binary32- bzw. binary64-Format für Komponenten der komplexen Zahl, unabhängig vom vom System verwendeten Gleitkommaformat. Beachten Sie, dass komplexe Typen (F und D) bedingungslos verfügbar sind, obwohl komplexe Typen in C eine optionale Funktion sind. Wie im C11-Standard spezifiziert, wird jeder komplexe Typ durch ein zweielementiges C-Array repräsentiert, das jeweils den Real- und Imaginärteil enthält.

Einem Formatzeichen kann ein ganzzahliger Wiederholungszähler vorangestellt sein. Zum Beispiel bedeutet die Formatzeichenkette '4h' genau dasselbe wie 'hhhh'.

Leerzeichen zwischen den Formaten werden ignoriert; ein Zähler und sein Format dürfen jedoch keine Leerzeichen enthalten.

Beim Packen eines Werts x mit einem der Ganzzahlformate ('b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q'), wird, wenn x außerhalb des gültigen Bereichs für dieses Format liegt, struct.error ausgelöst.

Geändert in Version 3.1: Zuvor wickelten einige der Ganzzahlformate Werte außerhalb des Bereichs und lösten stattdessen eine DeprecationWarning anstelle einer struct.error aus.

Für das Formatzeichen '?' ist der Rückgabewert entweder True oder False. Beim Packen wird der Wahrheitswert des Argumentobjekts verwendet. Entweder 0 oder 1 in der nativen oder Standard-Bool-Darstellung wird gepackt, und jeder Wert ungleich Null ist beim Entpacken True.

Beispiele

Hinweis

Beispiele für native Byte-Reihenfolge (bezeichnet durch das Formatpräfix '@' oder das Fehlen eines Präfixzeichens) stimmen möglicherweise nicht mit dem überein, was die Maschine des Lesers erzeugt, da dies von der Plattform und dem Compiler abhängt.

Packen und Entpacken von Ganzzahlen dreier verschiedener Größen, mit Big-Endian-Reihenfolge

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

Versuch, eine Ganzzahl zu packen, die zu groß für das definierte Feld ist

>>> pack(">h", 99999)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
struct.error: 'h' format requires -32768 <= number <= 32767

Demonstration des Unterschieds zwischen den Formatzeichen 's' und 'c'

>>> pack("@ccc", b'1', b'2', b'3')
b'123'
>>> pack("@3s", b'123')
b'123'

Entpackte Felder können benannt werden, indem sie Variablen zugewiesen oder das Ergebnis in einem benannten Tupel verpackt wird

>>> 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)

Die Reihenfolge der Formatzeichen kann im nativen Modus die Größe beeinflussen, da die Ausrichtung implizit ist. Im Standardmodus ist der Benutzer für das Einfügen jeglicher gewünschter Füllung verantwortlich. Beachten Sie im ersten pack-Aufruf unten, dass drei NUL-Bytes nach dem gepackten '#' eingefügt wurden, um die folgende Ganzzahl an einer Vier-Byte-Grenze auszurichten. In diesem Beispiel wurde die Ausgabe auf einer Little-Endian-Maschine erzeugt

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

Die folgende Formatierung 'llh0l' führt zu zwei zusätzlichen Füllbytes am Ende, vorausgesetzt, die Longs der Plattform sind an 4-Byte-Grenzen ausgerichtet.

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

Siehe auch

Modul array

Gepackte Binärspeicherung homogener Daten.

Modul json

JSON-Kodierer und -Dekodierer.

Modul pickle

Python-Objekt-Serialisierung.

Anwendungen

Zwei Hauptanwendungen für das struct-Modul existieren: Datenaustausch zwischen Python und C-Code innerhalb einer Anwendung oder einer anderen Anwendung, die mit demselben Compiler kompiliert wurde (native Formate), und Datenaustausch zwischen Anwendungen unter Verwendung eines vereinbarten Datenlayouts (Standardformate). Im Allgemeinen sind die für diese beiden Bereiche konstruierten Formatzeichenketten unterschiedlich.

Native Formate

Beim Konstruieren von Formatzeichenketten, die native Layouts nachahmen, bestimmen Compiler und Maschinenarchitektur die Byte-Reihenfolge und die Füllung. In solchen Fällen sollte das Formatzeichen @ verwendet werden, um die native Byte-Reihenfolge und Datengrößen anzugeben. Interne Füllbytes werden normalerweise automatisch eingefügt. Es ist möglich, dass ein Formatcode mit Wiederholungszahl Null am Ende einer Formatzeichenkette benötigt wird, um auf die richtige Byte-Grenze für die korrekte Ausrichtung von aufeinanderfolgenden Datenblöcken aufzurunden.

Betrachten Sie diese beiden einfachen Beispiele (auf einer 64-Bit-, Little-Endian-Maschine)

>>> calcsize('@lhl')
24
>>> calcsize('@llh')
18

Daten werden am Ende der zweiten Formatzeichenkette ohne zusätzliche Füllung nicht auf eine 8-Byte-Grenze aufgefüllt. Ein Formatcode mit Wiederholungszahl Null löst dieses Problem

>>> calcsize('@llh0l')
24

Der Formatcode 'x' kann zur Angabe der Wiederholung verwendet werden, aber für native Formate ist es besser, einen Formatcode mit Wiederholungszahl Null wie '0l' zu verwenden.

Standardmäßig werden native Byte-Reihenfolge und Ausrichtung verwendet, aber es ist besser, explizit zu sein und das Präfixzeichen '@' zu verwenden.

Standardformate

Beim Austausch von Daten außerhalb Ihres Prozesses, z.B. im Netzwerk oder in der Speicherung, seien Sie präzise. Geben Sie die genaue Byte-Reihenfolge, Größe und Ausrichtung an. Gehen Sie nicht davon aus, dass sie mit der nativen Reihenfolge einer bestimmten Maschine übereinstimmen. Die Netzwerk-Byte-Reihenfolge ist beispielsweise Big-Endian, während viele beliebte CPUs Little-Endian sind. Durch explizites Definieren dieser Parameter muss der Benutzer die Spezifika der Plattform, auf der sein Code läuft, nicht berücksichtigen. Das erste Zeichen sollte typischerweise < oder > (oder !) sein. Die Füllung liegt in der Verantwortung des Programmierers. Der Null-Wiederholungs-Formatzeichen wird nicht funktionieren. Stattdessen muss der Benutzer explizit 'x' Füllbytes dort einfügen, wo sie benötigt werden. Rückblickend auf die Beispiele aus dem vorherigen Abschnitt haben wir

>>> calcsize('<qh6xq')
24
>>> pack('<qh6xq', 1, 2, 3) == pack('@lhl', 1, 2, 3)
True
>>> calcsize('@llh')
18
>>> pack('@llh', 1, 2, 3) == pack('<qqh', 1, 2, 3)
True
>>> calcsize('<qqh6x')
24
>>> calcsize('@llh0l')
24
>>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3)
True

Die obigen Ergebnisse (ausgeführt auf einer 64-Bit-Maschine) sind nicht garantiert identisch, wenn sie auf verschiedenen Maschinen ausgeführt werden. Zum Beispiel wurden die folgenden Beispiele auf einer 32-Bit-Maschine ausgeführt

>>> calcsize('<qqh6x')
24
>>> calcsize('@llh0l')
12
>>> pack('@llh0l', 1, 2, 3) == pack('<qqh6x', 1, 2, 3)
False

Klassen

Das struct-Modul definiert auch den folgenden Typ

class struct.Struct(format)

Gibt ein neues Struct-Objekt zurück, das Binärdaten gemäß der Formatzeichenkette format schreibt und liest. Das einmalige Erstellen eines Struct-Objekts und das Aufrufen seiner Methoden ist effizienter als das Aufrufen von Modul-Funktionen mit derselben Formatierung, da die Formatzeichenkette nur einmal kompiliert wird.

Hinweis

Die kompilierten Versionen der zuletzt an die Modul-Funktionen übergebenen Formatzeichenketten werden zwischengespeichert, sodass Programme, die nur wenige Formatzeichenketten verwenden, sich keine Sorgen machen müssen, eine einzelne Struct-Instanz wiederzuverwenden.

Kompilierte Struct-Objekte unterstützen die folgenden Methoden und Attribute

pack(v1, v2, ...)

Identisch zur Funktion pack(), unter Verwendung des kompilierten Formats. (len(result) wird gleich size sein.)

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

Identisch zur Funktion pack_into(), unter Verwendung des kompilierten Formats.

unpack(buffer)

Identisch zur Funktion unpack(), unter Verwendung des kompilierten Formats. Die Größe des Puffers in Bytes muss gleich size sein.

unpack_from(buffer, offset=0)

Identisch zur Funktion unpack_from(), unter Verwendung des kompilierten Formats. Die Größe des Puffers in Bytes, beginnend bei Position offset, muss mindestens size betragen.

iter_unpack(buffer)

Identisch zur Funktion iter_unpack(), unter Verwendung des kompilierten Formats. Die Größe des Puffers in Bytes muss ein Vielfaches von size sein.

Hinzugefügt in Version 3.4.

format

Die Formatzeichenkette, die zum Erstellen dieses Struct-Objekts verwendet wurde.

Geändert in Version 3.7: Der Typ der Formatzeichenkette ist jetzt str anstelle von bytes.

size

Die berechnete Größe der Struktur (und damit des von der Methode pack() erzeugten Bytes-Objekts), die format entspricht.

Geändert in Version 3.13: Das repr() von Structs hat sich geändert. Es ist jetzt

>>> Struct('i')
Struct('i')