El módulo array ofrece una secuencia mutable de valores numéricos almacenados de forma compacta. A diferencia de una lista, que guarda referencias a objetos Python, un array.array mantiene elementos de un único tipo compatible con C en memoria contigua. Esto reduce overhead y facilita el intercambio con archivos binarios, sockets y APIs que soportan el buffer protocol.
El módulo no sustituye NumPy cuando necesitas cálculo vectorizado, álgebra lineal o arrays multidimensionales. Es útil cuando basta una estructura de la biblioteca estándar con tipo homogéneo, memoria predecible y métodos parecidos a los de una lista.
Crea un array
El primer argumento es el typecode, que selecciona el tipo de elemento.
from array import array
valores = array("i", [10, 20, 30])
print(valores)
print(valores.itemsize)
El tamaño y rango de algunos typecodes dependen de la plataforma. Consulta itemsize cuando el layout binario sea importante.
Typecodes comunes
Los códigos frecuentes incluyen b/B para bytes con y sin signo, h/H para short, i/I para enteros, l/L para long, q/Q para 64 bits, f para float y d para double.
Elige el tipo más pequeño que represente el dominio con seguridad. Los valores fuera del rango no pueden insertarse.
Operaciones parecidas a listas
Los arrays soportan índices, slices, append(), extend(), insert(), pop(), remove(), reverse() y conteos.
valores.append(40)
valores.extend([50, 60])
print(valores[1:4])
Todos los valores deben ser compatibles con el typecode.
Convierte a lista
tolist() crea objetos Python comunes.
lista = valores.tolist()
La conversión copia los datos y pierde la representación compacta. Hazla únicamente en una frontera que exija listas.
Crea desde bytes
frombytes() añade valores interpretando un bloque binario.
datos = (1).to_bytes(4, "little") + (2).to_bytes(4, "little")
valores = array("I")
valores.frombytes(datos)
La interpretación usa el layout nativo del tipo y la plataforma. Para protocolos portables, usa struct o normaliza el byte order.
Convierte a bytes
tobytes() devuelve la representación binaria nativa.
payload = valores.tobytes()
El resultado no incluye typecode, cantidad, endianness ni versión. El lector necesita conocer el contrato.
Orden de bytes
byteswap() invierte el orden de bytes de cada elemento cuando el tamaño lo permite.
valores.byteswap()
Úsalo solo cuando conozcas el orden de origen y destino. Aplicarlo dos veces restaura la representación original.
Lee desde un archivo
fromfile() lee una cantidad de elementos de un archivo binario.
valores = array("d")
with open("medidas.bin", "rb") as archivo:
valores.fromfile(archivo, 100)
Si el archivo termina antes, puede añadir datos parciales y luego lanzar EOFError. Gestiona ese estado.
Escribe en un archivo
tofile() escribe la representación nativa.
with open("medidas.bin", "wb") as archivo:
valores.tofile(archivo)
Para un formato durable, añade un header con magic bytes, versión, typecode, byte order y cantidad.
Cuándo usar struct
struct es mejor para registros con campos de tipos distintos.
Usa struct en Python para layouts heterogéneos y array para secuencias homogéneas.
Buffer protocol
Un array puede exponerse mediante memoryview sin copia.
valores = array("I", range(100))
vista = memoryview(valores)
try:
consumir(vista)
finally:
vista.release()
No redimensiones el array mientras existan views exportadas.
readinto y I/O directo
Las APIs que aceptan buffers mutables pueden llenar un array directamente.
valores = array("B", [0]) * 4096
with open("datos.bin", "rb") as archivo:
cantidad = archivo.readinto(valores)
El retorno indica cuántos bytes se leyeron. Maneja lecturas parciales.
Slices
Un slice crea otro array con el mismo typecode.
parte = valores[10:20]
Esto copia elementos. Usa memoryview para una vista sin copia.
Repetición
Como las listas, los arrays pueden repetirse.
ceros = array("f", [0.0]) * 1000
Multiplicadores enormes pueden agotar memoria. Valida tamaños externos.
Uso de memoria
El ahorro aparece porque cada elemento usa su representación C, sin un objeto Python separado.
Mide cargas reales. En arrays pequeños la complejidad adicional puede no compensar.
Rendimiento
Los loops Python siguen procesando elemento por elemento. El almacenamiento compacto no aporta vectorización automática.
NumPy suele ser mejor para transformaciones numéricas intensivas. array puede ser ideal para almacenamiento e I/O.
Valores Unicode
Los typecodes históricos relacionados con Unicode tienen limitaciones de portabilidad. Para texto, prefiere str, bytes con encoding explícito o codecs estándar.
No diseñes un formato de texto portable alrededor de un array nativo de caracteres sin un contrato preciso.
Overflow
Insertar un entero fuera del rango del typecode lanza OverflowError.
try:
valores.append(numero)
except OverflowError as error:
raise ValueError("valor fuera del rango") from error
Valida unidades y límites antes de insertar.
Concurrencia
El array es mutable y no sincroniza accesos. Las threads que escriben o redimensionan el mismo objeto necesitan lock.
Para compartir entre procesos, usa memoria compartida o archivo mapeado con un protocolo explícito.
Integración con mmap
Un memoryview de un mmap puede ser consumido por código compatible con buffers. Copia a un array cuando necesites ownership independiente.
Consulta mmap en Python.
Serialización
No trates tobytes() como formato autodescriptivo. Incluye metadatos o utiliza un estándar documentado.
Para intercambio entre máquinas, define tamaño, signo y byte order.
Seguridad
Aplica límites antes de asignar un array a partir de una cantidad externa. Comprueba que el payload sea múltiplo de itemsize.
if len(payload) % valores.itemsize != 0:
raise ValueError("payload truncado")
if len(payload) > LIMITE_BYTES:
raise ValueError("payload demasiado grande")
Pruebas
Prueba mínimos y máximos, byte order, archivos truncados, lecturas parciales, arrays vacíos, slices, memoryviews activas y diferencias de plataforma.
Verifica interoperabilidad con vectores binarios conocidos.
Errores comunes
Los fallos frecuentes son asumir el mismo tamaño de typecode en todas las plataformas, escribir bytes sin header, confundir almacenamiento compacto con cálculo vectorizado, redimensionar con una view activa, ignorar lecturas parciales y elegir un tipo demasiado pequeño.
Conclusión
array ofrece secuencias numéricas homogéneas y compactas con la biblioteca estándar. Combina una interfaz familiar con archivos binarios y buffer protocol.
Elige typecodes con cuidado, documenta byte order y usa NumPy cuando necesites operaciones avanzadas. Consulta la documentación oficial de array, struct en Python y mmap en Python.
