Bytes, Bytearray, and memoryview

bytes: Immutable Binary Sequences

The bytes type in Python represents an immutable sequence of bytes—integers in the range 0 <= x < 256. Its immutability means that once a bytes object is created, its contents cannot be altered. This design choice provides significant benefits, including thread safety, hashability (allowing use as dictionary keys or set elements), and performance optimizations, as the interpreter can rely on the data never changing. It is the go-to type for handling raw binary data from files, network connections, or hardware interfaces where the integrity of the data must be preserved.

Literal Syntax and Creation

The most common way to create a bytes object is using a literal, prefixed with b. The literal can only contain ASCII characters; non-ASCII bytes must be specified using escape sequences. Alternatively, you can create a bytes object from an iterable of integers or via the .encode() method of a string.

# Literal syntax with ASCII characters
ascii_data = b'Hello World'
print(ascii_data)  # Output: b'Hello World'

# Creating from an iterable of integers
from_list = bytes([72, 101, 108, 108, 111])  # ASCII values for 'Hello'
print(from_list)  # Output: b'Hello'

# Encoding a string (the most common method in practice)
text = "Python Bytes"
encoded_data = text.encode('utf-8')  # Returns a bytes object
print(encoded_data)  # Output: b'Python Bytes'

# Attempting a non-ASCII literal will cause a SyntaxError
# invalid_literal = b'café'  # This would fail
correct_way = 'café'.encode('utf-8')  # Use encoding instead
print(correct_way)  # Output: b'caf\xc3\xa9'

Operations and Indexing

Being a sequence type, bytes supports common sequence operations like indexing, slicing, and iteration. However, due to its immutability, any operation that would modify the object returns a new one. Indexing returns an integer representing the byte at that position, not a one-character bytes object.

data = b'ABCDEFG'

# Indexing returns an integer
first_byte = data[0]
print(first_byte, type(first_byte))  # Output: 65 <class 'int'>

# Slicing returns a new bytes object
slice_data = data[1:4]
print(slice_data)  # Output: b'BCD'

# Attempting to assign a new value will raise a TypeError
try:
    data[0] = 90  # Try to change 'A' (65) to 'Z' (90)
except TypeError as e:
    print(f"Error: {e}")  # Output: Error: 'bytes' object does not support item assignment

# The workaround is to create a new object, often via a bytearray
mutable_version = bytearray(data)
mutable_version[0] = 90
new_data = bytes(mutable_version)
print(new_data)  # Output: b'ZBCDEFG'

The Bytes-String Dichotomy

A critical concept is the strict separation between bytes (raw binary data) and str (text). They are fundamentally different types and should not be implicitly mixed. A bytes object does not have an intrinsic encoding; it’s just a sequence of numbers. Interpreting those numbers as text requires knowing the correct character encoding (e.g., UTF-8, Latin-1).

# A common pitfall: comparing bytes and string directly
binary_hello = b'hello'
text_hello = 'hello'

# This will always be False; they are different types
print(binary_hello == text_hello)  # Output: False

# This will raise a TypeError: can't compare bytes and str
# try:
#     binary_hello > text_hello
# except TypeError as e:
#     print(e)

# The correct approach is to decode bytes to a string or encode the string to bytes
decoded = binary_hello.decode('utf-8')  # Now it's a string
print(decoded == text_hello)  # Output: True

Common Methods and Patterns

The bytes type includes methods similar to those found on str, but they operate on and return bytes objects. These are invaluable for parsing binary protocols or file formats. Key methods include .startswith(), .endswith(), .split(), .find(), and .replace().

network_packet = b'GET /index.html HTTP/1.1\r\nHost: example.com\r\n\r\n'

# Check if it's an HTTP GET request
is_get = network_packet.startswith(b'GET')
print(is_get)  # Output: True

# Find the position of the first double CRLF (signaling end of headers)
header_end = network_packet.find(b'\r\n\r\n')
print(header_end)  # Output: 28

# Extract the headers (everything before the double CRLF)
headers = network_packet[:header_end]
print(headers)  # Output: b'GET /index.html HTTP/1.1\r\nHost: example.com'

# Split the packet into lines
lines = network_packet.split(b'\r\n')
print(lines)
# Output: [b'GET /index.html HTTP/1.1', b'Host: example.com', b'']

Best Practices and Pitfalls

Always Be Explicit About Encoding: Never assume an encoding. When decoding bytes to str, always specify the correct character set. Using the wrong encoding (e.g., decoding UTF-8 bytes as Latin-1) will silently create corrupted text or raise a UnicodeDecodeError.
Immutability is a Feature: Use bytes when you need to guarantee the data hasn’t been accidentally altered. For modifiable data, convert to a bytearray first, make your changes, and then convert back to bytes if needed.
Memory Efficiency: For large blocks of static binary data (e.g., the contents of an image file read from disk), bytes is the most efficient and appropriate container.
Use Hex for Debugging: When printing bytes for debugging, the representation can be hard to read. Using the .hex() method provides a clean hexadecimal view.

raw_bytes = b'\xde\xad\xbe\xef'
print(raw_bytes)          # Output: b'\xde\xad\xbe\xef' (hard to read)
print(raw_bytes.hex())    # Output: deadbeef (clear and standard)

bytearray: Mutable Binary Data

The bytearray type in Python is a mutable sequence of integers in the range 0 <= x < 256. It represents a mutable view over an underlying block of memory, making it the go-to choice for in-place manipulation of binary data without the overhead of creating new objects, a key limitation of the immutable bytes type. This mutability is its defining characteristic and the source of its power, but also of certain complexities when interacting with other Python objects.

Core Characteristics and Creation

A bytearray can be created in several ways, each suited to different initialization scenarios. The most common methods are using a literal syntax (with some restrictions), a constructor with a size, or by converting from other iterables.

# Creating an empty bytearray of a specific length (initialized with null bytes)
empty_buffer = bytearray(10)
print(empty_buffer)  # Output: bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

# Creating from a string, requiring an encoding
text_data = bytearray('hello world', encoding='utf-8')
print(text_data)  # Output: bytearray(b'hello world')

# Creating from an iterable of integers
from_list = bytearray([65, 66, 67, 68])  # ASCII values for 'A', 'B', 'C', 'D'
print(from_list)  # Output: bytearray(b'ABCD')

# Creating from a bytes object (copies the data)
immutable_bytes = b'Reference'
mutable_copy = bytearray(immutable_bytes)
print(mutable_copy)  # Output: bytearray(b'Reference')

It’s crucial to understand that the bytearray(10) constructor creates a sequence of ten zeroed bytes, while bytearray(b'10') creates a bytearray from the ASCII values of the characters ‘1’ and ‘0’. The literal syntax for bytearray is limited; you often create a bytes literal and convert it.

Mutability and In-Place Operations

The primary advantage of bytearray is the ability to modify its content after creation. This is done using indexing, slicing, and methods that change the object in-place.

data = bytearray(b'Hello World')

# Modify a single byte via index
data[0] = 104  # Decimal ASCII for 'h'
print(data)  # Output: bytearray(b'hello World')

# Modify a slice (must be assigned an iterable of integers in range)
data[6:11] = b'Python'  # Replaces 'World' with 'Python'
print(data)  # Output: bytearray(b'hello Python')

# In-place addition (extends the bytearray)
data += b' is great!'
print(data)  # Output: bytearray(b'hello Python is great!')

# Using mutable-specific methods
data.append(33)  # Appends the integer 33 (ASCII '!')
print(data)  # Output: bytearray(b'hello Python is great!!')

The requirement that assigned values must be integers in the 0-255 range or an iterable of such integers is a common pitfall. Assigning a string directly, for example, will raise a TypeError.

Interaction with Strings and Encoding

A bytearray contains raw bytes, not characters. Interpreting these bytes as text requires decoding, and creating them from text requires encoding. This distinction is fundamental and a frequent source of bugs.

# Decoding bytes to a string
raw_data = bytearray(b'Caf\xc3\xa9')  # 'é' encoded as UTF-8
text = raw_data.decode('utf-8')
print(text)  # Output: Café

# Encoding a string to a bytearray
new_text = "Resumé"
new_data = bytearray(new_text.encode('utf-8'))
print(new_data)  # Output: bytearray(b'Resum\xc3\xa9')

Attempting to manipulate text data directly in a bytearray without regard for encoding can corrupt multi-byte characters. For instance, changing a single byte in a UTF-8 encoded sequence might render the entire character invalid.

Memory Efficiency and the memoryview

For advanced use cases involving large data buffers or interfacing with C libraries, the memoryview object provides a zero-copy “view” into the memory of other binary objects, including bytearray. This is critical for performance when you need to access or modify slices of a large buffer without creating copies of the data.

