Question

在Python中，我有一个ndarray y 打印为array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

我试图计算此数组中有多少0个和多少1个。

但是当我输入y.count(0)或y.count(1)时，它会显示

numpy.ndarray对象没有属性count

我该怎么办？

Answer 1

>>> a = numpy.array([0, 3, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 1, 3, 4])
>>> unique, counts = numpy.unique(a, return_counts=True)
>>> dict(zip(unique, counts))
{0: 7, 1: 4, 2: 1, 3: 2, 4: 1}

非笨拙的方式：

使用collections.Counter;

>> import collections, numpy

>>> a = numpy.array([0, 3, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 1, 3, 4])
>>> collections.Counter(a)
Counter({0: 7, 1: 4, 3: 2, 2: 1, 4: 1})

Answer 2

如何使用numpy.count_nonzero，如

>>> import numpy as np
>>> y = np.array([1, 2, 2, 2, 2, 0, 2, 3, 3, 3, 0, 0, 2, 2, 0])

>>> np.count_nonzero(y == 1)
1
>>> np.count_nonzero(y == 2)
7
>>> np.count_nonzero(y == 3)
3

Answer 3

就个人而言，我会选择： (y == 0).sum()和(y == 1).sum()

E.g。

import numpy as np
y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
num_zeros = (y == 0).sum()
num_ones = (y == 1).sum()

Answer 4

对于您的情况，您还可以查看numpy.bincount

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

In [57]: np.bincount(a)
Out[57]: array([8, 4])  #count of zeros is at index 0 : 8
                        #count of ones is at index 1 : 4

Answer 5

将您的数组y转换为列出l，然后执行l.count(1)和l.count(0)

>>> y = numpy.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>> l = list(y)
>>> l.count(1)
4
>>> l.count(0)
8

Answer 6

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

如果您知道它们只是0和1：

np.sum(y)

给出了一些数量。 np.sum(1-y)给出零。

略微一般，如果你想计算0而不是零（但可能是2或3）：

np.count_nonzero(y)

给出非零数。

但如果你需要更复杂的东西，我不认为numpy会提供一个不错的count选项。在这种情况下，请转到集合：

import collections
collections.Counter(y)
> Counter({0: 8, 1: 4})

这就像一个字典

collections.Counter(y)[0]
> 8

Answer 7

如果您确切知道自己要查找的号码，可以使用以下内容;

__getattr__

返回数组中出现2的次数。

Answer 8

len(y[y==0])和len(y[y==1])呢？

Answer 9

老实说，我发现转换为pandas Series或DataFrame最简单：

import pandas as pd
import numpy as np

df = pd.DataFrame({'data':np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])})
print df['data'].value_counts()

或者罗伯特·穆尔建议的这个漂亮的单线：

pd.Series([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]).value_counts()

Answer 10

要计算出现次数，您可以使用np.unique(array, return_counts=True)：

In [75]: boo = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

# use bool value `True` or equivalently `1`
In [77]: uniq, cnts = np.unique(boo, return_counts=1)
In [81]: uniq
Out[81]: array([0, 1])   #unique elements in input array are: 0, 1

In [82]: cnts
Out[82]: array([8, 4])   # 0 occurs 8 times, 1 occurs 4 times

Answer 11

另一个简单的解决方案可能是使用 numpy.count_nonzero（）：

import numpy as np
y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
y_nonzero_num = np.count_nonzero(y==1)
y_zero_num = np.count_nonzero(y==0)
y_nonzero_num
4
y_zero_num
8

不要让这个名字误导你，如果你像布法一样使用它，就像在例子中一样，它会起作用。

Answer 12

y.tolist().count(val)

val 0或1

由于python列表具有本机函数count，因此在使用该函数之前转换为list是一个简单的解决方案。

Answer 13

我使用np.where：

how_many_0 = len(np.where(a==0.)[0])
how_many_1 = len(np.where(a==1.)[0])

Answer 14

没有人建议将numpy.bincount(input, minlength)与minlength = np.size(input)一起使用，但这似乎是一个很好的解决方案，而且最快：

In [1]: choices = np.random.randint(0, 100, 10000)

In [2]: %timeit [ np.sum(choices == k) for k in range(min(choices), max(choices)+1) ]
100 loops, best of 3: 2.67 ms per loop

In [3]: %timeit np.unique(choices, return_counts=True)
1000 loops, best of 3: 388 µs per loop

In [4]: %timeit np.bincount(choices, minlength=np.size(choices))
100000 loops, best of 3: 16.3 µs per loop

这是numpy.unique(x, return_counts=True)和numpy.bincount(x, minlength=np.max(x))之间的疯狂加速！

Answer 15

如果您对最快的执行感兴趣，那么您会事先知道要查找的值，并且您的数组是1D，否则您对展平数组上的结果感兴趣（在这种情况下，输入该函数应该是np.flatten(arr)而不是arr），那么Numba是您的朋友：

import numba as nb


@nb.jit
def count_nb(arr, value):
    result = 0
    for x in arr:
        if x == value:
            result += 1
    return result

或者，对于大型数组，并行化可能是有益的：

@nb.jit(parallel=True)
def count_nbp(arr, value):
    result = 0
    for i in nb.prange(arr.size):
        if arr[i] == value:
            result += 1
    return result

使用np.count_nonzero()和基于np.unique()的解决方案对它们进行标记（这也存在创建可以避免的临时数组的问题）

import numpy as np


def count_np(arr, value):
    return np.count_nonzero(arr == value)

