python两数组内容比较_关于python：比较两个numpy数组的相等性，逐个元素

比较两个numpy数组是否相等的最简单方法是什么(其中equality定义为：a=b iff，对于所有索引i:A[i] == B[i])？

简单地使用==给了我一个布尔数组：

1

2

3>>> numpy.array([1,1,1]) == numpy.array([1,1,1])

array([ True, True, True], dtype=bool)

我是否必须用and这个数组的元素来确定数组是否相等，或者是否有更简单的比较方法？

1(A==B).all()

测试数组(a==b)的所有值是否为真。

编辑(来自dbaupp的回答和yoavram的评论)

应注意：

在特定情况下，此解决方案可能有一种奇怪的行为：如果A或B为空，而另一个包含单个元素，则返回True。出于某种原因，比较A==B返回一个空数组，因此all运算符返回True。

另一个风险是，如果A和B的形状不相同且不可广播，那么这种方法会产生错误。

总之，我认为我提出的解决方案是标准的，但是如果你对A和B的形状有疑问，或者只是想安全：使用一种专门的功能：

1

2

3np.array_equal(A,B) # test if same shape, same elements values

np.array_equiv(A,B) # test if broadcastable shape, same elements values

np.allclose(A,B,...) # test if same shape, elements have close enough values

号

你几乎总是想要np.array_equal时间。如果A和B的长度不同，(A==B).all()将崩溃。从numpy 1.10开始，==在这种情况下会发出折旧警告。

你有一个很好的观点，但是如果我对形状有疑问的话，我通常更喜欢在值之前直接测试它。然后，错误明显出现在形状上，这些形状与具有不同值的形状具有完全不同的含义。但这可能取决于每个用例

另一个风险是如果数组包含NaN。在这种情况下，你会得到错误，因为南！=南

很好指出。然而，我认为这是合乎逻辑的，因为nan!=nan意味着array(nan)!=array(nan)。

我不理解这种行为：import numpy as npH = 1/np.sqrt(2)*np.array([[1, 1], [1, -1]]) #hadamard matrixnp.array_equal(H.dot(H.T.conj()), np.eye(len(H))) # checking if H is an unitary matrix or noth是一个单位矩阵，所以h x H.T.conj是一个单位矩阵。但np.array_equal返回错误

(A==B).all()解决方案非常简洁，但有一些内置功能可用于此任务。即array_equal、allclose和array_equiv。

(不过，一些对timeit的快速测试似乎表明，(A==B).all()方法是最快的，这有点奇怪，因为它必须分配一个全新的数组。)

你说得对，只是如果比较的数组中有一个是空的，那么用(A==B).all()会得到错误的答案。例如，试一试：(np.array([1])==np.array([])).all()给True，np.array_equal(np.array([1]), np.array([]))给False。

我也发现了这种性能差异。这很奇怪，因为如果你有两个完全不同的数组，那么(A==B).all()仍然比np.array_equal(a, b)快(它可以检查单个元素并退出)。

np.array_equal也与lists of arrays和dicts of arrays一起工作。这可能是性能降低的原因。

非常感谢函数allclose，这是我需要的数值计算。它比较了公差内向量的相等性。：)

让我们用下面的代码来度量性能。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33import numpy as np

import time

exec_time0 = []

exec_time1 = []

exec_time2 = []

sizeOfArray = 5000

numOfIterations = 200

for i in xrange(numOfIterations):

A = np.random.randint(0,255,(sizeOfArray,sizeOfArray))

B = np.random.randint(0,255,(sizeOfArray,sizeOfArray))

a = time.clock()

res = (A==B).all()

b = time.clock()

exec_time0.append( b - a )

a = time.clock()

res = np.array_equal(A,B)

b = time.clock()

exec_time1.append( b - a )

a = time.clock()

res = np.array_equiv(A,B)

b = time.clock()

exec_time2.append( b - a )

print 'Method: (A==B).all(), ', np.mean(exec_time0)

print 'Method: np.array_equal(A,B),', np.mean(exec_time1)

print 'Method: np.array_equiv(A,B),', np.mean(exec_time2)

产量

1

2

3Method: (A==B).all(), 0.03031857

Method: np.array_equal(A,B), 0.030025185

Method: np.array_equiv(A,B), 0.030141515

。

根据上面的结果，numpy方法似乎比==运算符和all()方法的组合更快，通过比较numpy方法，最快的方法似乎是numpy.array_equal方法。

您应该使用一个更大的数组大小，它至少需要一秒钟的编译时间来提高实验的准确性。

如果要检查两个数组是否具有相同的shape和elements，则应使用np.array_equal，因为这是文档中建议的方法。

Performance-wise don't expect that any equality check will beat another, as there is not much room to optimize comparing two elements. Just for the sake, i still did some tests.

号

1

2

3

4

5

6

7

8

9

10

11

12

13import numpy as np

import timeit

A = np.zeros((300, 300, 3))

B = np.zeros((300, 300, 3))

C = np.ones((300, 300, 3))

timeit.timeit(stmt='(A==B).all()', setup='from __main__ import A, B', number=10**5)

timeit.timeit(stmt='np.array_equal(A, B)', setup='from __main__ import A, B, np', number=10**5)

timeit.timeit(stmt='np.array_equiv(A, B)', setup='from __main__ import A, B, np', number=10**5)

> 51.5094

> 52.555

> 52.761

差不多，没必要谈论速度。

(A==B).all()的行为与以下代码片段非常相似：

1

2

3

4x = [1,2,3]

y = [1,2,3]

print all([x[i]==y[i] for i in range(len(x))])

> True

。