Как подсчитать появление определенного элемента в ndarray в Python?

В 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

Что я должен делать?

+283
источник поделиться
27 ответов
>>> 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}

Non-numpy way:

Использовать 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})
+460
источник

Как насчет использования 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
+203
источник
другие ответы

Связанные вопросы


Похожие вопросы

Лично я бы пошел: (y == 0).sum() и (y == 1).sum()

например.

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()
+109
источник

В вашем случае вы также можете посмотреть 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
+32
источник

Преобразуйте массив 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 
+19
источник
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})

Это ведет себя как dict

collections.Counter(y)[0]
> 8
+15
источник

Если вы точно знаете, какой номер вы ищете, вы можете использовать следующее:

lst = np.array([1,1,2,3,3,6,6,6,3,2,1])
(lst == 2).sum()

возвращает количество раз 2 в вашем массиве.

+13
источник

Как насчет len(y[y==0]) и len(y[y==1])?

+6
источник

y.tolist().count(val)

с val 0 или 1

Так как список python имеет собственную функцию count, преобразование в список перед использованием этой функции является простым решением.

+6
источник

Честно говоря, мне легче всего перейти в серию pandas или 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()
+6
источник

Еще одним простым решением может быть использование 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

Не позволяйте названию вводить вас в заблуждение, если вы используете его с логическим, как в примере, он сделает трюк.

+5
источник

Чтобы подсчитать количество вхождений, вы можете использовать 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
+5
источник

Никто не предлагал использовать 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)) !

+5
источник

Я бы использовал np.where:

how_many_0 = len(np.where(a==0.)[0])
how_many_1 = len(np.where(a==1.)[0])
+4
источник

Вы можете использовать понимание словаря для создания аккуратного однострочного слоя. Подробнее о понимании слова можно найти здесь

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

Это создаст словарь со значениями в вашем ndarray как ключи и значениями значений в качестве значений для ключей соответственно.

Это будет работать, когда вы хотите подсчитать количество значений в массивах этого формата.

+2
источник

Это можно сделать легко следующим способом

y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
y.tolist().count(1)
+1
источник

Общий и простой ответ:

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
+1
источник

Поскольку ваш ndarray содержит только 0 и 1, вы можете использовать sum(), чтобы получить появление 1s и len() - sum(), чтобы получить вхождение 0s.

num_of_ones = sum(array)
num_of_zeros = len(array)-sum(array)
+1
источник

У вас есть специальный массив только с 1 и 0 здесь. Так что хитрость заключается в использовании

np.mean(x)

который дает вам процент 1 с в вашем массиве. В качестве альтернативы используйте

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

даст вам абсолютное число 1 и 0 в вашем массиве.

+1
источник

использовать методы, предлагаемые серией:

>>> 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
+1
источник

Он включает в себя еще один шаг, но более гибкое решение, которое также будет работать для 2d-массивов и более сложных фильтров, - это создание булевой маски, а затем использование маски .sum() в маске.

>>>>y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>>>mask = y == 0
>>>>mask.sum()
8
0
источник

Если вы не хотите использовать 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 работает почти так же, но это более прозрачно.

0
источник

Для общих записей:

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]}
0
источник
dict(zip(*numpy.unique(y, return_counts=True)))

Только что скопировал комментарий Сеппо Энарви, который заслуживает правильного ответа

0
источник

У Numpy есть модуль для этого. Просто небольшой взлом. Поместите ваш массив ввода в виде корзин.

numpy.histogram(y, bins=y)

Выходные данные - 2 массива. Один с самими значениями, другие с соответствующими частотами.

-1
источник
using numpy.count

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

$ np.count(a, 1)
-1
источник

wtf kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

-3
источник

Посмотрите другие вопросы по меткам или Задайте вопрос