import numpy as np


def count_np2(arr, value):
    uniques, counts = np.unique(a, return_counts=True)
    counter = dict(zip(uniques, counts))
    return counter[value] if value in counter else 0

对于使用以下命令生成的输入：

def gen_input(n, a=0, b=100):
    return np.random.randint(a, b, n)

获得以下图（图的第二行是对更快方法的放大）：

表明基于Numba的解决方案比NumPy的解决方案要快得多，并且对于非常大的输入，并行方法比朴素的方法要快。

可用的完整代码here。

Answer 16

您可以使用字典理解功能来创建简洁的单线。有关字典理解can be found here

的更多信息

>>>counts = {int(value): list(y).count(value) for value in set(y)}
>>>print(counts)
{0: 8, 1: 4}

这将创建一个字典，将ndarray中的值作为键，并将值的计数分别作为键的值。

只要您要计算这种格式的数组中某个值的出现次数，此方法就起作用。

Answer 17

这可以通过以下方法轻松完成

y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
y.tolist().count(1)

Answer 18

利用“系列”提供的方法：

>>> import pandas as pd
>>> y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>> pd.Series(y).value_counts()
0    8
1    4
dtype: int64

Answer 19

由于你的ndarray只包含0和1，你可以使用sum（）来获得1的出现和len（） - sum（）得到0的出现。

num_of_ones = sum(array)
num_of_zeros = len(array)-sum(array)

Answer 20

一般而简单的答案是：

numpy.sum(MyArray==x)   # sum of a binary list of the occurence of x (=0 or 1) in MyArray

这将导致这个完整的代码作为例子

import numpy
MyArray=numpy.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])  # array we want to search in
x=0   # the value I want to count (can be iterator, in a list, etc.)
numpy.sum(MyArray==0)   # sum of a binary list of the occurence of x in MyArray

现在，如果MyArray处于多维，并且您想要计算行中值的分布的出现次数（=以后的模式）

MyArray=numpy.array([[6, 1],[4, 5],[0, 7],[5, 1],[2, 5],[1, 2],[3, 2],[0, 2],[2, 5],[5, 1],[3, 0]])
x=numpy.array([5,1])   # the value I want to count (can be iterator, in a list, etc.)
temp = numpy.ascontiguousarray(MyArray).view(numpy.dtype((numpy.void, MyArray.dtype.itemsize * MyArray.shape[1])))  # convert the 2d-array into an array of analyzable patterns
xt=numpy.ascontiguousarray(x).view(numpy.dtype((numpy.void, x.dtype.itemsize * x.shape[0])))  # convert what you search into one analyzable pattern
numpy.sum(temp==xt)  # count of the searched pattern in the list of patterns

Answer 21

对于通用条目：

x = np.array([11, 2, 3, 5, 3, 2, 16, 10, 10, 3, 11, 4, 5, 16, 3, 11, 4])
n = {i:len([j for j in np.where(x==i)[0]]) for i in set(x)}
ix = {i:[j for j in np.where(x==i)[0]] for i in set(x)}

将输出一个计数：

{2: 2, 3: 4, 4: 2, 5: 2, 10: 2, 11: 3, 16: 2}

和索引：

{2: [1, 5],
3: [2, 4, 9, 14],
4: [11, 16],
5: [3, 12],
10: [7, 8],
11: [0, 10, 15],
16: [6, 13]}

Answer 22

它涉及另一个步骤，但更灵活的解决方案也适用于2D阵列和更复杂的过滤器是创建一个布尔掩码，然后在掩码上使用.sum（）。

>>>>y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>>>mask = y == 0
>>>>mask.sum()
8

Answer 23

这里有一个只有1和0的特殊数组。因此，技巧是使用

np.mean(x)

给出数组中1s的百分比。或者，使用

np.sum(x)
np.sum(1-x)

将为您提供数组中1和0的绝对数字。

Answer 24

dict(zip(*numpy.unique(y, return_counts=True)))

只需在此处复制Seppo Enarvi的评论，就可以得到正确的答案

Answer 25

尝试一下：

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

Answer 26

这里有一些内容，您可以通过它计算出特定数字的出现次数：根据您的代码

count_of_zero = list（y [y == 0]）。count（0）

打印（计数为零）

//根据匹配将有布尔值，根据True值将返回数字0

Answer 27

如果您不想使用numpy或收藏模块，您可以使用字典：

d = dict()
a = [0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]
for item in a:
    try:
        d[item]+=1
    except KeyError:
        d[item]=1

结果：

>>>d
{0: 8, 1: 4}

当然你也可以使用if / else语句。我认为Counter功能几乎完全相同，但这更透明。

Answer 28

如果使用生成器处理非常大的数组，则可以选择。令人高兴的是，这种方法对数组和列表均适用，并且您不需要任何其他程序包。此外，您没有使用太多的内存。

my_array = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
sum(1 for val in my_array if val==0)
Out: 8

Answer 29

此功能返回数组中变量的出现次数：

def count(array,variable):
    number = 0
    for i in range(array.shape[0]):
        for j in range(array.shape[1]):
            if array[i,j] == variable:
                number += 1
    return number

Answer 30

Numpy有一个模块。只是一个小小的黑客。将输入数组作为bin。

numpy.histogram(y, bins=y)

输出是2个数组。一个具有值本身，另一个具有相应的频率。

Answer 31

using numpy.count

$ a = [0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]

$ np.count(a, 1)

如何计算Python中ndarray中某些项的出现次数？

31 个答案: