> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Python 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: ```python theme={"dark"} # 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. ```python theme={"dark"} 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. ```python theme={"dark"} 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. ```python theme={"dark"} 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' ```

Tired of Poor Python Skills? Fix That With Deep Grasping! Learn More