# `struct` — Interpret bytes as packed binary data

Вихідний код: Lib/struct.py

This module converts between Python values and C structs represented as Python `bytes` objects. Compact format strings describe the intended conversions to/from Python values. The module’s functions and objects can be used for two largely distinct applications, data exchange with external sources (files or network connections), or data transfer between the Python application and the C layer.

Примітка

When no prefix character is given, native mode is the default. It packs or unpacks data based on the platform and compiler on which the Python interpreter was built. The result of packing a given C struct includes pad bytes which maintain proper alignment for the C types involved; similarly, alignment is taken into account when unpacking. In contrast, when communicating data between external sources, the programmer is responsible for defining byte ordering and padding between elements. See Порядок байтів, розмір і вирівнювання for details.

Several `struct` functions (and methods of `Struct`) take a buffer argument. This refers to objects that implement the Буферний протокол 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.

## Функції та винятки

Модуль визначає такі винятки та функції:

exception struct.error

  Виняток, що виникає з різних приводів; аргумент - це рядок, що описує те, що є неправильним.

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

  Повертає об’єкт bytes, що містить значення v1, v2, … упаковані відповідно до рядка формату format. Аргументи мають точно відповідати значенням, які вимагає формат.

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

  Упакуйте значення v1, v2, … відповідно до рядка формату format і запишіть упаковані байти в записуваний буфер buffer, починаючи з позиції offset. Зауважте, що offset є обов’язковим аргументом.

struct.unpack(format, buffer)

  Розпакуйте з буфера buffer (імовірно запакованого `pack(format, ...)`) відповідно до рядка формату format. Результатом є кортеж, навіть якщо він містить рівно один елемент. Розмір буфера в байтах має відповідати розміру, який вимагає формат, як це відображається `calcsize()`.

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

  Розпакуйте з buffer, починаючи з позиції offset, відповідно до рядка формату format. Результатом є кортеж, навіть якщо він містить рівно один елемент. Розмір буфера в байтах, починаючи з позиції offset, має бути принаймні розміром, який вимагається форматом, що відображається `calcsize()`.

struct.iter_unpack(format, buffer)

  Iteratively unpack from the buffer buffer according to the format string format. 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()`.

  Кожна ітерація дає кортеж, як зазначено в рядку формату.

  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 format characters, 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.

### Порядок байтів, розмір і вирівнювання

By default, C types are represented in the machine’s native format and byte order, and properly aligned by skipping pad bytes if necessary (according to the rules used by the C compiler). This behavior is chosen so that the bytes of a packed struct correspond exactly to the memory layout of the corresponding C struct. Whether to use native byte ordering and padding or standard formats depends on the application.

Крім того, перший символ рядка формату можна використовувати для вказівки порядку байтів, розміру та вирівнювання упакованих даних згідно з наведеною нижче таблицею:

характер | Порядок байтів | Розмір | Вирівнювання
--- | --- | --- | ---
`@` | рідний | рідний | рідний
`=` | рідний | стандарт | немає
`<` | маленький байт | стандарт | немає
`>` | великий байт | стандарт | немає
`!` | мережа (= порядок байтів) | стандарт | немає

Якщо перший символ не є одним із цих, передбачається `'@'`.

Примітка

The number 1023 (`0x3ff` in hexadecimal) has the following byte representations:

- `03 ff` in big-endian (`>`)

- `ff 03` in little-endian (`<`)

Python example:

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

Native byte order is big-endian or little-endian, depending on the host system. For example, Intel x86, AMD64 (x86-64), and Apple M1 are little-endian; IBM z and many legacy architectures are big-endian. Use `sys.byteorder` to check the endianness of your system.

Власний розмір і вирівнювання визначаються за допомогою виразу `sizeof` компілятора C. Це завжди поєднується з рідним порядком байтів.

Стандартний розмір залежить тільки від символу формату; див. таблицю в розділі Формат символів.

Зверніть увагу на різницю між `'@'` і `'='`: обидва використовують власний порядок байтів, але розмір і вирівнювання останнього стандартизовані.

Форма `'!'` представляє мережевий порядок байтів, який завжди є старшим байтом, як визначено в IETF RFC 1700.

Немає способу вказати невласний порядок байтів (примусова заміна байтів); використовуйте відповідний вибір `' <'` or `'> ''`.

Примітки:

1. Відступи автоматично додаються лише між послідовними елементами структури. Заповнення не додається на початку або в кінці закодованої структури.

2. Під час використання невласного розміру та вирівнювання відступи не додаються, напр. з «<“, „>», «=» і «!».

