XQA
Back to Python
2026-03-305 min read

Python bytes

Learn Python bytes step by step with clear examples and exercises.

Title: Python Bytes - A full guide to Working with Byte Strings

Why This Matters

In this lesson, we delve into the world of byte strings in Python. Understanding bytes is crucial for working with data that isn't text-based, such as images, audio files, and network communication. Knowledge of bytes can also help you avoid common pitfalls when dealing with internationalized applications and improve your performance when handling large amounts of binary data.

Prerequisites

Before diving into the core concept, make sure you have a solid understanding of the following topics:

  1. Python basics (variables, data types, operators)
  2. Strings in Python (string literals, string methods, string formatting)
  3. File handling in Python (reading and writing files)

Core Concept

What are bytes?

In Python, bytes are a sequence of small integers, each representing a single character from the ASCII table or its extensions (UTF-8, UTF-16, etc.). The values range from 0 to 255. Unlike strings, bytes are immutable and do not support operations like concatenation or slicing directly.

Creating a byte object

byte_object = b'Hello, World!'

print(type(byte_object)) #


### Byte literals

Byte literals are created using the `b` prefix before the string. The backslashes (`\`) in the byte literal can be used to escape certain characters like `n`, `t`, and `b`.

Creating a byte object with escapes

escaped_byte_object = b'Hello\tnWorld!'

print(escaped_byte_object) # b'Hello\tnWorld!'

Decoding the byte object to print the actual string

print(escaped_byte_object.decode()) # Hello

t

World!


### Byte methods

Bytes objects have several built-in methods for common operations, such as decoding, encoding, and counting occurrences of a specific byte. Here are some examples:

1. `bytes.encode()` - Encodes the bytes object into another encoding format (e.g., ASCII, UTF-8).
2. `bytes.decode()` - Decodes the bytes object from an encoding format back to a string.
3. `bytes.count(byte)` - Returns the number of occurrences of a specific byte in the bytes object.
4. `bytes.find(byte)` - Searches for the first occurrence of a specific byte and returns its index, or -1 if not found.
5. `bytes.index(byte)` - Similar to `find()`, but raises a ValueError if the byte is not found.

### Byte operations

While bytes objects are immutable, you can perform operations like comparison, slicing, and concatenation using the `+` operator with the help of the `bytes()` constructor.

Concatenating two byte objects

byte_object1 = b'Hello,'

byte_object2 = b'World!'

concatenated_byte_object = byte_object1 + byte_object2

print(concatenated_byte_object) # b'Hello,World!'


### Byte I/O operations

To read and write bytes from files, you can use the built-in `open()` function with the `'rb'` (read binary) mode.

Reading a byte from a file

with open('example.bin', 'rb') as f:

byte = f.read(1) # Reads one byte at a time

print(byte) # Outputs the byte as an integer

Writing bytes to a file

with open('output.bin', 'wb') as f:

f.write(b'Hello, World!')

Worked Example

In this example, we will decode and encode a byte object, count specific bytes, find and index specific bytes, and perform I/O operations on a file containing binary data.

Creating a byte object with specific bytes

byte_object = b'\x48\x65\x6c\x6c\x6f' # 'Hello' in ASCII

print(byte_object) # b'\x48\x65\x6c\x6c\x6f'

Decoding the byte object to print the actual string

print(byte_object.decode()) # Hello

Encoding a string to bytes (ASCII encoding)

encoded_string = 'Hello, World!'.encode('ascii')

print(encoded_string) # b'Hello, World!'

Counting the number of occurrences of a specific byte

count = byte_object.count(b'\x6c') # Counts the number of 'l' characters

print(count) # Outputs: 4

Finding and indexing a specific byte

index1 = byte_object.find(b'\x65') # Finds the first occurrence of 'e'

index2 = byte_object.index(b'\x65') # Indexes the first occurrence of 'e' (raises ValueError if not found)

print(f"Index of e: {index1}, {index2}") # Outputs: Index of e: 1, 1

Reading and writing bytes from a file

with open('example.bin', 'rb') as f:

byte = f.read(1) # Reads one byte at a time

print(byte) # Outputs the byte as an integer

with open('output.bin', 'wb') as f:

f.write(b'Hello, World!'.encode()) # Writes the encoded string to the file

Common Mistakes

  1. Forgetting to decode bytes when expecting a string output.
  2. Using the + operator with mutable strings instead of creating new byte objects.
  3. Not handling exceptions when indexing or finding specific bytes that are not present in the byte object.
  4. Assuming that bytes can be concatenated, sliced, and manipulated like strings without proper encoding/decoding.
  5. Failing to close files when working with I/O operations.

Practice Questions

  1. Write a function that takes a byte object as input and returns the number of occurrences of each unique byte in the byte object.
  2. Given a binary file containing images, write a Python script to read the first 10 bytes from each image and print their hexadecimal values.
  3. Write a script to convert an ASCII text file into a binary file containing the same data.
  4. Write a function that takes two byte objects as input and returns a new byte object containing the concatenation of both input byte objects.
  5. Write a script to read a binary file, find the first occurrence of a specific byte, and replace it with another byte.

FAQ

  1. Why can't I perform string operations directly on bytes?
  • Because bytes are immutable, they don't support operations like concatenation or slicing directly. However, you can use the + operator with the help of the bytes() constructor to achieve similar results.
  1. What happens when I try to perform a string operation on a byte object without decoding it?
  • If you attempt to concatenate, slice, or manipulate a byte object like a string without proper encoding/decoding, you will get unexpected results, as bytes and strings have different data types and operations.
  1. How can I read binary files in Python?
  • To read binary files in Python, use the open() function with the 'rb' (read binary) mode. This allows you to read the file as raw binary data.
  1. What are some common encodings for byte objects in Python?
  • Some common encodings for byte objects in Python include ASCII, UTF-8, and UTF-16. Each encoding has its own set of supported characters and character ranges.
Python bytes | Python | XQA Learn