Boolesche Arrays vergleichen: Zählen, wie oft BEIDE wahr sind

Question

Ich möchte wissen, wie man die Anzahl der wahren Elemente in mehreren NumPy Bool-Arrays zählt. Zum Beispiel, in welchen Versuchen A und B = 1 sind. Unten habe ich versucht.

A = array([1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 1, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 2, 1, 2, 1, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1, 2, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 1, 2, 1, 1, 2, 1, 1, 2, 1, 2, 1, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1]) 
B = np.array([ 1., 1., 1., 1., 1., 1., 0., 1., 0., 1., 1., 1., 1., 0., 1., 0., 0., 1., 1., 1., 0., 0., 1., 0., 1., 1., 1., 1., 1., 1., 0., 1., 1., 0., 1., 1., 1., 0., 0., 0., 1., 1., 0., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 1., 0., 1., 0., 1., 1., 1., 1., 0., 0., 1., 0., 0., 1., 1., 1., 0., 0., 1., 0., 1., 1., 0., 1., 1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 1., 0., 0., 1., 1., 1., 0., 0., 1., 1., 0., 1., 1., 1., 0., 1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 1., 0., 1., 1., 1., 1., 1., 0., 0., 1., 0., 1., 0., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0., 1., 1., 0., 1., 1., 1., 1., 0., 0., 1., 0., 1., 1., 1., 0.]) 

num_trials = len(A) 
slide_avg = np.zeros(num_trials) 

for i in range(num_trials): 
    if i < num_trials_slide: 
     slide_avg[i] = np.sum(A[0:i+1] == 1 and B[0:i+1] == 1)/float(np.sum(A[0:i+1] == 1)) 

bekomme ich folgende Fehlermeldung:

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all() 

Answer 1

Wenn Sie einfach nur elementweise die Arrays in ein neues Array (zB C) multiplizieren, um die Anzahl der Elemente gleich wird gleich sein zu der Anzahl der Elemente, bei denen sowohl A als auch B wahr sind.

len(np.where(A*B == 1)[0]) 

Answer 2

@AustinA hat eine sehr intelligente answer unter Ausnutzung der Tatsache, dass 1 * 1 = 1.

Die eine mögliche Fehlmenge ist für Fälle, in denen Sie nicht ganzzahlige Werte haben, d. H. 2,0 und 0,5, die unter dieser Logik zu 1,0 ausgewertet werden. Wenn das der Fall ist, wäre eine Alternative:

np.sum((A == 1) & (B == 1)) 
# 24 

Aber wenn Sie mit ganzen Zahlen arbeiten, @ Austin Antwort sollte etwa 2x schneller sein.