Guía de archivos binarios en Python: lectura y escritura

1. Introducción

Python admite no solo archivos de texto, sino también la lectura y escritura de archivos binarios. Al trabajar con archivos binarios, es posible manipular imágenes, audio, video, archivos comprimidos y diversos tipos de datos. En este artículo, explicaremos cómo leer archivos binarios de forma segura y eficiente usando Python.

1.1 Qué es un archivo binario

Un archivo binario es un archivo compuesto por datos binarios (una combinación de 0 y 1) que la computadora puede interpretar, y no por cadenas de texto legibles directamente por humanos. Algunos ejemplos representativos de archivos binarios son los siguientes.

• Archivo de imagen (PNG, JPEG, BMP, etc.)
• Archivo de audio (WAV, MP3, AAC, etc.)
• Archivo de video (MP4, AVI, MOV, etc.)
• Archivo comprimido (ZIP, RAR, GZ, etc.)
• Archivo ejecutable de programa (EXE, DLL, BIN, etc.)

Los archivos binarios, al abrirse con un editor de texto convencional, suelen mostrarse como “texto corrupto”. Esto se debe a que los datos están codificados en un formato específico y no se convierten en información legible sin ser analizados con el programa adecuado.

1.2 Diferencias con los archivos de texto

La principal diferencia entre los archivos binarios y los archivos de texto es su método de almacenamiento de datos.

Principales diferencias

1. Estructura de datos

• Los archivos de texto solo contienen datos que pueden interpretarse como caracteres.
• Los archivos binarios pueden contener cualquier tipo de datos (imágenes, audio, código ejecutable, etc.).

1. Tamaño

• Cuando los datos guardados son pocos, los archivos de texto tienden a ser más pequeños.
• Los archivos binarios pueden ser más grandes incluso con el mismo contenido, debido al impacto de la codificación.

1. Método de edición

• Los archivos de texto pueden abrirse y editarse directamente con editores como Notepad o VS Code.
• Los archivos binarios requieren un programa especializado (p.ej., editor binario) para editarlos.

1.3 Necesidad de manejar archivos binarios con Python

Las razones para manipular archivos binarios con Python incluyen los siguientes puntos.

① Procesamiento de datos de imagen y audio

Al leer archivos binarios, los programas en Python pueden analizar imágenes y procesar datos de audio.

# Example: Read a PNG image file as binary
with open("image.png", "rb") as file:
    binary_data = file.read()
    print(binary_data[:20])  # Display the first 20 bytes

② Análisis de datos comprimidos

Python cuenta con módulos como zipfile y gzip que permiten descomprimir y comprimir archivos ZIP y GZ mediante código.

import gzip

# Example: Open a GZ-compressed file
with gzip.open("example.gz", "rb") as file:
    content = file.read()
    print(content)

③ Análisis de protocolos binarios

En comunicaciones de red y operaciones de bajo nivel en bases de datos, es necesario analizar datos binarios. Con el módulo struct, se puede convertir datos binarios a números o cadenas.

import struct

# Example: Convert binary data to an integer
binary_data = b'x01x00x00x00'  # 4-byte data
integer_value = struct.unpack('<I', binary_data)[0]
print(integer_value)  # Output: 1

1.4 Resumen

• Los archivos binarios son formatos de archivo utilizados para almacenar información como imágenes, audio y datos comprimidos.
• A diferencia de los archivos de texto, los datos se guardan como secuencias de bytes de 0 y 1.
• Con Python, es posible analizar datos binarios y realizar procesamiento o conversión.
• Al usar las funciones open() de Python y el módulo struct, se puede manejar archivos binarios de manera eficiente.

2. Cómo leer archivos binarios en Python y operaciones básicas

En Python, usando la función open() para abrir y leer archivos binarios se puede hacer. Esta sección explica los métodos básicos para manipular archivos binarios en Python.

2.1 Lectura de archivos binarios usando la función open()

La función open() de Python es la función básica para abrir archivos. Cuando se abre un archivo binario, se debe especificar 'rb' (modo binario de solo lectura).

Sintaxis básica

file = open("example.bin", "rb")  # 'rb' means "read in binary mode"
binary_data = file.read()  # Read the contents of the file
file.close()  # Close the file

Sin embargo, con este método, si no se llama explícitamente a close(), el archivo no se cierra, lo que puede causar fugas de recursos. Por ello, en Python es común usar la sentencia with para abrir archivos de forma segura.

