python - para - Convertir binario(0 | 1) numpy a entero o cadena binaria?

convertir de octal a decimal en python

Question

¿Hay un atajo para convertir binary (0 | 1) numpy array a entero o binary-string? Fe

b = np.array([0,0,0,0,0,1,0,1])
=> b is 5
np.packbits(b)

funciona pero solo para valores de 8 bits ... si el numpy es 9 o más elementos, genera 2 o más valores de 8 bits. Otra opción sería devolver una cadena de 0 | 1 ...

Lo que hago actualmente es:

 ba = bitarray()
ba.pack(b.astype(np.bool).tostring())
#convert from bitarray 0|1 to integer
result = int( ba.to01(), 2 )

que es feo!

Answer 1

def binary_converter(arr):
total = 0
for index, val in enumerate(reversed(arr)):
total += (val * 2**index)
print total
In [14]: b = np.array([1,0,1,0,0,0,0,0,1,0,1])
In [15]: binary_converter(b)
1285
In [9]: b = np.array([0,0,0,0,0,1,0,1])
In [10]: binary_converter(b)
5

o

b = np.array([1,0,1,0,0,0,0,0,1,0,1])
sum(val * 2**index for index, val in enumerate(reversed(b)))

Answer 2

Una forma sería usar dot-product con 2-powered matriz de rango de 2-powered -

b.dot(2**np.arange(b.size)[::-1])

Ejecución de muestra -

In [95]: b = np.array([1,0,1,0,0,0,0,0,1,0,1])
In [96]: b.dot(2**np.arange(b.size)[::-1])
Out[96]: 1285

Alternativamente, podríamos usar un operador de desplazamiento a la izquierda bit a bit para crear la matriz de rango y así obtener la salida deseada, como tal -

b.dot(1 << np.arange(b.size)[::-1])

Si los tiempos son de interés

In [148]: b = np.random.randint(0,2,(50))
In [149]: %timeit b.dot(2**np.arange(b.size)[::-1])
100000 loops, best of 3: 13.1 µs per loop
In [150]: %timeit b.dot(1 << np.arange(b.size)[::-1])
100000 loops, best of 3: 7.92 µs per loop

Proceso inverso

Para recuperar la matriz binaria, use np.binary_repr junto con np.fromstring -

In [96]: b = np.array([1,0,1,0,0,0,0,0,1,0,1])
In [97]: num = b.dot(2**np.arange(b.size)[::-1]) # integer
In [98]: np.fromstring(np.binary_repr(num), dtype=''S1'').astype(int)
Out[98]: array([1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1])

Answer 3

El uso de numpy para la conversión lo limita a los resultados binarios con signo de 64 bits. Si realmente quiere usar numpy y el límite de 64 bits le funciona, una implementación más rápida usando numpy es:

import numpy as np
def bin2int(bits):
return np.right_shift(np.packbits(bits, -1), bits.size).squeeze()

Como normalmente, si usa numpy, le importa la velocidad, la implementación más rápida para los resultados de> 64 bits es:

import gmpy2
def bin2int(bits):
return gmpy2.pack(list(bits[::-1]), 1)

Si no desea obtener una dependencia en gmpy2, esto es un poco más lento pero no tiene dependencias y admite resultados de> 64 bits:

def bin2int(bits):
total = 0
for shift, j in enumerate(bits[::-1]):
if j:
total += 1 << shift
return total

El observador observará algunas similitudes en la última versión con otras Respuestas a esta pregunta, con la principal diferencia es el uso del operador << en lugar de **, en mi prueba esto condujo a una mejora significativa en la velocidad.