3. Щоб вирівняти кінець структури відповідно до вимог вирівнювання певного типу, завершіть формат кодом для цього типу з нульовою кількістю повторів. Див. Приклади.

### Формат символів

Символи форматування мають таке значення; перетворення між значеннями C і Python повинно бути очевидним, враховуючи їхні типи. Стовпець «Стандартний розмір» стосується розміру упакованого значення в байтах при використанні стандартного розміру; тобто, коли форматний рядок починається з одного з `' <'`, `'> ''`, `'!''` або `'='`. При використанні рідного розміру розмір упакованого значення залежить від платформи.

Формат | C Тип | Тип Python | Стандартний розмір | Примітки
--- | --- | --- | --- | ---
`x` | pad byte | немає значення |  | (7)
`c` | char | байти довжиною 1 | 1 |
`b` | signed char | ціле число | 1 | (1), (2)
`B` | unsigned char | ціле число | 1 | (2)
`?` | _Bool | bool | 1 | (1)
`h` | short | ціле число | 2 | (2)
`H` | unsigned short | ціле число | 2 | (2)
`я` | int | ціле число | 4 | (2)
`Я` | unsigned int | ціле число | 4 | (2)
`l` | long | ціле число | 4 | (2)
`L` | unsigned long | ціле число | 4 | (2)
`q` | long long | ціле число | 8 | (2)
`Q` | unsigned long long | ціле число | 8 | (2)
`n` | `ssize_t` | ціле число |  | (3)
`N` | `size_t` | ціле число |  | (3)
`e` | (6) | плавати | 2 | (4)
`f` | float | плавати | 4 | (4)
`d` | double | плавати | 8 | (4)
`F` | float complex | complex | 8 | (10)
`D` | double complex | complex | 16 | (10)
`s` | char[] | байтів |  | (9)
`p` | char[] | байтів |  | (8)
`P` | void* | ціле число |  | (5)

Змінено в версії 3.3: Додано підтримку форматів `'n'` і `'N'`.

Змінено в версії 3.6: Додано підтримку формату `'e''`.

Змінено в версії 3.14: Added support for the `'F'` and `'D'` formats.

Примітки:

1. The `'?'` conversion code corresponds to the _Bool type defined by C standards since C99. In standard mode, it is represented by one byte.

2. When attempting to pack a non-integer using any of the integer conversion codes, if the non-integer has a `__index__()` method then that method is called to convert the argument to an integer before packing.

   Змінено в версії 3.2: Added use of the `__index__()` method for non-integers.

3. Коди перетворення `'n'` і `'N'` доступні лише для рідного розміру (вибрано як типовий або з символом порядку байтів `'@''`). Для стандартного розміру ви можете використовувати будь-який з інших форматів цілих чисел, який підходить для вашої програми.

4. Для кодів перетворення `'f'`, `'d'` і `'e'` упаковане представлення використовує формат IEEE 754 binary32, binary64 або binary16 (для `'f''` , `'d'` або `'e'` відповідно), незалежно від формату з плаваючою комою, який використовується платформою.

5. Символ формату `'P'` доступний лише для власного порядку байтів (вибрано як типовий або з символом порядку байтів `'@'`). Символ порядку байтів `'='` вибирає порядок використання малого або великого порядку байтів на основі головної системи. Модуль struct не інтерпретує це як рідне впорядкування, тому формат `'P'` недоступний.

6. Двійковий тип16 IEEE 754 із «половиною точності» було введено в редакції 2008 року стандарту IEEE 754. Він має знаковий біт, 5-бітний експоненту та 11-бітну точність (з 10 бітами, збереженими явно), і може представляти числа приблизно від `6.1e-05` до `6.5e+04` з повною точністю. . Цей тип не широко підтримується компіляторами C: на типовій машині беззнаковий короткий можна використовувати для зберігання, але не для математичних операцій. Перегляньте сторінку Вікіпедії про формат числа з плаваючою комою половинної точності для отримання додаткової інформації.

7. When packing, `'x'` inserts one NUL byte.

8. Символ формату `'p'` кодує «рядок Pascal», що означає короткий рядок змінної довжини, що зберігається у фіксованій кількості байтів, визначеній підрахунком. Перший збережений байт — це довжина рядка або 255, залежно від того, що менше. Далі йдуть байти рядка. Якщо рядок, переданий у `pack()`, задовгий (довший за лічильник мінус 1), зберігаються лише перші байти `count-1` рядка. Якщо рядок коротший за `count-1`, він доповнюється нульовими байтами, щоб використати рівно кількість байтів. Зверніть увагу, що для `unpack()` символ формату `'p'` споживає `count` байтів, але що повернутий рядок ніколи не може містити більше 255 байтів.

