bytearray() function - Python

The bytearray() function in Python creates a mutable sequence of bytes, which is essentially an array of integers in the range 0 to 255 (representing byte values). Unlike the immutable bytes type, bytearray allows us to modify its contents after creation, making it useful for tasks like binary data manipulation, file I/O, or network programming. It’s a built-in function that returns a bytearray object, and its flexibility makes it a powerful tool when we need to work with byte-level data that might change. Think of it as a dynamic, editable version of a byte string, commonly used in low-level programming or when interfacing with systems that require byte data.

Example:

bytearray(b'Geeks for geeks!')
bytearray(b'Gieks for geeks!')

Syntax:

bytearray([source[, encoding[, errors]]])

• source: This can be an integer (to create an array of that size filled with zeros), a string (to convert to bytes), an iterable of integers (0-255), or nothing (for an empty bytearray).
• encoding: Specifies the encoding (e.g., 'utf-8') if source is a string. Ignored otherwise.
• errors: Defines how encoding errors are handled (e.g., 'strict', 'replace'), only used with strings.

Different ways to create bytearray()

1. Creating an empty bytearray

We can create an empty bytearray by calling bytearray() with no arguments. This produces a bytearray of length 0, ready to be populated later using methods like append() or extend(). It’s the simplest starting point when we don’t yet know the data but plan to build it incrementally. Think of it as an empty canvas for byte data, useful in dynamic applications where data arrives over time, such as reading from a stream.

bytearray(b'')
0
bytearray(b'a')

Here, ba starts empty (bytearray(b'')). It has no initial content, but we can add bytes later. This is memory-efficient for scenarios where we are gathering data piece by piece.

2. Creatiing a bytearray from an integer

Passing an integer to bytearray() creates an array of that size, initialized with null bytes(\x00, or 0). this is useful when we know how many bytes we will need and want to pre-allocate space, avoiding resizing overhead. Each element is set to 0 by default, and we can overwrite them later. It's a common approach in performance-sensitive application, like buffering data a preparing a fixed-length binary structure.

bytearray(b'\x00\x00\x00\x00')
4
bytearray(b'A\x00\x00\x00')

bytearray(4) creates a 4-byte array filled with zeros. You can modify any byte by index, as shown with ba[0] = 65. This method ensures a fixed initial size, which you can then customize.

3. Creating a bytearray from a string with encoding

We can create a bytearray from a string by providing the string and an encoding (e.g., 'utf-8', 'ascii'). The string is converted to its byte representation based on the encoding, and the result is a mutable bytearray. This is handy when working with text that needs to be processed as bytes, like preparing data for a file or network transmission. The optional errors parameter lets us handle invalid characters (e.g., 'ignore' skips them).

bytearray(b'Hello')
5
bytearray(b'Hillo')

"Hello" is encoded to bytes using UTF-8, producing b'Hello'. The resulting bytearray has 5 bytes (one per character in this case), and you can modify it, as shown by changing the second byte. If you omit encoding, you’ll get a TypeError.

4. Creating a bytearray from an iterable of integers

Passing an iterable (like a list, tuple, or set) of integers (0-255) to bytearray() creates a bytearray where each integer becomes a byte. This is perfect when we already have a collection of byte values, such as ASCII codes or raw binary data, and want to work with them as a mutable sequence. Each value must be in the valid byte range (0-255), or Python raises a ValueError. It’s a direct way to construct a bytearray from numeric data.

bytearray(b'Hello')
5
bytearray(b'Wello')

The list [72, 101, 108, 108, 111] corresponds to the ASCII values for "Hello". The bytearray is initialized with these values, and you can modify them, as shown with ba[0] = 87. This method is explicit and precise for byte-level control.

5. Creating a bytearray from another bytearray or byte object

We can create a bytearray by passing an existing bytearray or bytes object to bytearray(). This copies the data into a new bytearray, giving us a mutable version of the original. It’s useful when we have immutable bytes data (e.g., from a file or network) that we need to edit. The new bytearray is independent, so changes don’t affect the source. No encoding is needed since the input is already in byte form.

bytearray(b'Python')
bytearray(b'Bython')
b'Python'

The bytes object b"Python" is copied into a bytearray. Modifying ba doesn’t affect original because it’s a separate copy. This method bridges immutable bytes to mutable bytearray workflows.