bytearray

A bytearray is a built-in, mutable sequence of integers in the range 0 <= x < 256. It serves as the mutable counterpart to the immutable bytes object, providing a contiguous block of memory that can be modified in-place without the overhead of allocating new objects for every transformation.

Because it is a mutable sequence, a bytearray implements the MutableSequence abstract base class, supporting both list-like mutation methods and bytes-like string operations.

Initialization Syntax

A bytearray can be instantiated in several ways depending on the source data type:

# 1. Empty initialization
ba_empty = bytearray()


# 2. Zero-initialized buffer of a specific length (int)
ba_zeros = bytearray(5)  

# Result: bytearray(b'\x00\x00\x00\x00\x00')


# 3. From an iterable of integers (must be 0 <= x < 256)
ba_iter = bytearray([112, 121, 116, 104, 111, 110])  

# Result: bytearray(b'python')


# 4. From a string (requires an explicit encoding)
ba_str = bytearray("data", encoding="utf-8")  

# Result: bytearray(b'data')


# 5. From an existing bytes object or buffer protocol object
ba_bytes = bytearray(b"immutable")

Mutability and Assignment

Unlike bytes, elements within a bytearray can be reassigned via indexing or slicing.

• Index assignment requires an integer representing the byte value.
• Slice assignment requires an iterable of integers (like bytes or another bytearray) and can dynamically resize the underlying array.

ba = bytearray(b"hello")


# Index assignment (modifying a single byte)
ba[0] = 72  # 72 is the ASCII integer for 'H'

# Result: bytearray(b'Hello')


# Slice assignment (replacing multiple bytes, can alter length)
ba[1:] = b"ELLO WORLD"

# Result: bytearray(b'HELLO WORLD')


# Deletion via slicing
del ba[5:]

# Result: bytearray(b'HELLO')

Sequence Operations

bytearray objects support standard mutable sequence operations, allowing dynamic resizing similar to Python lists. When appending or inserting, the arguments must be integers within the valid byte range.

ba = bytearray(b"foo")


# Append a single byte (integer)
ba.append(100)  # 100 is 'd'

# Result: bytearray(b'food')


# Extend with an iterable of bytes
ba.extend(b" bar")

# Result: bytearray(b'food bar')


# Insert a byte at a specific index
ba.insert(0, 95)  # 95 is '_'

# Result: bytearray(b'_food bar')


# Remove and return a byte at an index
popped_byte = ba.pop(0)  # Returns 95

Bytes-Like Operations

Because bytearray shares an API with bytes, it supports byte-oriented string methods. These methods typically return a new bytearray object rather than modifying the original in-place, unless explicitly stated otherwise.

ba = bytearray(b"  system_data  ")


# Stripping whitespace bytes
clean_ba = ba.strip()  

# Result: bytearray(b'system_data')


# Replacing byte sequences
replaced_ba = clean_ba.replace(b"_", b"-")  

# Result: bytearray(b'system-data')


# Decoding to a standard Python string
str_output = replaced_ba.decode("utf-8")  

# Result: 'system-data'

Master Python with Deep Grasping Methodology!

Learn More