Для подсчета вхождений значения в массиве numpy. Это будет работать так:

import numpy as np
a=np.array([0,3,4,3,5,4,7])
print(np.sum(a==3))

>>>Out: 2

Логика заключается в том, что Булево выражение создает массив, в котором все вхождения запрошенных значений равны 1, а все остальные равны нулю. Таким образом, суммируя их, мы получим количество случаев вхождения. Это работает для массивов любой формы или типа. Не забудьте убедиться, что вы  установили пакет NumPy.


Есть два метода, которые используют для подсчета вхождения всех уникальных значений в numpy:  уникальный и бинарный подсчет. Уникальный автоматически выравнивает многомерные массивы, тогда как бинарный подсчет работает только с одномерными массивами, содержащими только положительные целые числа.

unique, counts = np.unique(a, return_counts=True)
print(unique , counts) # counts[i] iравняется вхождениям unique[i] в a
>>>Out:[0 3 4 5 7] [1 2 2 1 1]

>>> bin_count=np.bincount(a)
>>> print(bin_count) # bin_count[i] равняется вхождениям i в a
>>>Out:[1 0 0 2 2 1 0 1] 


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

Подсчет всех вхождений всех элементов в итерируемом: collection.Counter

from collections import Counter

c = Counter(["a", "b", "c", "d", "a", "b", "a", "c", "d"])
c
>>>Out: Counter({'a': 3, 'b': 2, 'c': 2, 'd': 2})
c["a"]
>>>Out: 3

c[7]  # не в списке (7 входило 0 раз!)
>>>Out: 0

 

collections.Counter может быть использован для любого итератора и подсчитывает каждое вхождение для каждого элемента.
Примечание: Одно исключение , если dict или другой collections.Mapping -как класса дается, то он не будет считать их, а это создает счетчик с этими значениями:

Примечание: Одно исключение , если dict или другой collections.Mapping -как класса дается, то он не будет считать их, а это создает счетчик с этими значениями:

Counter({"e": 2})
>>>Out: Counter({"e": 2})

Counter({"e": "e"})        # предупреждение: Counter не проверяет значения типа int
>>>Out: Counter({"e": "e"}) 

Подсчет вхождений подстроки в строку: str.count

astring = 'thisisashorttext'
astring.count('t')

>>>Out: 4

Это работает даже для подстрок длиннее одного символа:

astring.count('th')
>>>Out: 1

astring.count('is')
>>>Out: 2

astring.count('text')
>>>Out: 1

которое не было бы возможно с collections.Counter, который только подсчитывает одиночные символы:

from collections import Counter
Counter(astring)

>>>Out: Counter({'a': 1, 'e': 1, 'h': 2, 'i': 2, 'o': 1, 'r': 1, 's': 3, 't': 4, 'x': 1})

Подсчет вхождений одного элемента в последовательности: list.count() и tuple.count()

alist = [1, 2, 3, 4, 1, 2, 1, 3, 4]
alist.count(1)

>>>Out: 3

atuple = ('bear', 'weasel', 'bear', 'frog')
atuple.count('bear')
>>>Out: 2

atuple.count('fox')
>>>Out: 0 

Получение наиболее распространенного значения (-s): collection.Counter.most_common ()

Подсчет ключи от Mapping не представляется возможным с collections.Counter , но мы можем посчитать значения:

from collections import Counter
adict = {'a': 5, 'b': 3, 'c': 5, 'd': 2, 'e':2, 'q': 5}
Counter(adict.values())

>>>Out: Counter({2: 2, 3: 1, 5: 3})

Наиболее распространенные элементы доступны с помощью most_common -метода:

#сортируем их от наиболее распространенного до наименее распространенному значению:
Counter(adict.values()).most_common()

>>>Out: [(5, 3), (2, 2), (3, 1)]

#получаем наиболее распространенные значения
Counter(adict.values()).most_common(1)

>>>Out: [(5, 3)]

# получаем 2 самых распространенных значения
Counter(adict.values()).most_common(2)

>>>Out: [(5, 3), (2, 2)]