# Create a large bytearray
large_buffer = bytearray(1000)  # 1000 bytes

# Create a memoryview to manipulate a slice without copying
mv = memoryview(large_buffer)
slice_view = mv[500:510]  # This is a view, not a copy

# Modify data through the view
slice_view[0] = 0xFF
# The change is reflected in the original bytearray
print(large_buffer[500])  # Output: 255

Using a memoryview is a best practice for performance-critical code that works on subsections of a bytearray or bytes object, as it avoids the memory allocation and copying overhead of slicing.

Common Pitfalls and Best Practices

Type Confusion: Remember that bytearray holds integers, not characters. ba[0] returns an int, not a one-character bytes object.
Encoding Awareness: Always be conscious of the encoding when converting to and from strings. Using the wrong encoding will lead to UnicodeDecodeError or silent data corruption.
Slicing Copies (vs. memoryview): Standard slicing of a bytearray creates a new bytes object. If you need a mutable slice or are working with very large data, use a memoryview to avoid the copy.
Value Range: Any operation that assigns a value must ensure it is an integer between 0 and 255. Using a value outside this range will raise a ValueError.

In summary, bytearray fills the essential niche of mutable binary data processing in Python. Its design forces an explicit separation between bytes and text, encouraging robust handling of encodings. For high-performance manipulation of large buffers, it is most effectively paired with the memoryview object.

Encoding and Decoding Between str and bytes

In Python, the fundamental distinction between text and binary data is critical. Text is represented by the str object, which holds a sequence of Unicode characters. Binary data is represented by the bytes and bytearray objects, which hold a sequence of integers in the range 0 <= x < 256. The process of converting a str to a bytes object is encoding, and the reverse process is decoding. This conversion is necessary because data must be in a binary format for storage (e.g., in a file) or transmission (e.g., over a network), while humans and application logic work with readable text.

The Core Concepts: Encoding and Decoding

An encoding is a specific algorithm that maps each Unicode character to a unique sequence of bytes and vice-versa. The most common encoding is UTF-8, which is a variable-length encoding capable of representing every character in the Unicode standard. Other encodings include ASCII (a subset of UTF-8), UTF-16, and Latin-1.

The str.encode() method converts a string to its binary representation, and the bytes.decode() method converts a binary object back to a string. Both methods accept an encoding parameter, which must be specified correctly for the operation to succeed.

# Encoding: str -> bytes
text = "Python's Zen: 🐍"
binary_data = text.encode(encoding='utf-8')
print(binary_data)  # Output: b"Python's Zen: \xf0\x9f\x90\x8d"

# Decoding: bytes -> str
reconstructed_text = binary_data.decode(encoding='utf-8')
print(reconstructed_text)  # Output: Python's Zen: 🐍

It is absolutely crucial that the same encoding is used for both operations. Decoding a sequence of bytes with an encoding different from the one used to create it will often result in a UnicodeDecodeError or, even worse, silently produce mojibake (garbled text).

Specifying and Handling Errors

What should happen if, during encoding, a character in the string cannot be represented in the target encoding? Or if, during decoding, a sequence of bytes is invalid for the specified encoding? The errors parameter controls this behavior. The default is 'strict', which raises a UnicodeError. Other common strategies are 'ignore' (silently skip the problematic data), 'replace' (use a replacement marker, like '?'), and 'xmlcharrefreplace' (use an XML/HTML character reference).

# Example of handling an encoding error
text = "café au lait"

# This will work fine with utf-8, but let's try ascii
try:
    text.encode('ascii')
except UnicodeEncodeError as e:
    print(f"Error: {e}")

# Using 'replace' to handle unencodable characters
encoded_data = text.encode('ascii', errors='replace')
print(encoded_data)  # Output: b'caf? au lait'

# Example of handling a decoding error
invalid_bytes = b'This is good: \xff\xfe'

# This will fail with strict decoding (default)
try:
    invalid_bytes.decode('utf-8')
except UnicodeDecodeError as e:
    print(f"Error: {e}")

# Using 'ignore' to skip invalid bytes
decoded_text = invalid_bytes.decode('utf-8', errors='ignore')
print(decoded_text)  # Output: 'This is good: '

The `bytes` Constructor and Literal

A bytes object can be created from a string by using the bytes constructor with an encoding. This is functionally equivalent to calling .encode() on the string. The b'' prefix is used to create a bytes literal, where each character within the quotes must be an ASCII character or an escape sequence (\x00 to \xff).

