# `struct` — Ερμηνεία bytes ως πακετοποιημένα δυαδικά δεδομένα

Πηγαίος κώδικας: Lib/struct.py

Αυτό το module μετατρέπει μεταξύ τιμών της Python και δομών της C που αναπαρίστανται ως αντικείμενα `bytes` της Python. Συμπαγείς format strings περιγράφουν τις προβλεπόμενες μετατροπές από/προς τιμές της Python. Οι συναρτήσεις και τα αντικείμενα του module μπορούν να χρησιμοποιηθούν για δύο κυρίως εφαρμογές: την ανταλλαγή δεδομένων με εξωτερικές πηγές (αρχεία ή συνδέσεις δικτύου) ή τη μεταφορά δεδομένων μεταξύ της εφαρμογής Python και του επιπέδου C.

Σημείωση

Όταν δεν δίνεται χαρακτήρας προθέματος, η προεπιλεγμένη λειτουργία είναι η εγγενής (native mode). Πακετάρει ή αποσυμπιέζει δεδομένα με βάση την πλατφόρμα και τον μεταγλωττιστή με τον οποίο κατασκευάστηκε ο διερμηνέας της Python. Το αποτέλεσμα της συσκευασίας μιας δεδομένης δομής C περιλαμβάνει συμπληρωματικά bytes (pad bytes) που διατηρούν τη σωστή στοίχιση για τους εμπλεκόμενους τύπους C· παρομοίως, η στοίχιση λαμβάνεται υπόψη κατά την αποσυσκευασία. Αντίθετα, κατά την επικοινωνία δεδομένων με εξωτερικές πηγές, ο προγραμματιστής είναι υπεύθυνος για τον καθορισμό της σειράς byte και του συμπληρώματος μεταξύ των στοιχείων. Δείτε Διάταξη Byte, Μέγεθος και Στοίχιση για λεπτομέρειες.

Several `struct` functions (and methods of `Struct`) take a buffer argument. This refers to objects that implement the Buffer Protocol and provide either a readable or read-writable buffer. The most common types used for that purpose are `bytes` and `bytearray`, but many other types that can be viewed as an array of bytes implement the buffer protocol, so that they can be read/filled without additional copying from a `bytes` object.

## Συναρτήσεις και εξαιρέσεις

Το module ορίζει την ακόλουθη εξαίρεση και συναρτήσεις:

exception struct.error

  Εξαίρεση που γίνεται raise σε διάφορες περιπτώσεις· το όρισμα είναι μια συμβολοσειρά που περιγράφει το σφάλμα.

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

  Επιστρέφει ένα αντικείμενο τύπου bytes που περιέχει τις τιμές v1, v2, … πακεταρισμένες σύμφωνα με τη συμβολοσειρά μορφοποίησης format. Τα ορίσματα πρέπει να ταιριάζουν ακριβώς με τις απαιτούμενες τιμές της μορφοποίησης.

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

  Πακετάρει τις τιμές v1, v2, … σύμφωνα με τη συμβολοσειρά μορφοποίησης format και γράφει τα πακεταρισμένα bytes στον εγγράψιμο buffer buffer ξεκινώντας από τη θέση offset. Σημειώστε ότι το offset είναι υποχρεωτικό όρισμα.

struct.unpack(format, buffer)

  Αποσυμπιέζει από τον buffer buffer (ο οποίος υποτίθεται έχει πακεταριστεί με τη μέθοδο `pack(format, ...)`) σύμφωνα με την συμβολοσειρά μορφοποίησης format. Το αποτέλεσμα είναι μια πλειάδα, ακόμα κι αν περιέχει μόνο ένα στοιχείο. Το μέγεθος του buffer σε bytes πρέπει να ταιριάζει με το απαιτούμενο μέγεθος σύμφωνα με τη μορφή, όπως καθορίζεται από τη συνάρτηση `calcsize()`.

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

  Αποσυμπιέζει από τον buffer ξεκινώντας από τη θέση offset, σύμφωνα με τη συμβολοσειρά μορφοποίησης format. Το αποτέλεσμα είναι μια πλειάδα, ακόμα κι αν περιέχει μόνο ένα στοιχείο. Το μέγεθος του buffer σε bytes, ξεκινώντας από τη θέση offset, πρέπει να είναι τουλάχιστον το μέγεθος που απαιτείται από τη μορφή, όπως καθορίζεται από τη συνάρτηση `calcsize()`.

