测试 numpy 数组是否只包含零

我们初始化一个带有零的数组，如下所示:

np.zeros((N,N+1))

但是我们如何检查给定 n * n 个数组矩阵中的所有元素是否为零。
如果所有值都为零，则该方法只需返回 True。

176137 次浏览
小开
最佳答案

看看 Count _ nonzero。

>>> np.count_nonzero(np.eye(4))
4
>>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]])
5
小开

如果你有一个数组 a，我会在这里使用 np.all:

>>> np.all(a==0)
小开

这里张贴的其他答案也可以，但最清晰和最有效的功能是使用 numpy.any():

>>> all_zeros = not np.any(a)

或者

>>> all_zeros = not a.any()
  • 这是优先于 numpy.all(a==0)，因为它使用较少的内存。(它不需要由 a==0术语创建的临时数组。)
  • 此外，它比 numpy.count_nonzero(a)快，因为它可以在找到第一个非零元素时立即返回。
    • 编辑: 正如@Rachel 在评论中指出的，np.any()不再使用“短路”逻辑，所以你不会看到小数组的速度优势。
小开

如果您正在测试所有的零，以避免在另一个 numpy 函数上出现警告，那么在 try 中包装该行，but 块将在您感兴趣的操作即。

try: # removes output noise for empty slice
mean = np.mean(array)
except:
mean = 0
小开

正如另一个答案所说，如果您知道 0是数组中唯一可能的假元素，则可以利用 true/false 求值。如果一个数组中没有任何真元素，则该数组中的所有元素都是假的。*

>>> a = np.zeros(10)
>>> not np.any(a)
True

然而，答案声称，any比其他选项更快，部分原因是短路。截至2018年，努比的 all和 any 不要短路。

如果你经常做这样的事情，很容易使用 numba制作你自己的短路版本:

import numba as nb


# short-circuiting replacement for np.any()
@nb.jit(nopython=True)
def sc_any(array):
for x in array.flat:
if x:
return True
return False


# short-circuiting replacement for np.all()
@nb.jit(nopython=True)
def sc_all(array):
for x in array.flat:
if not x:
return False
return True

即使没有短路，它们也比 Numpy 的版本快。 count_nonzero是最慢的。

检查性能的一些输入:

import numpy as np


n = 10**8
middle = n//2
all_0 = np.zeros(n, dtype=int)
all_1 = np.ones(n, dtype=int)
mid_0 = np.ones(n, dtype=int)
mid_1 = np.zeros(n, dtype=int)
np.put(mid_0, middle, 0)
np.put(mid_1, middle, 1)
# mid_0 = [1 1 1 ... 1 0 1 ... 1 1 1]
# mid_1 = [0 0 0 ... 0 1 0 ... 0 0 0]

检查:

## count_nonzero
%timeit np.count_nonzero(all_0)
# 220 ms ± 8.73 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit np.count_nonzero(all_1)
# 150 ms ± 4.56 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)


### all
# np.all
%timeit np.all(all_1)
%timeit np.all(mid_0)
%timeit np.all(all_0)
# 56.8 ms ± 3.41 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 57.4 ms ± 1.76 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 55.9 ms ± 2.13 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)


# sc_all
%timeit sc_all(all_1)
%timeit sc_all(mid_0)
%timeit sc_all(all_0)
# 44.4 ms ± 2.49 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 22.7 ms ± 599 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 288 ns ± 6.36 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)


### any
# np.any
%timeit np.any(all_0)
%timeit np.any(mid_1)
%timeit np.any(all_1)
# 60.7 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 60 ms ± 287 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 57.7 ms ± 1.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)


# sc_any
%timeit sc_any(all_0)
%timeit sc_any(mid_1)
%timeit sc_any(all_1)
# 41.7 ms ± 1.24 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 22.4 ms ± 1.51 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
# 287 ns ± 12.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

* 有用的 all和 any等价物:

np.all(a) == np.logical_not(np.any(np.logical_not(a)))
np.any(a) == np.logical_not(np.all(np.logical_not(a)))
not np.all(a) == np.any(np.logical_not(a))
not np.any(a) == np.all(np.logical_not(a))
小开

会成功的。

def check(arr):
if np.all(arr == 0):
return True
return False
小开

如果你的数组中的所有元素都大于或等于0，我认为使用 sum 是最快的方法。

test = np.ones((128, 128, 128))
%%timeit
not np.any(test)
>>> 1.46 ms ± 9.09 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%%timeit
np.sum(test) == 0
>>> 646 µs ± 3.19 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

提交答案