Python bytes() Function

Spread the love

The bytes() function in Python creates a bytes object which is an immutable (unchangeable) sequence of integers in the range 0 <= x < 256. Since it’s immutable, once a bytes object is created, it cannot be modified unlike bytearray objects.

bytes() Syntax

The syntax of bytes( ) function is:

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

bytes() Parameters

bytes( ) takes three optional parameters:

  • source (Optional) – source to initialize the array of bytes.
  • encoding (Optional) – if the source is a string, the encoding of the string.
  • errors (Optional) – if the source is a string, the action to take when the encoding conversion fails.

bytes() Return Value

The bytes( ) function returns a bytes object of the given size and initialization values.

Constructing a bytes Object

a. Without any arguments:

When the bytes() function is invoked without providing any arguments, it generates an empty bytes object. But to understand its significance, it’s essential first to comprehend what a bytes object is.

Creating an empty bytes object:

To create an empty bytes object, simply call the bytes() function without any arguments:

b = bytes()
print(b)  # Outputs: b''

The resultant variable b now holds an empty bytes object, often denoted as b''.

Why would you need an empty bytes object?

On the surface, an empty bytes object might appear unremarkable or even pointless, but it has several applications:

  1. Initialization: In some coding scenarios, especially when dealing with binary data streams, you might want to initialize a bytes object and later extend or concatenate it with other bytes data. An empty bytes object serves as a neutral starting point, much like initializing an empty list or string in other contexts.
  2. Data checks: An empty bytes object can be used in conditions to check if some data-processing functions or operations have returned any data. For example, reading from a file or a network stream might result in an empty bytes object if there’s no data, and you can use this to take appropriate actions in your program.
  3. Separation or Padding: In some protocols or file formats, an empty byte or a sequence of empty bytes might be used for padding or as separators.

Behavior and Operations:

An empty bytes object behaves like any other bytes object, just without content. You can:

  • Check its length using the len() function, which will return 0.
  • Concatenate it with other bytes objects.
  • Use it in conditions, where it’ll evaluate to False if treated as a boolean, given its emptiness.


Consider a scenario where you’re reading chunks of binary data from a source, and you want to concatenate them:

data_source = [b'Hello', b' ', b'World!']
data = bytes()  # Initialize an empty bytes object

for chunk in data_source:
    data += chunk

print(data)  # Outputs: b'Hello World!'

In the above example, the empty bytes object acts as a starting point to accumulate data.

b. Using an integer:

When you provide an integer, say n, as an argument to the bytes() function, the result is a bytes object of length n. Each byte in this object is initialized to 0, which corresponds to a null byte (\x00 in hexadecimal notation).

What is a null byte?

A null byte, represented as \x00, is a byte with all bits set to 0. In the ASCII character set, the null byte corresponds to the character with the code value 0. It is often used to denote the end of strings in some programming languages and contexts, notably in C-style strings.

Creating a bytes object with null bytes:

To generate a bytes object filled with null bytes, simply call the bytes() function and pass the desired length as an argument:

b = bytes(5)

This creates a bytes object b of length 5, filled with null bytes. It would be represented as:


Why would you need a bytes object filled with null bytes?

There are several scenarios where such a bytes object can be handy:

  1. Buffer Initialization: When working with file I/O operations or network communications, you might need to create a buffer of a specific size to read or write data. Initializing this buffer with null bytes ensures that there’s no garbage or unexpected data in it.
  2. Data Padding: In some binary protocols or file formats, you might need to pad data to ensure it meets a certain length requirement. Using null bytes is a common way to achieve this padding.
  3. Placeholder for Replacement: If you know the length of the data you’re going to work with but don’t have the actual data yet, you can create a placeholder bytes object with null bytes and replace its content later as required.

Operations on a bytes object filled with null bytes:

Even though the bytes object is filled with null bytes, it behaves like any other bytes object. You can:

  • Check its length using len().
  • Access individual bytes through indexing.
  • Slice it to obtain a subset.
  • Concatenate it with other bytes objects.

However, since bytes objects are immutable, you cannot modify the individual bytes directly. If you need mutable byte sequences, you’d use the bytearray() function instead.


Imagine you’re creating a binary file with fixed-size records, where each record is 50 bytes long. If a particular record has data that is less than 50 bytes, you’d pad it with null bytes:

record_data = b'Hello, World!'
padding_needed = 50 - len(record_data)
padded_record = record_data + bytes(padding_needed)

In the example above, the record is padded with null bytes to ensure it’s exactly 50 bytes long.

c. Using a string:

Strings in Python are sequences of characters, but computers fundamentally understand binary data (0s and 1s). Encoding is the process of converting these character-based strings into a sequence of bytes. When you want to represent a string as a bytes object, you must specify the encoding to be used for this conversion.

How to create a bytes object from a string:

To generate a bytes object from a string, you pass the string as the first argument and the encoding as the second argument to the bytes() function:

s = "Hello, World!"
b = bytes(s, 'utf-8')

Here, b will be a bytes object representing the string “Hello, World!” encoded in UTF-8.

Understanding Encoding:

Encoding is a mapping between characters and bytes. There are several encodings available, each designed to handle text in specific languages or scenarios:

  • UTF-8: This is a universally accepted encoding that can represent any character in the Unicode standard. It’s variable-width, meaning characters can be represented using 1 to 4 bytes. Due to its widespread acceptance and versatility, it’s often the default choice.
  • ASCII: An older encoding that can represent only English characters and some control characters. It uses 1 byte per character.
  • Latin-1 (ISO-8859-1): Designed for Western European languages, it uses 1 byte per character.
  • Others: There are many other encodings like UTF-16, UTF-32, ISO-8859-5 (for Cyrillic), etc., designed for specific languages or sets of languages.