struct.iter_unpack(format, buffer)

  Αποσυμπιέζει επαναληπτικά από τον buffer buffer σύμφωνα με τη συμβολοσειρά μορφοποίησης format. Αυτή η συνάρτηση επιστρέφει έναν iterator ο οποίος θα διαβάσει κομμάτια ίδιου μεγέθους από τον buffer μέχρι να καταναλωθούν όλα τα περιεχόμενά του. Το μέγεθος του buffer σε bytes πρέπει να είναι πολλαπλάσιο του μεγέθους που απαιτείται από τη μορφή, όπως καθορίζεται από τη συνάρτηση `calcsize()`.

  Κάθε επανάληψη επιστρέφει μια πλειάδα σύμφωνα με τη συμβολοσειρά μορφοποίησης.

  Added in version 3.4.

struct.calcsize(format)

  Επιστρέφει το μέγεθος της δομής (και κατά συνέπεια του αντικειμένου bytes που παράγεται από το `pack(format, ...)`) που αντιστοιχεί στη συμβολοσειρά μορφοποίησης format.

## Συμβολοσειρές μορφοποίησης

Format strings describe the data layout when packing and unpacking data. They are built up from type codes, which specify the type of data being packed/unpacked. In addition, special characters control the byte order, size and alignment. Each format string consists of an optional prefix character which describes the overall properties of the data and one or more format characters which describe the actual data values and padding.

### Διάταξη Byte, Μέγεθος και Στοίχιση

Από προεπιλογή, οι τύποι της C αναπαρίστανται στη φυσική μορφή και διάταξη byte της μηχανής και ευθυγραμμίζονται σωστά, παραλείποντας byte γεμίσματος εάν είναι απαραίτητο (σύμφωνα με τους κανόνες που χρησιμοποιεί ο μεταγλωττιστής C). Αυτή η συμπεριφορά επιλέγεται έτσι ώστε τα byte μιας συσκευασμένης δομής να αντιστοιχούν ακριβώς στη διάταξη μνήμης της αντίστοιχης δομής της C. Το αν θα χρησιμοποιηθεί φυσική διάταξη byte και γέμισμα ή τυποποιημένες μορφές εξαρτάται από την εφαρμογή.

Εναλλακτικά, ο πρώτος χαρακτήρας της συμβολοσειράς μορφοποίησης μπορεί να χρησιμοποιηθεί για να υποδείξει τη σειρά byte, το μέγεθος και την ευθυγράμμιση των συσκευασμένων δεδομένων, σύμφωνα με το παρακάτω πίνακα:

Χαρακτήρας | Σειρά bytes | Μέγεθος | Στοίχιση
--- | --- | --- | ---
`@` | native | native | native
`=` | native | τυπικό | κανένα
`<` | little-endian | τυπικό | κανένα
`>` | big-endian | τυπικό | κανένα
`!` | δίκτυο (= big-endian) | τυπικό | κανένα

Αν ο πρώτος χαρακτήρας δεν είναι ένας από αυτούς, υποτίθεται `'@'`.

Σημείωση

Ο αριθμός 1023 (`0x3ff` σε δεκαεξαδική μορφή) έχει τις ακόλουθες αναπαραστάσεις σε byte:

- `03 ff` σε big-endian (`>`)

- `ff 03` σε little-endian (`<`)

Παράδειγμα Python:

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

Η native σειρά byte είναι big-endian ή little-endian, ανάλογα με το σύστημα υποδοχής. Για παράδειγμα, οι Intel x86, AMD64 (x86-64) και Apple M1 είναι little-endian, ενώ οι IBM z και πολλές παλαιότερες αρχιτεκτονικές είναι big-endian. Χρησιμοποιήστε τη μεταβλητή `sys.byteorder` για να ελέγξετε το endianness του συστήματος σας.

Το native μέγεθος και η στοίχιση καθορίζονται χρησιμοποιώντας την έκφραση `sizeof` του μεταγλωττιστή C. Αυτό συνδυάζεται πάντα με την native σειρά byte.

Standard size depends only on the type code; see the table in the Type Codes section.

Σημειώστε τη διαφορά μεταξύ του `'@'` και `'='`: και τα δύο χρησιμοποιούν τη native σειρά byte, αλλά το μέγεθος και η στοίχιση του τελευταίου είναι τυποποιημένα.

Η μορφή `'!'` αντιπροσωπεύει τη σειρά byte του δικτύου, η οποία είναι πάντα big-endian όπως ορίζεται στο IETF RFC 1700.

Δεν υπάρχει τρόπος να δηλωθεί non-native σειρά byte (να επιβληθεί εναλλαγή byte). Χρησιμοποιήστε την κατάλληλη επιλογή `'<'` ή `'>'`.

Σημειώσεις:

1. Το συμπλήρωμα (padding) προστίθεται αυτόματα μόνο μεταξύ διαδοχικών μελών της δομής. Δεν προστίθεται συμπλήρωμα στην αρχή ή στο τέλος της κωδικοποιημένης δομής.

2. Δεν προστίθεται συμπλήρωμα όταν χρησιμοποιείται non-native μέγεθος και στοίχιση, π.χ. με “<”,”>”, “=”, και “!”.

3. Για να ευθυγραμμίσετε το τέλος μιας δομής με την απαίτηση στοίχισης ενός συγκεκριμένου τύπου, τελειώστε τη μορφή με τον κωδικό για αυτό τον τύπο με πλήθος επαναλήψεων μηδέν. Δείτε Παραδείγματα.

### Type Codes

Type codes (or format codes) have the following meaning; the conversion between C and Python values should be obvious given their types. The “Standard size” column refers to the size of the packed value in bytes when using standard size; that is, when the format string starts with one of `'<'`, `'>'`, `'!'` or `'='`. When using native size, the size of the packed value is platform-dependent.

Μορφή | Τύπος C | Τύπος Python | Τυπικό μέγεθος | Σημειώσεις
--- | --- | --- | --- | ---
`x` | συμπληρωματικό byte | καμία τιμή |  | (7)
`c` | char | bytes μήκους 1 | 1 |
`b` | signed char | int | 1 | (2)
`B` | unsigned char | int | 1 | (2)
`?` | _Bool | bool | 1 | (1)
`h` | short | int | 2 | (2)
`H` | unsigned short | int | 2 | (2)
`i` | int | int | 4 | (2)
`I` | unsigned int | int | 4 | (2)
`l` | long | int | 4 | (2)
`L` | unsigned long | int | 4 | (2)
`q` | long long | int | 8 | (2)
`Q` | unsigned long long | int | 8 | (2)
`n` | `ssize_t` | int |  | (2), (3)
`N` | `size_t` | int |  | (2), (3)
`e` | _Float16 | float | 2 | (4), (6)
`f` | float | float | 4 | (4)
`d` | double | float | 8 | (4)
`F` | float complex | μιγαδικός | 8 | (10)
`D` | double complex | μιγαδικός | 16 | (10)
`Zf` | float complex | μιγαδικός | 8 | (10)
`Zd` | double complex | μιγαδικός | 16 | (10)
`s` | char[] | bytes |  | (9)
`p` | char[] | bytes |  | (8)
`P` | void* | int |  | (2), (5)

Άλλαξε στην έκδοση 3.3: Προστέθηκε υποστήριξη για τις μορφές `'n'` και `'N'`.

Άλλαξε στην έκδοση 3.6: Προστέθηκε υποστήριξη για τη μορφή `'e'`.

Άλλαξε στην έκδοση 3.14: Προστέθηκε υποστήριξη για τις μορφές `'F'` και `'D'`.

Άλλαξε στην έκδοση 3.15: Added support for the `'Zf'` and `'Zd'` formats.

Δείτε επίσης

The `array` and ctypes modules, as well as third-party modules like numpy, use similar – but slightly different – type codes.

Σημειώσεις:

1. Ο κωδικός μετατροπής `'?'` αντιστοιχεί στον τύπο _Bool που ορίζεται από τα πρότυπα C από την έκδοση C99. Σε τυπική λειτουργία, αναπαρίσταται από ένα byte.

2. Όταν επιχειρείται η συσκευασία ενός μη ακέραιου αριθμού χρησιμοποιώντας οποιονδήποτε από τους κωδικούς μετατροπής ακεραίων, αν το αντικείμενο διαθέτει τη μέθοδο `__index__()`, τότε καλείται αυτή η μέθοδος για τη μετατροπή του ορίσματος σε ακέραιο πριν από τη συσκευασία.

   Άλλαξε στην έκδοση 3.2: Προστέθηκε η χρήση της μεθόδου `__index__()` για μη ακέραιους αριθμούς.

3. Οι κωδικοί μετατροπής `'n'` και `'N'` είναι διαθέσιμοι μόνο για το native μέγεθος (επιλεγμένο ως προεπιλογή ή με τον χαρακτήρα διάταξης byte `'@'`). Για το τυπικό μέγεθος, μπορείτε να χρησιμοποιήσετε οποιαδήποτε από τις άλλες μορφές ακέραιων που ταιριάζουν στην εφαρμογή σας.

4. Για τους κωδικούς μετατροπής `'f'`, `'d'` και `'e'`, η συσκευασμένη αναπαράσταση χρησιμοποιεί τη μορφή IEEE 754 binary32, binary64 ή binary16 (αντίστοιχα για `'f'`, `'d'` ή `'e'`), ανεξάρτητα από τη μορφή κινητής υποδιαστολής που χρησιμοποιεί η πλατφόρμα.

5. The `'P'` type code is only available for the native byte ordering (selected as the default or with the `'@'` byte order character). The byte order character `'='` chooses to use little- or big-endian ordering based on the host system. The struct module does not interpret this as native ordering, so the `'P'` format is not available.

6. The IEEE 754 binary16 «half precision» type was introduced in the 2008 revision of the IEEE 754 standard. It has a sign bit, a 5-bit exponent and 11-bit precision (with 10 bits explicitly stored), and can represent numbers between approximately `6.1e-05` and `6.5e+04` at full precision. This type is not widely supported by C compilers: it’s available as _Float16 type, if the compiler supports the Annex H of the C23 standard. On a typical machine, an unsigned short can be used for storage, but not for math operations. See the Wikipedia page on the half-precision floating-point format for more information.

7. Κατά τη συσκευασία, το `'x'` εισάγει ένα NUL byte.

8. The `'p'` type code encodes a «Pascal string», meaning a short variable-length string stored in a fixed number of bytes, given by the count. The first byte stored is the length of the string, or 255, whichever is smaller. The bytes of the string follow. If the byte string passed in to `pack()` is too long (longer than the count minus 1), only the leading `count-1` bytes of the string are stored. If the byte string is shorter than `count-1`, it is padded with null bytes so that exactly count bytes in all are used. Note that for `unpack()`, the `'p'` type code consumes `count` bytes, but that the `bytes` object returned can never contain more than 255 bytes. When packing, arguments of types `bytes` and `bytearray` are accepted.

9. For the `'s'` type code, the count is interpreted as the length of the byte string, not a repeat count like for the other type codes; for example, `'10s'` means a single 10-byte string mapping to or from a single Python byte string, while `'10c'` means 10 separate one byte character elements (e.g., `cccccccccc`) mapping to or from ten different Python byte objects. (See Παραδείγματα for a concrete demonstration of the difference.) If a count is not given, it defaults to 1. For packing, the byte string is truncated or padded with null bytes as appropriate to make it fit. For unpacking, the resulting `bytes` object always has exactly the specified number of bytes. As a special case, `'0s'` means a single, empty byte string (while `'0c'` means 0 characters). When packing, arguments of types `bytes` and `bytearray` are accepted.

10. For the `'F'` and `'D'` type codes, the packed representation uses the IEEE 754 binary32 and binary64 format for components of the complex number, regardless of the floating-point format used by the platform. Note that complex types (`F`/`Zf` and `D`/`Zd`) are available unconditionally, despite complex types being an optional feature in C. As specified in the C11 standard, each complex type is represented by a two-element C array containing, respectively, the real and imaginary parts.

A type code may be preceded by an integral repeat count. For example, the format string `'4h'` means exactly the same as `'hhhh'`.

Οι χαρακτήρες κενού μεταξύ των μορφοποιήσεων αγνοούνται· ωστόσο, ένας αριθμός και η μορφή του δεν πρέπει να περιέχουν κενά.

Κατά το πακετάρισμα μιας τιμής `x` χρησιμοποιώντας μια από τις μορφές ακεραίων (`'b'`, `'B'`, `'h'`, `'H'`, `'i'`, `'I'`, `'l'`, `'L'`, `'q'`, `'Q'`), εάν το `x` είναι εκτός του έγκυρου εύρους για αυτήν τη μορφή, γίνεται raise μια εξαίρεση `struct.error`.

Άλλαξε στην έκδοση 3.1: Προηγουμένως, ορισμένες από τις μορφές ακεραίων περιτύλιγαν τιμές εκτός εύρους και εμφάνιζαν `DeprecationWarning` αντί για `struct.error`.

For the `'?'` type code, the return value is either `True` or `False`. When packing, the truth value of the argument object is used. Either 0 or 1 in the native or standard bool representation will be packed, and any non-zero value will be `True` when unpacking.

### Παραδείγματα

Σημείωση

Τα παραδείγματα native σειράς byte (που καθορίζονται από το πρόθεμα μορφής `'@'` ή την απουσία οποιουδήποτε χαρακτήρα προθέματος) ενδέχεται να μην αντιστοιχούν σε αυτά που παράγει η μηχανή του αναγνώστη, καθώς αυτό εξαρτάται από την πλατφόρμα και τον μεταγλωττιστή.

Συσκευασία και αποσυσκευασία ακεραίων τριών διαφορετικών μεγεθών, χρησιμοποιώντας διάταξη big endian:

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

Προσπάθεια συσκευασίας ενός ακεραίου που είναι πολύ μεγάλος για το καθορισμένο πεδίο:

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

Επιδεικνύει την διαφορά μεταξύ των χαρακτήρων μορφοποίησης `'s'` και `'c'`:

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

Τα αποσυσκευασμένα πεδία μπορούν να ονομαστούν είτε αναθέτοντάς τα σε μεταβλητές είτε περιτυλίγοντάς τα σε μια ονομασμένη πλειάδα:

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

The ordering of type codes may have an impact on size in native mode since padding is implicit. In standard mode, the user is responsible for inserting any desired padding. Note in the first `pack` call below that three NUL bytes were added after the packed `'#'` to align the following integer on a four-byte boundary. In this example, the output was produced on a little endian machine:

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

Η ακόλουθη μορφή `'llh0l'` έχει ως αποτέλεσμα την προσθήκη δύο bytes συμπλήρωσης στο τέλος, υποθέτοντας ότι οι μακροί ακέραιοι (longs) της πλατφόρμας ευθυγραμμίζονται σε όρια 4-byte:

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

Δείτε επίσης

Module `array`

  Πακεταρισμένη δυαδική αποθήκευση ομοιογενών δεδομένων.

Module `json`

  Κωδικοποιητής και αποκωδικοποιητής JSON.

Module `pickle`

  Σειριοποίηση αντικειμένων Python.

## Εφαρμογές

Two main applications for the `struct` module exist, data interchange between Python and C code within an application or another application compiled using the same compiler (native formats), and data interchange between applications using agreed upon data layout (standard formats). Generally speaking, the format strings constructed for these two domains are distinct.

### Native Μορφές

When constructing format strings which mimic native layouts, the compiler and machine architecture determine byte ordering and padding. In such cases, the `@` format character should be used to specify native byte ordering and data sizes. Internal pad bytes are normally inserted automatically. It is possible that a zero-repeat type code will be needed at the end of a format string to round up to the correct byte boundary for proper alignment of consecutive chunks of data.

Εξετάστε αυτά τα δύο απλά παραδείγματα (σε έναν 64-bit, little-endian υπολογιστή):

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

Τα δεδομένα δεν συμπληρώνονται σε όριο 8 byte στο τέλος της δεύτερης συμβολοσειράς μορφοποίησης χωρίς τη χρήση επιπλέον συμπλήρωσης. Ένας κωδικός μορφοποίησης με επανάληψη μηδέν λύνει αυτό το πρόβλημα:

    >>> calcsize('@llh0l')
    24

The `'x'` type code can be used to specify the repeat, but for native formats it is better to use a zero-repeat format like `'0l'`.

Από προεπιλογή, χρησιμοποιείται η native σειρά byte και στοίχιση, αλλά είναι καλύτερο να είμαστε σαφείς και να χρησιμοποιούμε τον χαρακτήρα πρόθεμα `'@'`.

### Τυπικές μορφές

