Python/Numpy: Convertire elenco di Caccio a unsigned int

Question

1. Qual è il (o la maggior parte "Pythonic") modo più veloce per convertire

   x = [False, False, True, True] 
   

   in 12? (Se c'è un modo.)

2. E se di bool fosse invece ? C'è un comando speciale per questo?

Ho un grande array m-by-n di booleani, in cui ogni riga n-elemento rappresenta un singolo hash dimensionale ridotto di un vettore di caratteristiche altamente dimensionale. (Nell'esempio sopra, n = 4.) Vorrei conoscere la risposta per comprimere i miei dati il ​​più possibile. Grazie.

---

Edit: Grazie per le risposte! Utilizzando il seguente codice di prova,

t = 0 
for iter in range(500): 
    B = scipy.signbit(scipy.randn(1000,20)) 
    for b in B: 
     t0 = time.clock() 
     # test code here 
     t1 = time.clock() 
     t += (t1-t0) 
print t 

... ecco erano i tempi di esecuzione sul mio computer portatile Thinkpad:

• My answer: 4.26 sec
• Sven Marnach 1: 7.88
• Emil H: 8.51
• Sven Marnach 2: 8,72
• delnan: 10,14
• liori: 53,49

Naturalmente, accolgo con favore eventuali test indipendenti che possono confermare o smentire i miei dati!

---

Edit: Nella mia risposta qui sotto, cambiando int(j) semplicemente j funziona ancora, ma corre sei volte più lento! Allora forse le altre risposte diventerebbero più veloci se la bool fosse lanciata usando int. Ma sono troppo pigro per testare di nuovo tutto.

---

Edit: Liori ha registrato risultati di test indipendenti here.

Answer 1

Prendendo varie idee da varie altre risposte, ecco un altro modo per farlo:

sum(1<<i for i, b in enumerate(x) if b) 

E 'abbastanza veloce nel mio test - a destra con il metodo numpy per un gran numero di bit anche se trabocca come un matto. Ho usato il modulo di test di Liori per il test. Il metodo di Steve, con il cambiamento che ho suggerito, è appena più veloce. Tuttavia, se un sacco di questi tipi di conversioni devono essere eseguiti alla volta (e con non troppi bit), scommetto che Numpy sarà più veloce.

Answer 2

Qualcosa di simile?

>>> x = [False, False, True, True] 
>>> sum([int(y[1])*2**y[0] for y in enumerate(x)]) 
12 

È possibile convertire un allineamento NumPy a un elenco regolare utilizzando un cast list().

>>> a = numpy.array([1,2,3,4]) 
>>> a 
array([1, 2, 3, 4]) 
>>> list(a) 
[1, 2, 3, 4] 

Answer 3

La maggior parte Pythonic potrebbe essere questo:

sum(2**i*b for i, b in enumerate(x)) 

E 'difficile dire se è anche il più veloce.

In NumPy vorrei utilizzare

numpy.sum(2**numpy.arange(len(x))*x) 

, ma questo non sarà più veloce per i piccoli array x, e non funzionerà per i grandi array x dal interi dimensioni della macchina sono utilizzati al posto di Pythons interi precisione arbitraria .

Answer 4

Un elegante, modo sempre lavorare pythonic è questo:

def powers(x): 
    """yield powers of x, starting from x**0 forever""" 
    power = 1 
    while True: 
     yield power 
     power *= x 

def bools_to_int(bools): 
    # in Python 2, use itertools.izip! 
    return sum(int(place) * place_weight for place_weight, place in 
       zip(powers(2), bools)) 

Si noti che è possibile sbarazzarsi di powers (da enumerare e quadratura nella comprensione, come altre risposte fanno) - ma forse è più chiaro in questo modo.

Answer 5

reduce(lambda a,b:2*a+b, reversed(x)) 

Si potrebbe eliminare il contrario() se il bit meno significativo alla fine dell'array. Funziona anche con numpy.array e non ha bisogno enumerate(). Dai miei test sembra anche essere più veloce: non c'è bisogno di usare l'esponenziazione.

Answer 6

Il mio primo tentativo, appena per riferimento:

def bool2int(x): 
    y = 0 
    for i,j in enumerate(x): 
     if j: y += int(j)<<i 
    return y 

Answer 7

Se si desidera aggiungere un'altra estensione al mix, ho aggiunto pack() e unpack() al ramo di sviluppo di gmpy. I miei test mostrano che potrebbe essere 2x o 3 volte più veloce.

>>> import gmpy2 
>>> gmpy2.pack([0,0,1,1],1) 
mpz(12) 
>>> gmpy2.unpack(12,1) 
[mpz(0), mpz(0), mpz(1), mpz(1)] 

Disclaimer: la versione di sviluppo si chiama gmpy2 e può coesistere con la versione stabile. È ancora in fase Alfa, ma si spera che diventi beta in poche settimane. È necessario disporre di librerie GMP e MPFR installate. La sorgente è disponibile presso http://code.google.com/p/gmpy/source/checkout

Answer 8

Se si dispone di una matrice, probabilmente avrete bisogno di fare in questo modo:

#precompute powers of two 
vals = 2.**np.arange(20) 

B = .... 
compressed = np.dot(B, vals) # matrix multiplication. 

np.dot dovrebbe essere più veloce di qualsiasi ciclo in Python. Più veloce.

Answer 9

Stavo cercando ipython %timeit e sembra che facendo quanto segue è più veloce:

y = 0 
for i,j in enumerate(x): 
    if j: y += 1<<i 

Inoltre, se il vettore booleano è un numpy.ndarray, convertendolo in pitone gamma x.tolist() e in esecuzione lo stesso sembra lavorare più velocemente in questo caso. È tutto marginale, ma costante e, a queste velocità, i margini si sommano bene.

Answer 10

numpy ha la funzione packbits per questo. Esso supporta anche le operazioni lungo gli assi:

In [3]: B = scipy.signbit(scipy.randn(1000,8)).astype("i1") 

In [3]: B[0] 
Out[3]: array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8) 

In [4]: np.packbits(B[0]) 
Out[4]: array([68], dtype=uint8) 

In [5]: %timeit np.packbits(B, axis=1) 
10000 loops, best of 3: 37 µs per loop 

funziona per dimensioni int8 per taglie più grandi si deve spostare eo

In [8]: x # multiple of 8 
Out[8]: array([1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1], dtype=int8) 

In [9]: r = np.packbits(x).astype(np.int32); r 
Out[9]: array([171, 129], dtype=uint8) 

In [10]: r[0] << 8 | r[1] 
Out[10]: 33237 

In [11]: sum(1<<i for i, b in enumerate(x[::-1]) if b) 
Out[11]: 33237 

se x c'è multiplo di 8 dovete pad in zeri