When you encode a string, each character is mapped to a specific sequence of bytes based on the chosen encoding.

Why is specifying encoding important?

Different encodings may represent the same string using different byte sequences. If you don’t specify the correct encoding, you risk data corruption, as the bytes produced might not represent the original string when decoded back.

Handling Encoding Errors:

Sometimes, a string might contain characters that are not representable in the chosen encoding. For instance, a non-English character might not be representable in ASCII. In such cases, Python raises a UnicodeEncodeError unless you specify an error-handling mechanism:

  • ‘strict’ (default): Raises a UnicodeEncodeError.
  • ‘replace’: Replaces the unencodable character with a replacement character (often '?').
  • ‘ignore’: Simply ignores the unencodable character.
  • … and others.


s = "Hello, 世界!"
b = bytes(s, 'ascii', 'replace')  
# The result will be: b'Hello, ??!'

In the above example, since “世界” cannot be represented in ASCII, it’s replaced with '??' when the 'replace' error handling strategy is used.

d. Using an iterable:

When you provide an iterable to the bytes() function, the iterable should yield integers. These integers are then taken as byte values to initialize the resultant bytes object.

How does it work?

Each integer in the iterable is expected to be in the range 0 to 255 (inclusive), representing a valid byte value. The resultant bytes object will have a length equal to the number of items in the iterable, and each byte in the object corresponds to an integer from the iterable.

Creating a bytes object from an iterable:

Here’s how you can use an iterable to create a bytes object:

iterable = [72, 101, 108, 108, 111]
b = bytes(iterable)

The resulting bytes object b will represent the ASCII string “Hello”.

Points to Remember:

  1. Valid Byte Range: Each integer in the iterable must be in the range 0 to 255. Providing values outside this range will raise a ValueError.
  2. Types of Iterables: While lists are commonly used, you’re not restricted to them. You can use any iterable, including tuples, sets, and even generators.
  3. Bytes are Immutable: Once the bytes object is created, it’s immutable. This means you cannot change its content. If you need a mutable sequence of bytes, consider using bytearray().


Consider a scenario where you’re computing a sequence of byte values based on some algorithm or criteria. A generator can be a perfect fit for such use cases:

def byte_generator():
    for i in range(5):
        yield i * 50  # Just a simple example logic

b = bytes(byte_generator())

In the above example, the generator produces values 0, 50, 100, 150, and 200, which are used to create the bytes object.

Common Operations with bytes:

a. Indexing and Slicing:

Indexing: Like strings and lists, bytes support indexing. When you index a bytes object, you get an integer in return, representing the byte at that position.

b = b'hello'
print(b[1])  # Outputs: 101 (ASCII value for 'e')

Slicing: Slicing a bytes object returns another bytes object containing the sliced portion.

b = b'hello'
print(b[1:4])  # Outputs: b'ell'

b. Concatenation and Repetition:

Concatenation: You can concatenate two bytes objects using the + operator.

b1 = b'hello'
b2 = b' world'
print(b1 + b2)  # Outputs: b'hello world'

Repetition: Use the * operator to repeat a bytes object.

b = b'hello'
print(b * 3)  # Outputs: b'hellohellohello'

c. Searching and Counting:

Searching: Use the find() method to search for a subsequence. It returns the start index of the first occurrence, or -1 if not found.

b = b'hello world'
print(b.find(b'world'))  # Outputs: 6

Counting: The count() method returns the number of non-overlapping occurrences of a subsequence.

b = b'hello world, hello universe'
print(b.count(b'hello'))  # Outputs: 2

d. Splitting and Joining:

Splitting: The split() method divides the bytes object around a delimiter and returns a list of bytes.

b = b'apple,banana,cherry'
print(b.split(b','))  # Outputs: [b'apple', b'banana', b'cherry']

Joining: Conversely, you can join a list of bytes objects using a delimiter with the join() method.

fruits = [b'apple', b'banana', b'cherry']
print(b','.join(fruits))  # Outputs: b'apple,banana,cherry'

e. Transformations:

Replace: Use the replace() method to replace occurrences of a sequence with another.

b = b'hello world'
print(b.replace(b'world', b'universe'))  # Outputs: b'hello universe'

Case Operations: Methods like upper(), lower(), capitalize(), etc., change the case of ASCII characters in the bytes object.

b = b'Hello World'
print(b.lower())  # Outputs: b'hello world'

f. Length and Membership:

Length: The built-in len() function returns the number of bytes in the object.

b = b'hello'
print(len(b))  # Outputs: 5

Membership: Use the in keyword to check if a subsequence exists within the bytes object.

b = b'hello world'
print(b'world' in b)  # Outputs: True

g. Decoding:

Decoding: Convert a bytes object into a string using the decode() method. You’ll typically specify the encoding (like ‘utf-8’).

b = b'hello'
s = b.decode('utf-8')
print(s)  # Outputs: 'hello'

h. Iterating:

Iterating: Bytes objects are iterable. You can loop over them using a for loop, and each iteration yields an integer (the byte value).

b = b'hello'
for byte in b:



This will print the ASCII values of the characters in the word “hello”.


Python’s bytes() function provides a versatile tool for representing and working with byte data. While it closely mirrors bytearray in many respects, its immutability sets it apart, offering unique advantages and use-cases. Whether dealing with binary files, crafting network packets, or interfacing with other software, bytes offers a reliable and straightforward way to handle byte-oriented data in Python.

Leave a Reply