Read a Binary File in Python: A Complete Guide for Beginners and Professionals
When you need to work with raw data—such as images, audio samples, compiled executables, or custom data formats—you must read a binary file in Python instead of treating the content as text. Binary files store information as a sequence of bytes, and interpreting those bytes correctly is essential for accurate processing. This article walks you through the concepts, tools, and best practices for reading binary data safely and efficiently, with clear code examples you can adapt to your own projects.
Why Reading Binary Files Differs from Text Files
Text files are typically encoded using a character set like UTF‑8 or ASCII, which means each byte (or group of bytes) corresponds to a printable character. When you open a text file with mode 'r', Python automatically decodes the bytes into Unicode strings, making it easy to manipulate lines and words And that's really what it comes down to..
Binary files, however, contain non‑character data. Opening them with a text mode would trigger unwanted decoding attempts, possibly raising a UnicodeDecodeError or corrupting the data. That's why, you must open the file in binary mode ('rb') and handle the raw bytes yourself, often converting them to integers, floats, or custom structures using libraries such as struct, numpy, or pickle It's one of those things that adds up. Which is the point..
Counterintuitive, but true That's the part that actually makes a difference..
Core Concepts Before You Start
| Concept | Description | Typical Use |
|---|---|---|
Binary mode ('rb') |
Opens the file for reading raw bytes without any encoding/decoding. | |
NumPy fromfile |
Reads binary data directly into a NumPy array, respecting dtype and shape. | Multi‑byte numeric types. |
| Pickle | Serializes Python objects to a binary stream and can reconstruct them later. | All binary file operations. |
| Struct format strings | Mini‑language that tells struct how to pack/unpack bytes into Python values. |
Numerical datasets, images, scientific data. |
Memory mapping (mmap) |
Maps a file (or part of it) directly into the process’s address space, allowing slice‑like access. | |
| Byte order (endianness) | Determines whether the most significant byte comes first (big‑endian) or last (little‑endian). | Saving/loading complex Python objects. |
Honestly, this part trips people up more than it should Turns out it matters..
Understanding these building blocks lets you choose the most appropriate method for your specific binary format.
Step‑by‑Step: Reading a Simple Binary File
Let’s start with a concrete example: a file that contains a sequence of 32‑bit signed integers stored in little‑endian order. We’ll walk through three common ways to read it.
1. Using the Built‑in open and struct
import struct
def read_ints_with_struct(filepath, count=None):
"""Read little‑endian 32‑bit signed integers from a binary file."""
fmt = ' mm. That said, size():
raise ValueError("Offset exceeds file size")
mm. seek(offset)
data = mm.read(4)
(value,) = struct.
**Explanation**
- `mmap.mmap` maps the whole file (length = 0 means map the entire file).
- We can `seek` to any offset and read exactly the number of bytes we need.
- This approach is ideal for indexed formats (e.g., video frames, tile maps) where you only need scattered pieces.
---
## Handling More Complex Binary Structures
Real‑world binary formats often consist of **records** made up of multiple fields of different types. The `struct` module shines here because you can describe the whole record with a single format string.
### Example: Reading a Simple Header + Payload
Suppose a file starts with an 8‑byte magic number (ASCII), followed by a 4‑byte unsigned integer indicating the number of records, and then each record contains:
- 2‑byte unsigned short (ID)
- 4‑byte float (little‑endian)
- 1‑byte unsigned char (flag)
```python
import struct
HEADER_FMT = '<8sI' # 8‑byte string, 4‑byte unsigned int
RECORD_FMT = ' 