# Creating bytes from a str with encoding
byte_obj_from_str = bytes("Hello", encoding='ascii')
print(byte_obj_from_str)  # Output: b'Hello'

# Using a bytes literal
byte_literal = b'Hello'
print(byte_literal)       # Output: b'Hello'

# A literal with a hex escape for a non-ASCII byte
byte_with_hex = b'caf\xe9' # Represents 'café' in Latin-1, not UTF-8
print(byte_with_hex)      # Output: b'caf\xe9'

Common Pitfalls and Best Practices

The Default Encoding Trap: The encode() and decode() methods default to 'utf-8' in modern Python versions. However, relying on this default can be dangerous in environments where the system encoding might be different (e.g., 'cp1252' on Windows). Always explicitly specify the encoding parameter. This makes your code predictable and portable.
The Mojibake Problem: This occurs when data is decoded with the wrong encoding. For example, decoding UTF-8 bytes as Latin-1 will produce garbled text. The only solution is to know or guess the correct encoding. Libraries like chardet can help guess encodings, but they are not infallible.
Working with Bytes Literals: A common mistake is to create a bytes literal for non-ASCII text: b'café'. This will cause a SyntaxError because 'é' is not an ASCII character. You must use escape sequences (b'caf\xc3\xa9' for UTF-8) or create the object by encoding a string.
The surrogateescape Error Handler: This is an advanced but powerful error handler particularly useful for dealing with filenames on Unix systems. It allows decoding and encoding to preserve bytes that are invalid in the target encoding by using Unicode surrogate code points. This prevents data loss when working with data that may have been created with an unknown or incorrect encoding.

# Example of surrogateescape
# Simulate getting a filename with invalid UTF-8 bytes
filename_bytes = b'file_with_\xff_in_name.txt'

# Decode with surrogateescape to avoid immediate failure
filename_str = filename_bytes.decode('utf-8', errors='surrogateescape')
print(filename_str)  # Output: 'file_with_\udcff_in_name.txt'

# You can then encode it back to the original bytes
original_bytes = filename_str.encode('utf-8', errors='surrogateescape')
print(original_bytes == filename_bytes)  # Output: True

memoryview: Zero-Copy Buffer Protocol

The memoryview object provides a zero-copy interface for accessing the internal buffer of other objects that support the buffer protocol, such as bytes, bytearray, array.array, and certain NumPy arrays. Unlike slicing which creates a copy of the data, a memoryview allows you to work directly with the memory of the original object, offering significant performance benefits for large data sets and efficient memory usage.

Core Concept and Buffer Protocol

At its heart, a memoryview is a wrapper around the Buffer Protocol, a C-level API that allows Python objects to expose their raw memory bytes to other objects without copying. This protocol is the foundation for efficient data sharing between low-level and high-level parts of Python, as well as between Python and external libraries written in C or other languages. When you create a memoryview, you are not creating new data; you are creating a “view” or a window into the existing data of another object. This is why operations through a memoryview directly affect the original object if it is mutable.

# Creating a memoryview from a bytearray (mutable)
original_data = bytearray(b'Hello, World!')
mv = memoryview(original_data)

# Modifying through the view alters the original
mv[7:12] = b'Python'
print(original_data)  # Output: bytearray(b'Hello, Python!')

Memory Layout and Multi-Dimensional Views

A powerful feature of memoryview is its ability to interpret the underlying buffer as multi-dimensional arrays with specific formats. The format property defines the data type of each element (e.g., 'B' for unsigned byte, 'i' for int, 'f' for float), while the shape property defines the dimensions. This is incredibly useful for working with structured data, image buffers, or numerical arrays without the overhead of copying.

import array

# Create an array of integers
arr = array.array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

# Create a memoryview and cast it to a 2D shape
mv = memoryview(arr)
mv_2d = mv.cast('i', shape=(2, 5))

print(mv_2d.tolist())  # Output: [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
print(mv_2d[1, 2])    # Output: 8 (second row, third column)

# A change through the view affects the original array
mv_2d[0, 4] = 99
print(arr)  # Output: array('i', [1, 2, 3, 4, 99, 6, 7, 8, 9, 10])

Slicing and Stride

Slicing a memoryview does not copy data; it creates a new memoryview object that references a subset of the original buffer. The strides attribute is a tuple indicating the number of bytes to step in each dimension to reach the next element. This allows for efficient, non-contiguous views of data, such as extracting every other element from a row.

