Saltearse al contenido

array, memoryview y struct

Hasta aquí, cada valor era un objeto con cabecera. Estas tres herramientas rompen esa regla a propósito: trabajan con bytes y con valores crudos, sin objetos intermedios. Son la frontera entre Python y el resto del mundo —archivos binarios, redes, sensores, librerías en C— y también la respuesta cuando un millón de números no cabe o no rinde.

array guarda el valor, memoryview lo mira, struct lo interpreta. Ninguno de los tres crea objetos por elemento.

Mil enteros: dos formas de guardarlos
list — 8 B por puntero → 8 B → 8 B → 8 B → 8 B = 8 056 B array('i') — 4 B por valor int 4 B int 4 B int 4 B int 4 B = 4 200 B

La lista apunta a objetos de 28 bytes que el dibujo no muestra. El array guarda los enteros consecutivos, sin punteros ni cabeceras.

Un array se crea declarando el tipo, y esa declaración decide cuántos bytes ocupa cada elemento:

from array import array
enteros = array("i", [1, 2, 3]) # 4 B por elemento, hasta 2**31-1
grandes = array("q", [1, 2, 3]) # 8 B por elemento
reales = array("d", [1.5, 2.5]) # 8 B, coma flotante
1 000 elementos
Estructura Memoria Por elemento
list[int] 8 056 B 8.0 B
array('i') 4 200 B 4.2 B
deque 8 680 B 8.7 B

python mediciones/02-01-04-secuencias.py

En 100 000 elementos, el array ahorra unos 0,4 MB sólo en el contenedor (3,5 MB si se cuentan los enteros de 28 B que la lista además mantiene); en un millón, 4 y 35. Y con enteros grandes el ahorro es mayor, porque la lista además paga los objetos de 28 bytes.

El array sigue copiando al hacer slicing. memoryview no: es una ventana sobre los mismos bytes.

Cortar 500 000 elementos
Expresión Coste Qué hace
lista[:500_000] 3 476 µs copia 4 MB
memoryview(array)[:500_000] 0.24 µs devuelve una vista

python mediciones/02-01-04-secuencias.py

from array import array
datos = array("i", range(1_000_000))
ventana = memoryview(datos)[:500_000] # instantáneo
ventana[0] = 99 # escribe en el array original
datos[0] # 99

Esa última línea es la clave: la vista no es una copia, así que escribir en ella modifica el original. Es lo mismo que un puntero bien tipado, con la ventaja de que Python comprueba los límites.

memoryview funciona sobre bytes, bytearray y array. Sobre bytes es de sólo lectura, porque bytes es inmutable.

Un archivo binario o un paquete de red no trae tipos: trae bytes en un orden acordado. struct los traduce:

import struct
binario = struct.pack(">ih", 42, 1000) # big-endian: int + short
struct.unpack(">ih", binario) # (42, 1000)

El > es el orden de bytes (big-endian), i un entero de 4 bytes y h un short de 2. Sin declarar el orden, el resultado depende de la máquina, y ahí empiezan los bugs que sólo aparecen en el servidor.

bytes es una secuencia inmutable de enteros entre 0 y 255; bytearray es la misma cosa, mutable. La diferencia decide si puedes construir un búfer incremental:

b = bytearray()
b.extend(b"\x01\x02")
b[0] = 255 # funciona
datos = bytes(b) # congelar para enviar

bytes es lo que devuelve open(..., "rb").read(), lo que acepta un socket y lo que produce str.encode(). bytearray es lo que usas cuando vas a rellenar un búfer poco a poco: concatenar bytes en un bucle es O(n²), extender un bytearray es amortizado O(1), por la misma razón que append en una lista.

La regla: bytes para el dato terminado, bytearray para el que se está construyendo.

  • Si puedes usar numpy. Cubre array y memoryview con operaciones vectorizadas; sólo evítalo si no puedes añadir dependencias.
  • Si el dato es pequeño. Por debajo de diez mil elementos, la diferencia son kilobytes y el código pierde comodidad.
  • Si necesitas tipos mezclados. array es homogéneo por definición; una fila con nombre, categoría y precio no cabe.
  • Si el archivo es de texto. CSV, JSON y YAML se leen con str; struct es para binario.

Tienes que leer un archivo binario de sensores: cada registro son 4 bytes de un entero big-endian y 8 de un double little-endian. Escribe la lectura de los primeros diez registros y explica por qué no se puede usar array directamente.

Solución
import os
import struct
import tempfile
ENTERO = struct.Struct(">i") # entero de 4 B, big-endian
MEDIDA = struct.Struct("<d") # double de 8 B, little-endian
TAM = ENTERO.size + MEDIDA.size
# Generamos el archivo para que el ejemplo se pueda ejecutar tal cual.
ruta = os.path.join(tempfile.gettempdir(), "sensores.bin")
with open(ruta, "wb") as salida:
for i in range(12):
salida.write(ENTERO.pack(i) + MEDIDA.pack(i * 1.5))
with open(ruta, "rb") as f:
for _ in range(10):
trozo = f.read(TAM)
if len(trozo) < TAM:
break
valor = ENTERO.unpack(trozo[: ENTERO.size])[0]
medida = MEDIDA.unpack(trozo[ENTERO.size :])[0]

array no sirve porque exige un único tipo homogéneo para todos los elementos, y aquí cada registro mezcla un int y un double. struct.Struct precompila cada formato por separado, que es la única forma de mezclar endianidades en el mismo registro: el entero es >i y el double es <d. Un solo Struct no puede expresarlo, y ">i<d" es un formato inválido.

Si el archivo fuera de un millón de double seguidos, entonces sí: array("d") o numpy.frombuffer, que leen el bloque completo de una vez.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulos 2 y 4: array, memoryview y bytes.
  • CPython 3.13: Modules/arraymodule.c, Objects/memoryobject.c.
  • Mediciones: mediciones/02-01-04-secuencias.py.
  • 01 · Secuencias: dónde encajan las secuencias planas.
  • 02 · list por dentro: la estructura a la que estas tres reemplazan.
  • 08 · Texto (Parte I): bytes como secuencia de enteros 0–255.