memoryview.count cuenta cuántas veces aparece un valor dentro de una vista de memoria sin convertir todo el buffer a bytes o a una lista. Es útil en procesamiento binario, protocolos, archivos mapeados, imágenes, audio, redes y cualquier flujo donde copiar grandes bloques de datos aumente el uso de memoria y el tiempo de ejecución.
En esta guía aprenderás cómo funciona el método, qué valores acepta, cómo el formato del buffer cambia el resultado, cuándo conviene usarlo en lugar de una conversión, cómo se comporta con cortes y buffers tipados y qué precauciones debes tomar con datos externos.
Qué representa memoryview
Un memoryview expone el protocolo de buffer de Python. En lugar de crear una segunda secuencia con los mismos datos, ofrece una ventana sobre un objeto existente, como bytes, bytearray, array.array, memoria compartida o un archivo mapeado. Una vista escribible puede modificar el objeto original, mientras que una vista de solo lectura permite inspección eficiente.
datos = bytearray(b"ABRACADABRA")
vista = memoryview(datos)
print(vista[0])
print(len(vista))
Con el formato de byte sin signo, cada posición representa un entero entre 0 y 255. Contar la letra A significa contar el valor numérico devuelto por ord("A").
Conteo básico
datos = memoryview(b"ABRACADABRA")
cantidad = datos.count(ord("A"))
print(cantidad)
El método recorre la vista y devuelve la cantidad de elementos iguales al valor indicado. No devuelve posiciones y no modifica el buffer. Para buscar la primera coincidencia, usa una operación específica; para reunir todas las posiciones, realiza una iteración controlada.
Por qué evitar conversiones
Una alternativa habitual es llamar a bytes(vista).count(...). Funciona, pero puede crear una copia completa. En buffers pequeños esto suele ser irrelevante. En archivos grandes, paquetes de red, datos científicos o procesos repetidos, la asignación adicional puede aumentar de forma considerable el uso máximo de memoria.
def contar_ceros(buffer):
vista = memoryview(buffer)
return vista.count(0)
La función acepta cualquier objeto compatible con el protocolo de buffer y cuenta bytes nulos sin imponer una representación intermedia.
Contar delimitadores
Supón que un protocolo separa registros mediante saltos de línea. Antes de dividir el contenido, puedes estimar cuántos registros contiene.
paquete = memoryview(b"uno\ndos\ntres\n")
lineas = paquete.count(ord("\n"))
print(lineas)
El resultado es solo una métrica. No valida el protocolo completo, la codificación, el tamaño máximo de línea ni la integridad del mensaje.
Cortes sin copiar
Los cortes de una vista suelen seguir apuntando a la misma memoria. Esto permite contar valores en una región concreta.
datos = bytearray(range(100))
vista = memoryview(datos)
region = vista[20:60]
print(region.count(42))
Este patrón es útil para cabeceras, payloads, canales de imagen y bloques dentro de una estructura mayor. Valida siempre offsets y longitudes antes de crear el corte.
El formato cambia la unidad
Una vista de memoria no siempre representa bytes individuales. Su formato puede describir enteros, flotantes u otros tipos proporcionados por el objeto exportador. El valor pasado a count debe ser compatible con los elementos de la vista.
from array import array
muestras = array("i", [10, 20, 10, 30, 10])
vista = memoryview(muestras)
print(vista.format)
print(vista.count(10))
Aquí la unidad de comparación es un entero del array, no cada byte usado para almacenarlo. Esta diferencia es fundamental en buffers numéricos.
Reinterpretar con cast
El método cast puede exponer la misma memoria con otro formato compatible cuando las reglas de tamaño y disposición lo permiten.
datos = bytearray([1, 0, 1, 0, 2, 0])
vista = memoryview(datos)
enteros = vista.cast("H")
print(enteros.count(1))
La representación nativa puede depender de la plataforma. Para datos guardados o transmitidos, trata explícitamente el orden de bytes y la estructura.
Vistas de solo lectura y escribibles
count es una operación de lectura y funciona con ambos tipos de vista. La diferencia práctica aparece cuando otra parte del programa cambia el almacenamiento durante el procesamiento.
La memoria compartida o modificada de forma concurrente puede producir resultados que reflejan cambios intermedios. Cuando necesitas una fotografía inmutable, una copia deliberada puede ser la decisión correcta. El acceso sin copia es una optimización, no una garantía de consistencia.
Buffers multidimensionales
Algunos exportadores proporcionan forma, dimensiones, strides y disposiciones complejas. Revisa ndim, shape, strides y contiguous antes de asumir que la vista es una secuencia lineal simple.
def describir(vista):
print("formato:", vista.format)
print("dimensiones:", vista.ndim)
print("shape:", vista.shape)
print("contigua:", vista.contiguous)
En datos científicos, confirma que el conteo recorre los elementos en la representación esperada. Convertir a bytes cambia la unidad contada.
Ejemplo con archivo mapeado
El mapeo de memoria permite acceder a archivos grandes mediante memoria virtual. Una vista puede contar marcadores sin leer manualmente todo el archivo en un segundo objeto.
import mmap
with open("datos.bin", "rb") as archivo:
with mmap.mmap(archivo.fileno(), 0, access=mmap.ACCESS_READ) as mapa:
vista = memoryview(mapa)
try:
print(vista.count(0))
finally:
vista.release()
Libera la vista antes de cerrar el mapa. De lo contrario, Python puede impedir el cierre porque aún existe un buffer exportado.
Ciclo de vida y liberación
Una vista conserva una referencia al objeto subyacente. Con recursos como archivos mapeados y memoria compartida, usa release o un gestor de contexto para finalizar el acceso de forma predecible.
with memoryview(bytearray(b"abcabc")) as vista:
print(vista.count(ord("a")))
Después de liberarla, no reutilices la vista.
Validación de datos externos
Cuando el buffer proviene de un usuario, archivo o red, impone un tamaño máximo, valida offsets y comprueba el formato esperado. Un conteo no sustituye al parser, la autenticación, los checksums ni la validación estructural.
def contar_delimitador(buffer, valor, limite=10_000_000):
vista = memoryview(buffer)
if vista.nbytes > limite:
raise ValueError("buffer por encima del límite")
if not 0 <= valor <= 255:
raise ValueError("valor de byte inválido")
return vista.cast("B").count(valor)
Rendimiento y medición
No asumas que el código sin copias siempre será más rápido. Mide con datos representativos, repite las operaciones y observa tanto el tiempo como la memoria máxima. Para una sola operación sobre pocos bytes, la diferencia será pequeña. Para buffers grandes procesados muchas veces, evitar conversiones puede ser importante.
Errores comunes
Un error frecuente es pasar una cadena como "A" a una vista de bytes. El elemento esperado es un entero. Otro error es confundir cantidad de bytes con cantidad de elementos en una vista tipada. También puede fallar el intento de redimensionar un bytearray mientras existe una vista activa.
Buenas prácticas
Inspecciona el formato antes de contar. Usa cast("B") solo cuando quieras interpretar la memoria como bytes. Libera las vistas conectadas a recursos externos. Valida tamaños y offsets. Documenta si el valor representa un byte, entero, muestra, píxel o token de protocolo. Prefiere una copia explícita cuando la consistencia sea más importante que el ahorro de memoria.
Contenido relacionado
Consulta también las guías de Academify sobre bytes en Python, bytearray, archivos binarios y mmap. Revisa además la documentación oficial de memoryview y la referencia del protocolo de buffer.
Conclusión
memoryview.count es una herramienta directa para contar elementos en almacenamiento respaldado por buffers sin crear representaciones intermedias innecesarias. Su principal beneficio aparece con grandes bloques binarios, cortes, archivos mapeados, arrays tipados y pipelines sin copia. Combínalo con inspección de formato, límites, liberación correcta y mediciones realistas para ganar eficiencia sin perder seguridad.