2.2 Lectura segura de archivos binarios usando la sentencia with

Al usar la sentencia with, el archivo se cierra automáticamente, por lo que incluso si ocurre un error, los recursos se liberan adecuadamente.

Ejemplo: Lectura segura de datos binarios

with open("example.bin", "rb") as file:
    binary_data = file.read()

# When leaving the with-block, the file is automatically closed

Ventajas de usar la sentencia with

1. No es necesario llamar a file.close() (se cierra automáticamente)
2. Incluso si ocurre un error, no hay fuga de recursos
3. El código es más simple y mejora la legibilidad

2.3 Variaciones de métodos de lectura

Python ofrece varios métodos para leer archivos binarios. Elija el método adecuado según el caso de uso.

① Leer todos los datos de una vez (read())

Método que carga todo el contenido del archivo binario en la memoria.

with open("example.bin", "rb") as file:
    binary_data = file.read()  # Read all data at once

Ventajas

• Simple y fácil de entender
• Eficiente para archivos pequeños

Desventajas

• En archivos grandes (de varios cientos de MB a GB), puede consumir mucha memoria

② Leer en bloques de bytes especificados (read(n))

Leer el archivo en partes es adecuado para procesar archivos de gran tamaño.

with open("example.bin", "rb") as file:
    chunk = file.read(1024)  # Read 1024 bytes (1KB) at a time
    while chunk:
        print(chunk)  # Process the read data
        chunk = file.read(1024)  # Read the next 1024 bytes

Ventajas

• Reduce el consumo de memoria
• Procesa eficientemente incluso archivos grandes

Desventajas

• No es adecuado para procesar el archivo completo de una sola vez

③ Leer datos binarios línea por línea (readline())

Si los datos binarios contienen saltos de línea, es posible leerlos línea por línea.

with open("example.bin", "rb") as file:
    line = file.readline()  # Read one line at a time
    while line:
        print(line)
        line = file.readline()  # Read the next line

Usos

• Archivos de registro binario y otros datos binarios que contienen saltos de línea

Precauciones

• Si no hay saltos de línea, todo se considera una sola línea, por lo que solo es válido para archivos apropiados

2.4 Operación de posición de archivo usando seek()

Al usar seek(), se pueden leer datos desde cualquier posición del archivo.

Sintaxis básica de seek()

file.seek(offset, whence)

Ejemplo: Leer datos desde la mitad del archivo

with open("example.bin", "rb") as file:
    file.seek(10)  # Move to the 10th byte from the start
    data = file.read(5)  # Read 5 bytes
    print(data)

Usos

• Obtener la información del encabezado del archivo
• Analizar una parte específica de los datos

2.5 Obtener la posición actual del archivo con tell()

Al usar el método tell(), se puede obtener la posición actual del archivo (desplazamiento en bytes).

Ejemplo: Verificar la posición del archivo

with open("example.bin", "rb") as file:
    file.read(10)  # Read 10 bytes
    position = file.tell()  # Get the current file position
    print(f"Current position: {position} bytes")

Usos

• Confirmar hasta dónde se ha leído el archivo
• Depuración al procesar el archivo a mitad de camino

2.6 Resumen

• Al abrir archivos binarios en Python, use el modo 'rb'
• Usando la sentencia with se puede cerrar el archivo de forma segura
• Leer todos los datos de una vez (read()) consume mucha memoria, por lo que para archivos grandes se debe usar read(n)
• Con seek() se puede mover a cualquier posición del archivo, y con tell() se puede obtener la posición actual

3. Lectura eficiente de archivos binarios con Python

En la sección anterior se explicó el método básico para abrir archivos binarios. En esta sección se describirá en detalle cómo leer archivos binarios de manera eficiente. En Python es posible leer datos binarios de diversas formas, y es importante elegir la técnica adecuada según el caso de uso.

3.1 Leer todo el contenido de un archivo binario de una sola vez（read()）

Para leer un archivo binario de una sola vez, se utiliza el método read().

Sintaxis básica

with open("example.bin", "rb") as file:
    binary_data = file.read()

Ventajas

• Simple e intuitivo
• Adecuado para archivos pequeños (menos de varios MB)

Desventajas

• Consume mucha memoria cuando el archivo es grande (cientos de MB o más)
• Puede provocar que el programa se bloquee si no cabe en la memoria

Ejemplo

with open("sample.bin", "rb") as file:
    binary_data = file.read()
    print(len(binary_data))  # Display file size (in bytes)

Este método funciona sin problemas para archivos de varios MB.

3.2 Leer archivos binarios en bloques de un número de bytes especificado（read(n)）

Cuando se manejan archivos binarios de gran tamaño, se recomienda leerlos en bloques de un número de bytes fijo, considerando la eficiencia de memoria.

Sintaxis básica

with open("example.bin", "rb") as file:
    chunk = file.read(1024)  # Read 1024 bytes (1KB) at a time
    while chunk:
        print(chunk)
        chunk = file.read(1024)  # Read the next 1024 bytes

Ventajas

• Reduce la carga de memoria al manejar archivos de gran tamaño
• Permite procesamiento en streaming

Desventajas

• Se requiere procesamiento adicional si se necesita procesar datos en tiempo real

Ejemplo

with open("large_file.bin", "rb") as file:
    while True:
        chunk = file.read(4096)  # Read 4KB at a time
        if not chunk:
            break  # Stop when no more data
        print(f"Read {len(chunk)} bytes")

Con este método se pueden procesar archivos de varios GB sin saturar la memoria.

3.3 Leer datos binarios línea por línea（readline()）

Si los datos binarios contienen saltos de línea, es posible leerlos línea por línea.

Sintaxis básica

with open("example.bin", "rb") as file:
    line = file.readline()
    while line:
        print(line)
        line = file.readline()

Usos

• Adecuado para archivos de registro binario y otros datos binarios que contienen saltos de línea

Precauciones

• Si el archivo binario no contiene saltos de línea, todo se considerará una sola línea
• No se usa mucho en el procesamiento típico de datos binarios

3.4 Leer datos desde una posición específica del archivo（utilizando seek()）

Al analizar un archivo binario, a veces se necesita leer datos desde una posición específica del archivo. En esos casos se utiliza el método seek().

Sintaxis básica

file.seek(offset, whence)

Ejemplo: Leer datos desde una posición específica

with open("example.bin", "rb") as file:
    file.seek(10)  # Move to the 10th byte from the start
    data = file.read(5)  # Read 5 bytes
    print(data)

Este método es útil para analizar encabezados de archivos y procesar archivos con estructuras de datos específicas.

3.5 Obtener la posición actual del archivo（tell()）

El método tell() permite obtener la posición actual del archivo (desplazamiento en bytes).

Ejemplo

with open("example.bin", "rb") as file:
    file.read(20)  # Read 20 bytes
    position = file.tell()  # Get the current file position
    print(f"Current position: {position} bytes")

Usos

• Verificar hasta dónde se ha leído el archivo
• Depurar cuando se procesa el archivo a mitad

3.6 Lectura rápida usando archivos de memoria mapeada（mmap）

Con el módulo mmap, se puede mapear archivos binarios de gran tamaño en memoria virtual y acceder a ellos rápidamente.

Sintaxis básica

import mmap

with open("example.bin", "rb") as file:
    with mmap.mmap(file.fileno(), 0, access=mmap.ACCESS_READ) as mmapped_file:
        print(mmapped_file[:100])  # Get the first 100 bytes

Ventajas

• Permite manejar todo el archivo en memoria, lo que posibilita un acceso rápido
• Se puede acceder directamente a rangos específicos

Desventajas

• Es algo más complejo que el manejo de archivos estándar de Python
• Mapear archivos demasiado grandes puede provocar falta de memoria

3.7 Resumen

• Para leer archivos binarios de forma eficiente, es importante elegir la técnica adecuada según el tamaño del archivo y el caso de uso
• Los archivos pequeños se pueden leer de una sola vez con read()
• Los archivos grandes se procesan en bloques con read(n)
• Para obtener datos desde una posición específica del archivo, utilice seek()
• Usar mmap permite un acceso rápido a los datos, pero se debe tener cuidado según el caso de uso

4. Método de análisis de datos binarios en Python

Con Python, puedes convertir datos binarios en tipos de datos significativos como enteros, números de punto flotante, cadenas, etc.. Aquí explicamos principalmente cómo usar el módulo struct, útil para el análisis de datos binarios.

4.1 Análisis con el módulo struct

El módulo struct de Python se utiliza para analizar y convertir datos binarios al estilo de estructuras en C.

Sintaxis básica

import struct
value = struct.unpack(format, binary_data)