9. For the `'s'` format character, the count is interpreted as the length of the bytes, not a repeat count like for the other format characters; 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 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 string (while `'0c'` means 0 characters).

10. For the `'F'` and `'D'` format characters, 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` and `D`) 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.

Символу форматування може передувати цілий підрахунок повторів. Наприклад, рядок формату `'4h''` означає те саме, що `'hhhh'`.

Пробіли між форматами ігноруються; кількість і його формат не повинні містити пробіли.

Під час пакування значення `x` з використанням одного з цілочисельних форматів (`'b'`, `'B'`, `'h'`, `'H'`, `'i'`, `'I'`, `'l'`, `'L'`, `'q'`, `'Q'`), якщо `x` знаходиться за межами допустимого діапазону для цього формату, тоді виникає `struct.error`.

Змінено в версії 3.1: Раніше деякі цілочисельні формати обгортали значення поза діапазоном і викликали `DeprecationWarning` замість `struct.error`.

Для символу формату `'?'` повертається значення `True` або `False`. При упаковці використовується значення істинності об’єкта аргументу. Буде запаковано 0 або 1 у нативному або стандартному логічному представленні, а будь-яке ненульове значення під час розпакування буде `True`.

### Приклади

Примітка

Native byte order examples (designated by the `'@'` format prefix or lack of any prefix character) may not match what the reader’s machine produces as that depends on the platform and compiler.

Pack and unpack integers of three different sizes, using big endian ordering:

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

Attempt to pack an integer which is too large for the defined field:

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

Demonstrate the difference between `'s'` and `'c'` format characters:

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

The following format `'llh0l'` results in two pad bytes being added at the end, assuming the platform’s longs are aligned on 4-byte boundaries:

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

Дивись також

Модуль `array`

  Упаковане двійкове сховище однорідних даних.

Модуль `json`

  JSON encoder and decoder.

Модуль `pickle`

  Python object serialization.

## Applications

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 Formats

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

Consider these two simple examples (on a 64-bit, little-endian machine):

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

Data is not padded to an 8-byte boundary at the end of the second format string without the use of extra padding. A zero-repeat format code solves that problem:

    >>> calcsize('@llh0l')
    24

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

By default, native byte ordering and alignment is used, but it is better to be explicit and use the `'@'` prefix character.

### Standard Formats

When exchanging data beyond your process such as networking or storage, be precise. Specify the exact byte order, size, and alignment. Do not assume they match the native order of a particular machine. For example, network byte order is big-endian, while many popular CPUs are little-endian. By defining this explicitly, the user need not care about the specifics of the platform their code is running on. The first character should typically be `<` or `>` (or `!`). Padding is the responsibility of the programmer. The zero-repeat format character won’t work. Instead, the user must explicitly add `'x'` pad bytes where needed. Revisiting the examples from the previous section, we have:

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

The above results (executed on a 64-bit machine) aren’t guaranteed to match when executed on different machines. For example, the examples below were executed on a 32-bit machine:

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

  Return a new Struct object which writes and reads binary data according to the format string format. Creating a `Struct` object once and calling its methods is more efficient than calling module-level functions with the same format since the format string is only compiled once.

  Примітка

  The compiled versions of the most recent format strings passed to the module-level functions are cached, so programs that use only a few format strings needn’t worry about reusing a single `Struct` instance.

  Зкомпільовані об’єкти Struct підтримують наступні методи та атрибути:

  pack(v1, v2, ...)

    Ідентична функції `pack()`, використовуючи скомпільований формат. (`len(result)` дорівнюватиме `size`.)

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

    Ідентична функції `pack_into()`, використовуючи скомпільований формат.

  unpack(buffer)

    Ідентична функції `unpack()`, використовуючи скомпільований формат. Розмір буфера в байтах має дорівнювати `size`.

  unpack_from(buffer, offset=0)

    Ідентична функції `unpack_from()`, використовуючи скомпільований формат. Розмір буфера в байтах, починаючи з позиції offset, має бути не менше `size`.

  iter_unpack(buffer)

    Ідентична функції `iter_unpack()`, використовуючи скомпільований формат. Розмір буфера в байтах має бути кратним `size`.

    Added in version 3.4.

  format

    Рядок формату, який використовується для створення цього об’єкта Struct.

    Змінено в версії 3.7: Тип рядка формату тепер `str` замість `bytes`.

  size

    Розрахований розмір структури (і, отже, об’єкта bytes, створеного методом `pack()`), що відповідає `format`.

  Змінено в версії 3.13: The repr() of structs has changed. It is now:

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