Όταν ανταλλάσετε δεδομένα πέρα από τη διεργασία σας, όπως σε δικτύωση ή αποθήκευση, να είστε ακριβείς. Καθορίστε την ακριβή σειρά των byte, το μέγεθος και την ευθυγράμμιση. Μην υποθέτετε ότι ταιριάζουν με τη φυσική σειρά μιας συγκεκριμένης μηχανής. Για παράδειγμα, η σειρά byte του δικτύου είναι big-endian, ενώ πολλοί δημοφιλείς επεξεργαστές είναι little-endian. Ορίζοντας αυτό ρητά, ο χρήστης δεν χρειάζεται να ενδιαφέρεται για τις λεπτομέρειες της πλατφόρμας στην οποία εκτελείται ο κώδικας. Ο πρώτος χαρακτήρας πρέπει τυπικά να είναι `<` ή `>` (ή `!`). Η ευθύνη για την προσθήκη συμπληρωματικών byte ανήκει στον προγραμματιστή. Ο χαρακτήρας μορφής με μηδενική επανάληψη δεν θα λειτουργήσει. Αντ” αυτού, ο χρήστης πρέπει να προσθέτει ρητά byte `'x'` όπου απαιτείται. Επανεξετάζοντας τα παραδείγματα από την προηγούμενη ενότητα, έχουμε:

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

Τα παραπάνω αποτελέσματα (εκτελεσμένα σε 64-bit μηχανή) δεν είναι εγγυημένο ότι θα ταιριάζουν όταν εκτελούνται σε διαφορετικές μηχανές. Για παράδειγμα, τα παρακάτω παραδείγματα εκτελέστηκαν σε 32-bit μηχανή:

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

## Κλάσεις

The `struct` module also defines the following type:

class struct.Struct(format)

  Επιστρέφει ένα νέο αντικείμενο Struct που γράφει και διαβάζει δυαδικά δεδομένα σύμφωνα με τη συμβολοσειρά μορφοποίησης format. Η δημιουργία ενός αντικειμένου `Struct` μια φορά και η κλήση των μεθόδων του είναι πιο αποδοτική από την κλήση συναρτήσεων σε επίπεδο module με την ίδια μορφή, καθώς η συμβολοσειρά μορφοποίησης μεταγλωττίζεται μόνο μία φορά.

  Σημείωση

  Οι μεταγλωττισμένες εκδόσεις των πιο πρόσφατων συμβολοσειρών μορφοποίησης που περνούν στις συναρτήσεις του module αποθηκεύονται προσωρινά, επομένως τα προγράμματα που χρησιμοποιούν μόνο λίγες συμβολοσειρές μορφοποίησης δεν χρειάζεται να ανησυχούν για την επαναχρησιμοποίηση μιας μεμονωμένης περίπτωσης της κλάσης `Struct`.

  Τα μεταγλωττισμένα αντικείμενα Struct υποστηρίζουν τις ακόλουθες μεθόδους και ιδιότητες:

  pack(v1, v2, ...)

    Ταυτόσημο με τη συνάρτηση `pack()`, χρησιμοποιώντας τη μεταγλωττισμένη μορφή. (`len(result)` θα είναι ίσο με `size`.)

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

    Ταυτόσημο με τη συνάρτηση `pack_into()`, χρησιμοποιώντας τη μεταγλωττισμένη μορφή.

  unpack(buffer)

    Ταυτόσημο με τη συνάρτηση `unpack()`, χρησιμοποιώντας τη μεταγλωττισμένη μορφή. Το μέγεθος του buffer σε bytes πρέπει να είναι ίσο με `size`.

  unpack_from(buffer, offset=0)

    Ταυτόσημο με τη συνάρτηση `unpack_from()`, χρησιμοποιώντας τη μεταγλωττισμένη μορφή. Το μέγεθος του buffer σε bytes, ξεκινώντας από τη θέση offset, πρέπει να είναι τουλάχιστον `size`.

  iter_unpack(buffer)

    Ταυτόσημο με τη συνάρτηση `iter_unpack()`, χρησιμοποιώντας τη μεταγλωττισμένη μορφή. Το μέγεθος του buffer σε bytes πρέπει να είναι πολλαπλάσιο του `size`.

    Added in version 3.4.

  format

    Η συμβολοσειρά μορφής που χρησιμοποιήθηκε για τη δημιουργία αυτού του αντικειμένου Struct.

    Άλλαξε στην έκδοση 3.7: Ο τύπος της συμβολοσειράς μορφής είναι πλέον `str` αντί για `bytes`.

  size

    Το υπολογισμένο μέγεθος της δομής (και κατά συνέπεια του αντικειμένου bytes που παράγεται από τη μέθοδο `pack()`) που αντιστοιχεί στη `format`.

  Άλλαξε στην έκδοση 3.13: Η repr() αναπαράσταση των δομών έχει αλλάξει. Είναι πλέον:

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