Ejemplo: leer un entero

import struct

# Binary data (4 bytes)
binary_data = b'x01x00x00x00'  # 1 (little-endian)

# Unpack (unsigned int, little-endian)
value = struct.unpack('<I', binary_data)[0]
print(value)  # Output: 1

Ejemplo: leer una cadena

import struct

# 10-byte binary data
binary_data = b'HelloWorld'

# Interpret as string data
decoded_string = struct.unpack('10s', binary_data)[0].decode('utf-8')
print(decoded_string)  # Output: HelloWorld

Ejemplo: leer un número de punto flotante

import struct

# 4-byte float (IEEE 754 format)
binary_data = b'x00x00x80x3f'  # Represents 1.0

# Unpack
value = struct.unpack('<f', binary_data)[0]
print(value)  # Output: 1.0

4.2 Diferencias de endian (big endian y little endian)

La interpretación de datos binarios varía según el endian (orden de bytes).

Ejemplo: verificar diferencias de endian

import struct

binary_data = b'x01x00x00x00'  # 1 (little-endian)

# Little-endian
little_endian = struct.unpack('<I', binary_data)[0]
print(f"Little Endian: {little_endian}")  # Output: 1

# Big-endian
big_endian = struct.unpack('>I', binary_data)[0]
print(f"Big Endian: {big_endian}")  # Output: 16777216

4.3 Resumen

• Al usar el módulo, puedes convertir datos binarios en enteros, números de punto flotante, cadenas, etc.
• Es necesario prestar atención a la especificación del endian (< Little Endian, > Big Endian)
• Como el endian varía según el formato de archivo, una interpretación incorrecta puede producir valores erróneos

5. Escritura de archivos binarios en Python

Hasta ahora, hemos explicado el método de lectura de archivos binarios usando Python. Aquí explicaremos el método de escritura de archivos binarios. En Python, se puede escribir datos en un archivo binario usando el modo 'wb'.

5.1 Escritura básica usando la función open()

Al especificar el modo 'wb' con la función open(), se abre el archivo en modo de escritura binaria.

Sintaxis básica

with open("example.bin", "wb") as file:
    file.write(binary_data)

Puntos

• Al especificar el modo 'wb', el contenido existente se sobrescribe
• El argumento de file.write() debe ser del tipo bytes

5.2 Escribir secuencias de bytes

En Python, los datos binarios se tratan como tipo bytes.

Ejemplo: escribir secuencias de bytes

with open("output.bin", "wb") as file:
    file.write(b'x01x02x03x04')  # Write 4 bytes of data

En este caso, se escribirán secuencialmente 4 bytes llamados 01 02 03 04 en output.bin.

5.3 Escritura de datos binarios usando struct.pack()

Al usar struct.pack(), se pueden convertir números y cadenas de Python a datos binarios y guardarlos en un archivo.

Ejemplo: escritura de enteros

import struct

# Unsigned 16-bit int (H) and unsigned 32-bit int (I)
binary_data = struct.pack('<HI', 512, 123456789)

with open("numbers.bin", "wb") as file:
    file.write(binary_data)

Ejemplo: escritura de cadenas

import struct

text = "Hello"
binary_data = struct.pack('10s', text.encode('utf-8'))  # 10-byte fixed length

with open("text.bin", "wb") as file:
    file.write(binary_data)

Ejemplo: escritura de números de punto flotante

import struct

float_value = 3.14
binary_data = struct.pack('<f', float_value)  # 4-byte float

with open("float.bin", "wb") as file:
    file.write(binary_data)

5.4 Escritura binaria en modo de anexado

Si se desea agregar datos al final del archivo, se usa el modo 'ab'.

Ejemplo: modo de anexado

with open("output.bin", "ab") as file:
    file.write(b'xffxff')  # Append data

Al ejecutar este código, se añadirá FF FF al final del output.bin existente.

5.5 Modificar una parte del archivo

Si se sobrescribe una parte de un archivo ya existente, se usa el modo 'r+b'.

Ejemplo: escribir datos en medio del archivo

with open("output.bin", "r+b") as file:
    file.seek(10)  # Move to the 10th byte
    file.write(b'ª»')  # Write 2 bytes of data

En este caso, 2 bytes a partir del byte 10 del archivo se sobrescribirán en ª».

5.6 Resumen

• Al escribir archivos binarios en Python, se usa el modo 'wb'
• Al usar struct.pack(), se pueden convertir números y cadenas a formato binario y guardarlos
• Con el modo 'ab' es posible anexar
• Con el modo 'r+b' se puede sobrescribir una parte de un archivo existente

6. Ejemplo práctico de manejo de archivos binarios con Python

Hasta aquí, hemos aprendido los métodos básicos de lectura y escritura de archivos binarios usando Python. En esta sección, presentamos ejemplos concretos de análisis y procesamiento de archivos binarios reales.

6.1 Análisis binario de imágenes PNG

¿Qué es un archivo PNG?

PNG (Portable Network Graphics) es un formato de imagen comprimido, en el que la información de encabezado y los datos de la imagen se almacenan como datos binarios.

Estructura del encabezado de un archivo PNG

Los primeros 8 bytes de un archivo PNG son un número mágico (89 50 4E 47 0D 0A 1A 0A) que indica que el archivo está en formato PNG.

Analizar datos binarios de PNG

with open("example.png", "rb") as file:
    header = file.read(8)  # Get the first 8 bytes
    print("PNG Header:", header)

Ejemplo de salida

PNG Header: b'x89PNGrnx1an'

Al verificar este número mágico, se puede determinar que el archivo está en formato PNG.

6.2 Análisis binario de archivos de audio WAV

¿Qué es un archivo WAV?

WAV (Waveform Audio File Format) es un formato de audio sin compresión que incluye información como tasa de muestreo, número de canales y profundidad de bits en el encabezado.

Análisis del encabezado de un archivo WAV

Los archivos WAV utilizan el formato RIFF y almacenan metadatos en los primeros 44 bytes.

Analizar datos binarios de WAV

import struct

with open("example.wav", "rb") as file:
    header = file.read(44)  # Get the first 44 bytes (WAV header)

    # Parse RIFF header
    riff, size, wave = struct.unpack('<4sI4s', header[:12])

    # Parse format information
    fmt, fmt_size, audio_format, num_channels, sample_rate = struct.unpack('<4sIHHI', header[12:24])

    print(f"RIFF Header: {riff}")
    print(f"Format: {wave}")
    print(f"Audio Format: {audio_format}")
    print(f"Channels: {num_channels}")
    print(f"Sample Rate: {sample_rate} Hz")

Ejemplo de salida

RIFF Header: b'RIFF'
Format: b'WAVE'
Audio Format: 1
Channels: 2
Sample Rate: 44100 Hz

• RIFF → número mágico que indica formato WAV
• Channels: 2 → audio estéreo
• Sample Rate: 44100 Hz → calidad de CD

6.3 Análisis de formato binario propio

Algunos archivos tienen un formato binario propio. En Python, es posible analizarlos usando struct.

Formato de muestra

Análisis de datos binarios

import struct

with open("custom_data.bin", "rb") as file:
    data = file.read()

    file_id, version, name = struct.unpack('<If10s', data)

    print(f"File ID: {file_id}")
    print(f"Version: {version}")
    print(f"Name: {name.decode().strip()}")

Ejemplo de salida

File ID: 12345
Version: 1.2
Name: TestFile

6.4 Resumen

• Análisis PNG → número mágico para confirmar el formato
• Análisis WAV → verificar número de canales y tasa de muestreo desde el encabezado
• Formato propio → struct.unpack() para extraer valores numéricos y cadenas

7. Precauciones y mejores prácticas al manejar archivos binarios

Al trabajar con archivos binarios en Python, existen varios puntos a considerar, como optimización del rendimiento, prevención de corrupción de datos y garantía de seguridad. Aquí se resumen las mejores prácticas para el procesamiento de archivos binarios.

7.1 Optimizar el procesamiento de archivos de gran tamaño

Los archivos binarios pueden alcanzar desde varios cientos de MB hasta varios GB. Es seguro evitar la lectura completa y procesarlos por bloques (chunks).

Ejemplo no recomendado: leer un archivo de gran tamaño de una sola vez

with open("large_file.bin", "rb") as file:
    data = file.read()  # Load entire file into memory (dangerous)

Ejemplo recomendado: procesar por bloques

with open("large_file.bin", "rb") as file:
    while chunk := file.read(4096):  # Read in 4KB chunks
        process(chunk)

7.2 Cerrar el archivo de forma segura con la sentencia with

Olvidar close() causa fugas de recursos. Siempre use la sentencia with.

