`struct` — Interpret bytes as packed binary data¶

Source code: 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.

Note

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 Byte Order, Size, and Alignment for details.

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.

Functions and Exceptions¶

The module defines the following exception and functions:

exception struct.error¶: Exception raised on various occasions; argument is a string describing what is wrong.

struct.pack(format, v1, v2, ...)¶: Return a bytes object containing the values v1, v2, … packed according to the format string format. The arguments must match the values required by the format exactly.

struct.pack_into(format, buffer, offset, v1, v2, ...)¶: Pack the values v1, v2, … according to the format string format and write the packed bytes into the writable buffer buffer starting at position offset. Note that offset is a required argument. A negative offset counts from the end of buffer.

struct.unpack(format, buffer)¶: Unpack from the buffer buffer (presumably packed by pack(format, ...)) according to the format string format. The result is a tuple even if it contains exactly one item. The buffer’s size in bytes must match the size required by the format, as reflected by calcsize().

struct.unpack_from(format, /, buffer, offset=0)¶: Unpack from buffer starting at position offset, according to the format string format. The result is a tuple even if it contains exactly one item. The buffer’s size in bytes, starting at position offset, must be at least the size required by the format, as reflected by calcsize(). A negative offset counts from the end of buffer.

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

Each iteration yields a tuple as specified by the format string.

Added in version 3.4.

struct.calcsize(format)¶: Return the size of the struct (and hence of the bytes object produced by pack(format, ...)) corresponding to the format string format.

Format Strings¶

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 Order, Size, and Alignment¶

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.

Alternatively, the first character of the format string can be used to indicate the byte order, size and alignment of the packed data, according to the following table:

Character	Byte order	Size	Alignment
`@`	native	native	native
`=`	native	standard	none
`<`	little-endian	standard	none
`>`	big-endian	standard	none
`!`	network (= big-endian)	standard	none

If the first character is not one of these, '@' is assumed.

Note

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.

Native size and alignment are determined using the C compiler’s sizeof expression. This is always combined with native byte order.

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

Note the difference between '@' and '=': both use native byte order, but the size and alignment of the latter is standardized.

The form '!' represents the network byte order which is always big-endian as defined in IETF RFC 1700.

There is no way to indicate non-native byte order (force byte-swapping); use the appropriate choice of '<' or '>'.

Notes:

Padding is only automatically added between successive structure members. No padding is added at the beginning or the end of the encoded struct.
No padding is added when using non-native size and alignment, e.g. with ‘<’, ‘>’, ‘=’, and ‘!’.
To align the end of a structure to the alignment requirement of a particular type, end the format with the code for that type with a repeat count of zero. See Examples.

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.

Format	C Type	Python type	Standard size	Notes
`x`	pad byte	no value		(7)
`c`	char	bytes of length 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)
`Zf`	float complex	complex	8	(10)
`Zd`	double complex	complex	16	(10)
`s`	char[]	bytes		(9)
`p`	char[]	bytes		(8)
`P`	void*	int		(2), (5)

Changed in version 3.3: Added support for the 'n' and 'N' formats.

Changed in version 3.6: Added support for the 'e' format.

Changed in version 3.14: Added support for the 'F' and 'D' formats.

Changed in version 3.15: Added support for the 'Zf' and 'Zd' formats.

Changed in version 3.16: 'F' and 'D' formats are deprecated.