data = bytearray(b'abcdefghijklmnop')
mv = memoryview(data)
slice_mv = mv[2:10]  # No copy made; view of bytes 'c' to 'j'

# Create a view with a stride to get every other byte
strided_mv = mv[2:10:2]
print(bytes(strided_mv))  # Output: b'cegi'

# For a 2D view, strides become crucial
mv_2d = mv.cast('B', shape=(4, 4))
print(mv_2d.strides)  # Output: (4, 1) -> 4 bytes to next row, 1 byte to next column

Common Pitfalls and Best Practices

The primary pitfall involves the lifetime of the original object. A memoryview does not own its data; it holds a reference to the original object’s buffer. If the original object is destroyed while the memoryview is still alive, accessing the view will raise a ValueError.

def create_view():
    data = bytearray(b'temporary data')
    return memoryview(data)  # Dangerous!

my_view = create_view()
# The bytearray 'data' is garbage collected after the function returns.
try:
    print(my_view[0])  # This will likely fail with a ValueError
except ValueError as e:
    print(f"Error: {e}")  # operation forbidden on released memoryview object

Best Practices:

Ensure Object Longevity: Always keep a reference to the original object for as long as you need its memoryview.
Use tobytes() for Safety: If you need a permanent, independent copy of the data from the view, call .tobytes(). This is safe but defeats the zero-copy purpose.
Explicit Release: For large buffers, you can explicitly release the underlying buffer by calling .release() on the memoryview before letting it go out of scope. This can help with deterministic resource management, though it’s often handled by the garbage collector.
Mind Mutability: Be acutely aware of whether the source object (bytearray) is mutable or not (bytes). Writing to a view of an immutable source will raise a TypeError.

# Safe practice: keeping the original object referenced
original = bytearray(10000)
view = memoryview(original)
# ... work with the view ...
# When completely finished, you can release the view and delete the original
view.release()
del original

Practical Uses: Network Protocols, File I/O, and Struct Parsing

The bytes, bytearray, and memoryview objects are the fundamental data types for working with binary data in Python. Their power is fully realized in practical applications involving network communication, file operations, and the parsing of structured binary data. These domains require precise control over data layout, efficient manipulation without unnecessary copying, and a clear understanding of the boundary between textual and binary representations.

Network Protocol Implementation

Network protocols are almost universally defined in terms of octets (bytes). When sending data over a socket, you must encode higher-level data structures (like strings or integers) into a sequence of bytes. Conversely, when receiving data, you must decode these bytes back into meaningful data.

A common pitfall is assuming data received from a socket will arrive in complete, discrete messages. TCP is a stream protocol; a single recv() call might return a partial message, multiple messages, or a fragment of a message. Robust protocol handling requires buffering incoming data and parsing it based on known framing rules (e.g., a fixed header indicating message length).

import socket

def send_message(sock, message_str):
    # Encode the string to bytes using UTF-8
    message_bytes = message_str.encode('utf-8')
    # Prepend a 4-byte header containing the message length (big-endian)
    header = len(message_bytes).to_bytes(4, 'big')
    # Send the header followed by the message bytes
    sock.sendall(header + message_bytes)

def receive_message(sock):
    # First, read the fixed-length 4-byte header
    header = receive_exactly(sock, 4)
    # Unpack the header to get the message length
    message_length = int.from_bytes(header, 'big')
    # Now read exactly that many bytes for the message body
    message_bytes = receive_exactly(sock, message_length)
    # Decode the bytes back to a string
    return message_bytes.decode('utf-8')

def receive_exactly(sock, num_bytes):
    """Helper function to ensure exactly num_bytes are read."""
    data = bytearray()
    while len(data) < num_bytes:
        chunk = sock.recv(num_bytes - len(data))
        if not chunk:
            raise ConnectionError("Connection closed")
        data.extend(chunk)  # Efficiently build the bytearray
    return bytes(data)  # Return an immutable bytes object

In this example, bytearray is used efficiently in receive_exactly to build the incoming data buffer without creating new bytes objects on each recv() call. The final result is converted back to an immutable bytes object for decoding.

Binary File I/O

Reading and writing binary files requires careful attention to the encoding of data. The open() function with mode 'rb' or 'wb' returns a file object that works with bytes objects, not strings.

# Writing structured binary data to a file
config_data = {
    "magic_number": 0xDEADBEEF,
    "version": 1,
    "flags": 0b1101,
    "username": "alice"
}

with open('config.bin', 'wb') as f:
    # Write a 4-byte magic number
    f.write(config_data["magic_number"].to_bytes(4, 'little'))
    # Write a 1-byte version
    f.write(config_data["version"].to_bytes(1, 'little'))
    # Write a 1-byte flags field
    f.write(config_data["flags"].to_bytes(1, 'little'))
    # Write the username: first its length, then the bytes
    username_bytes = config_data["username"].encode('utf-8')
    f.write(len(username_bytes).to_bytes(1, 'little'))
    f.write(username_bytes)

# Reading it back
with open('config.bin', 'rb') as f:
    magic = int.from_bytes(f.read(4), 'little')
    version = int.from_bytes(f.read(1), 'little')
    flags = int.from_bytes(f.read(1), 'little')
    name_len = int.from_bytes(f.read(1), 'little')
    username = f.read(name_len).decode('utf-8')

print(f"Read back: {username}, version {version}")

This manual approach is error-prone. The order of reads must exactly match the order of writes, and the programmer must manually manage the size and endianness of every field. This leads us to a more robust solution.

Parsing Binary Structures with `struct` and `memoryview`

The struct module provides functions to pack and unpack structured binary data according to a format string. Combining it with bytes is common, but memoryview unlocks significant performance benefits when working with slices of a larger buffer.

Without memoryview, slicing a bytes object creates a copy of that data segment. For large buffers or performance-critical applications, this overhead is unacceptable.

import struct

# Example: Parsing a PNG chunk (simplified)
# PNG chunk layout: 4-byte length, 4-byte type, data, 4-byte CRC
png_data = b'\x00\x00\x00\x0APLTE\xFF\xFF\xFF\x00\x00\x00\xD2\x7F\x1D\xC4'  # Sample data

# Inefficient way (involves copying data):
length_bytes = png_data[0:4]  # This creates a copy of 4 bytes
chunk_type = png_data[4:8]    # Another copy
data_segment = png_data[8:8+12] # A copy of the 12-byte data payload

length = struct.unpack('>I', length_bytes)[0]
print(f"Inefficient data copy: {data_segment}")

# Efficient way using memoryview (zero-copy):
mv = memoryview(png_data)
# These slices are new memoryview objects, not copies of the data
mv_length = mv[0:4]
mv_type = mv[4:8]
# The .tobytes() call here *does* create a copy, but only when needed.
length = struct.unpack('>I', mv_length.tobytes())[0]
data_view = mv[8:8+length]  # Still a view, no copy

# We can also unpack directly from the memoryview without tobytes()
# if the struct module supports the buffer protocol (it does in modern Python)
chunk_type, = struct.unpack_from('>4s', mv, 4) # Unpack from offset 4
print(f"Zero-copy chunk type: {chunk_type}")
print(f"Efficient data view: {data_view.tobytes()}") # Copy only now for display

The memoryview allows you to work with different segments of the original png_data buffer as if they were separate objects, but without the memory cost of duplication. This is crucial for protocols that involve large headers or payloads where you only need to inspect a small part at a time. The struct.unpack_from() function is a key partner here, as it can unpack data from a specific offset within a buffer that supports the buffer protocol, which includes memoryview, bytes, and bytearray.

bytes: Immutable Binary Sequences

Literal Syntax and Creation

Operations and Indexing

The Bytes-String Dichotomy

Common Methods and Patterns

Best Practices and Pitfalls

bytearray: Mutable Binary Data

Core Characteristics and Creation

Mutability and In-Place Operations

Interaction with Strings and Encoding

Memory Efficiency and the memoryview

Common Pitfalls and Best Practices

Encoding and Decoding Between str and bytes

The Core Concepts: Encoding and Decoding

Specifying and Handling Errors

The bytes Constructor and Literal

Common Pitfalls and Best Practices

memoryview: Zero-Copy Buffer Protocol

Core Concept and Buffer Protocol

Memory Layout and Multi-Dimensional Views

Slicing and Stride

Common Pitfalls and Best Practices

Practical Uses: Network Protocols, File I/O, and Struct Parsing

Network Protocol Implementation

Binary File I/O

Parsing Binary Structures with struct and memoryview

The `bytes` Constructor and Literal

Parsing Binary Structures with `struct` and `memoryview`