Ejemplo no recomendado

file = open("example.bin", "rb")
data = file.read()
# Forgot to close() → leak

Ejemplo recomendado

with open("example.bin", "rb") as file:
    data = file.read()
# File is closed automatically

7.3 Especificar correctamente el endianness (Byte Order)

Dependiendo del entorno o protocolo, se utiliza little endian o big endian; si no se especifica correctamente, los datos pueden corromperse.

Ejemplo: diferencias de endianness

import struct

binary_data = b'x01x00x00x00'

value_le = struct.unpack('<I', binary_data)[0]  # Little Endian
print("Little Endian:", value_le)  # 1

value_be = struct.unpack('>I', binary_data)[0]  # Big Endian
print("Big Endian:", value_be)  # 16777216

7.4 Prevenir errores con manejo de excepciones

Las operaciones de archivo siempre pueden generar errores. Asegúrese de incluir try-except.

Ejemplo: lectura segura de binarios

import struct

try:
    with open("example.bin", "rb") as file:
        binary_data = file.read(4)
        value = struct.unpack('<I', binary_data)[0]
        print(f"Value: {value}")

except FileNotFoundError:
    print("Error: File not found.")
except struct.error:
    print("Error: Invalid binary format.")
except Exception as e:
    print(f"Unexpected error: {e}")

7.5 Métodos de depuración de datos binarios

Puede inspeccionar el contenido binario usando binascii.hexlify() o el hexdump de Linux.

Mostrar en hexadecimal con Python

import binascii

with open("example.bin", "rb") as file:
    binary_data = file.read(16)
    print(binascii.hexlify(binary_data))

Verificación en Linux/macOS

hexdump -C example.bin | head

7.6 Resumen

• Optimizar la eficiencia de memoria de archivos de gran tamaño mediante procesamiento por bloques
• Cerrar el archivo de forma segura usando la sentencia with
• Un endianness incorrecto puede causar corrupción de datos
• Manejar los errores de forma segura con manejo de excepciones
• Depuración posible con binascii.hexlify() o hexdump

8. Preguntas frecuentes (FAQ)

Sobre la lectura, escritura y análisis de archivos binarios, hemos recopilado los puntos que muchas personas se preguntan en formato de FAQ. Problemas y soluciones generales al manejar datos binarios con Python se explican.

Q1: ¿Cuál es la diferencia entre archivos de texto y archivos binarios?

Q2: Al abrir un archivo binario con Python, ¿cuál es la diferencia entre 'rb' y 'r'?

Q3: No entiendo cómo usar el módulo struct. ¿Cómo se usa?

struct módulo se utiliza para convertir datos binarios a números o cadenas (unpack), o viceversa a binario (pack).

Ejemplo: Convertir datos binarios a entero

import struct

binary_data = b'x01x00x00x00'
value = struct.unpack('<I', binary_data)[0]  # Little Endian unsigned int
print(value)  # 1

Q4: ¿Cómo convertir datos binarios a texto?

Representación hexadecimal al convertir aumenta la legibilidad.

import binascii

with open("example.bin", "rb") as file:
    binary_data = file.read()
    hex_data = binascii.hexlify(binary_data)
    print(hex_data)

Q5: ¿Qué es endian?

Endian se refiere al orden de los bytes.

Q6: ¿Cómo procesar eficientemente archivos binarios grandes?

Se recomienda el método de leer por bloques (chunks) parciales.

with open("large_file.bin", "rb") as file:
    while chunk := file.read(4096):  # Read in 4KB chunks
        process(chunk)

Q7: ¿Cómo depurar datos binarios?

Se utilizan los comandos binascii.hexlify() de Python y hexdump de Linux.

Verificación con Python

import binascii

with open("example.bin", "rb") as file:
    binary_data = file.read(16)
    print(binascii.hexlify(binary_data))

Verificación en Linux/macOS

hexdump -C example.bin | head

Resumen

• Abrir binario en modo 'rb'
• Usar struct para pack/unpack y realizar análisis o escritura
• Es importante especificar correctamente el endian
• Los archivos de gran tamaño se optimizan con procesamiento por chunks
• Depuración posible con binascii.hexlify() y hexdump

Finalmente

Con esto, se ha completado la guía completa de lectura, escritura y análisis de archivos binarios con Python. En el futuro, aplíquela en proyectos reales y utilícela para procesos más avanzados 🚀