Question

我有2个具有相同形状的numpy数组。现在我想比较数组1和数组2的值。最后，输出条件值== 1的匹配总和。

阵列1：

[1, 0, 1]
[1, 1, 0]
[0, 0, 1]

阵列2：

[0, 1, 1]
[1, 0, 0]
[0, 1, 1]

结果应该如下所示：

sum = 3

-------------------------

我的以下算法正在运行，但效率不高且非常优雅：

k = 0
for i in range(0,array1.shape[0],1):
    for j in range(0, array1.shape[1], 1):

        if array1[i][j] == array2[i][j] and array1[i][j] == 1:
            k = k + 1
        else:
            continue

print k

Answer 1

如果它真的只是二进制数据，你可以做

np.logical_and(a, b).sum()
3

这应该比执行(a==b) & (a==1)

快得多

Answer 2

这是结合两个条件的一种方法。

import numpy as np

a = np.array([[1, 0, 1],
              [1, 1, 0],
              [0, 0, 1]])

b = np.array([[0, 1, 1],
              [1, 0, 0],
              [0, 1, 1]])

res = np.sum((a==b) & (a==1))  # 3

<强>解释

a==b返回一个布尔数组，用于按元素测试2个数组之间的相等性。
a==1返回一个布尔数组，用于按元素测试a内元素的相等性。
&运算符用于表示必须满足这两个条件。
np.sum适用于布尔数组，因为bool是int的子类，即True可视为1，False为0。 / LI>

Answer 3

我对上述解决方案做了一些时间......

第一名：np.logical_and（）

第二名：np.sum（np.multiply（））

第3位：np.sum（arr1 == arr2＆amp; arr1 == 1）

第四名：基本循环和比较。

这将输出：

# Test 1 gives : 15.1819742985
# Test 2 gives : 14.9471218792
# Test 3 gives : 6.76537855828
# Test 4 gives : 9.16029915098

import numpy as np
import timeit

arr1 = np.array([[1, 0, 1], [1, 1, 0], [0, 0, 1]])
arr2 = np.array([[0, 1, 1], [1, 0, 0], [0, 1, 1]])
numberIterations = 1000000

def test_1(arr1, arr2):
    return np.sum((arr1 == arr2) & (arr1 == 1))

def test_2(arr1, arr2):
    summed = 0
    for a1, a2 in zip(arr1, arr2):
        for c1, c2 in zip(a1, a2):
            if c1 == c2 and c1 == 1:
                summed += 1
    return summed

def test_3(arr1, arr2):
    return np.logical_and(arr1, arr2).sum()

def test_4(arr1, arr2):
    return np.sum(np.multiply(arr1, arr2))  

# Testing time.
# Test 1
time1 = timeit.timeit(stmt='test_1(arr1, arr2)',
                    setup='from __main__ import test_1, arr1, arr2',
                    number=numberIterations)

# Test 2
time2 = timeit.timeit(stmt='test_2(arr1, arr2)',
                    setup='from __main__ import test_2, arr1, arr2',
                    number=numberIterations)

# Test 3
time3 = timeit.timeit(stmt='test_3(arr1, arr2)',
                    setup='from __main__ import test_3, arr1, arr2',
                    number=numberIterations)

# Test 4
time4 = timeit.timeit(stmt='test_4(arr1, arr2)',
                    setup='from __main__ import test_4, arr1, arr2',
                    number=numberIterations)

# Printing results.
print 'Test 1 gives : {}'.format(time1)
print 'Test 2 gives : {}'.format(time2)
print 'Test 3 gives : {}'.format(time3)
print 'Test 4 gives : {}'.format(time4)

Answer 4

>>> import numpy as np
>>> a=np.array([[1,0,1],[1,1,0],[0,0,1]])
>>> b=np.array([[0,1,1],[1,0,0],[0,1,1]])
>>> a==b
array([[False, False,  True],
       [ True, False,  True],
       [ True, False,  True]], dtype=bool)
>>> c=np.array(a==b, dtype=int)
>>> c
array([[0, 0, 1],
       [1, 0, 1],
       [1, 0, 1]])
>>> np.sum(c)
5
>>> d=np.array(a*b, dtype=int)
>>> d
array([[0, 0, 1],
       [1, 0, 0],
       [0, 0, 1]])
>>> np.sum(d)
3

Answer 5

如果矩阵中只有0和1

import numpy as np 

ar_1=np.array([[1, 0, 1],
[1, 1, 0],
[0, 0, 1]])

ar_2 = np.array([[0, 1, 1],
[1, 0, 0],
[0, 1, 1]])

np.sum(np.multiply(ar_1,ar_2))

np.multiply将是元素乘法。只有当两个参数都是一个时，才会给你1。

没有轴的

np.sum将汇总矩阵的所有元素

Answer 6

以下是四种更快的方法：

1）np.dot：

np.dot(a.ravel(), b.ravel())
# 3

2）np.bincount：

np.bincount(a.ravel(), b.ravel())[1]
# 3.0

3）np.count_nonzero：

np.count_nonzero(a * b)
# 3

4）np.repeat：

np.count_nonzero(a.ravel().repeat(b.ravel()))
# 3

借用@ IMCoins＆＃39;我得到的测试脚本

Test 1 gives : 6.34505105019
Test 2 gives : 7.32884097099
Test 3 gives : 3.29451298714
Test 4 gives : 3.76608014107
Test 5 gives : 1.28572297096    <- np.dot
Test 6 gives : 1.3145699501     <- np.bincount
Test 7 gives : 0.984617948532   <- np.count_nonzero
Test 8 gives : 1.06798291206    <- np.repeat

如果我使用更大的数组（np.tile(arr[1/2], (100, 100))）并且迭代次数减少，则变为：

Test 1 gives : 0.253939151764
Test 2 gives : 34.9494478703
Test 3 gives : 0.190597057343
Test 4 gives : 0.139708995819
Test 5 gives : 0.0751769542694
Test 6 gives : 0.382376909256
Test 7 gives : 0.239590883255
Test 8 gives : 0.335343122482

比较两个数组并显示匹配的总和

-------------------------

6 个答案: