Python Bytes: Creation, Conversion, and Operations
Learn how to create, convert, and manipulate Python bytes objects, including encoding, decoding, binary file handling, and common pitfalls.

Python bytes objects represent sequences of integers in the range 0 to 255. They are used whenever you work with binary data, such as file contents, network packets, or cryptographic hashes. Understanding how to create and manipulate bytes is essential for many low-level programming tasks.
What Are Python Bytes?
A bytes object is an immutable sequence of integers, each between 0 and 255. Unlike strings, which are sequences of Unicode characters, bytes are raw data. They are often the result of encoding a string with a specific character encoding, or they come directly from I/O operations that read binary data.
Python also provides a mutable counterpart, bytearray, which you can modify in place. The choice between bytes and bytearray depends on whether you need to change the data after creation.
| Feature | bytes | bytearray |
|---|---|---|
| Mutability | Immutable | Mutable |
| Creation | b'...' | bytearray(b'...') |
| Use case | Read-only data | In-place modification |
Creating Bytes Objects
There are several ways to create a bytes object:
- Bytes literal: Use a
bprefix with a string literal. For example,b'hello'. - From a string: Call
str.encode()with an encoding, such as'utf-8'. - From an iterable of integers: Pass a list or range of integers to
bytes(). - From a hexadecimal string: Use
bytes.fromhex().
# Bytes literal
data = b'hello'
# From a string
text = "hello"
data = text.encode('utf-8')
# From an iterable of integers
data = bytes([104, 101, 108, 108, 111]) # ASCII values
# From a hex string
data = bytes.fromhex('68656c6c6f')The bytes() constructor with no arguments creates an empty bytes object. When you pass a single integer, it creates a bytes object of that length filled with null bytes.
Converting Between Bytes and Strings
The most common conversion is between bytes and strings. Use encode() on a string to get bytes, and decode() on bytes to get a string. Always specify the encoding explicitly to avoid platform-dependent defaults.
text = "café"
data = text.encode('utf-8') # b'caf\xc3\xa9'
decoded = data.decode('utf-8') # 'café'When decoding, you may encounter errors if the bytes are not valid for the specified encoding. You can handle these with the errors parameter, which accepts values like 'ignore', 'replace', or 'strict' (the default).
data = b'\xff\xfe'
try:
text = data.decode('utf-8')
except UnicodeDecodeError:
text = data.decode('utf-8', errors='replace')Common Operations on Bytes
Bytes support many of the same operations as strings, but they work with integer values instead of characters.
- Indexing returns an integer:
data[0]gives the first byte as an int. - Slicing returns a new bytes object.
- Concatenation uses
+and repetition uses*. - Membership tests with
incheck for an integer or a subsequence. - Methods like
find(),replace(),split(), andjoin()work similarly to strings but expect bytes arguments.
data = b'hello world'
first_byte = data[0] # 104
sub = data[0:5] # b'hello'
combined = data + b'!' # b'hello world!'
repeated = b'ab' * 3 # b'ababab'
has_hello = b'hello' in data # TrueThe split() method returns a list of bytes objects, and join() combines a list of bytes objects with a separator.
Working with Binary Data
Binary files are read and written using the 'rb' and 'wb' modes. When you read a binary file, you get a bytes object.
with open('image.png', 'rb') as f:
data = f.read()To write bytes, open the file in binary write mode.
with open('output.bin', 'wb') as f:
f.write(data)For structured binary data, the struct module lets you pack and unpack values according to a format string. This is useful for reading binary protocols or file formats.
import struct
packed = struct.pack('>I', 1024) # big-endian unsigned int
value = struct.unpack('>I', packed)[0] # 1024Performance and Memory Considerations
Bytes objects are immutable, so operations that modify them, like concatenation, create a new object. If you need to build a large bytes object incrementally, consider using bytearray or collecting parts in a list and joining them at the end.
parts = []
for i in range(1000):
parts.append(bytes([i % 256]))
result = b''.join(parts)Using bytearray allows in-place modification, which can be more memory-efficient when you need to update data frequently.
buf = bytearray(b'hello')
buf[0] = ord('H') # b'Hello'When dealing with large binary data, be mindful of copying. Slicing a bytes object creates a copy, whereas memoryview provides a view without copying, which can be useful for zero-copy operations.
Common Pitfalls and How to Avoid Them
One frequent mistake is mixing bytes and strings. You cannot concatenate a str with bytes directly; you must encode or decode one of them first.
# This raises TypeError
# data = b'hello' + ' world'
data = b'hello' + ' world'.encode('utf-8')Another pitfall is assuming that indexing a bytes object returns a one-byte bytes object. It actually returns an integer, so comparisons with string characters will fail.
data = b'abc'
if data[0] == 'a': # False, because data[0] is 97
pass
if data[0] == 97: # True
passEncoding errors are also common when decoding data that was not encoded with the expected encoding. Always specify the encoding and handle errors appropriately.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.