Подсчет количества вхождений каждого элемента в список с помощью Python’s Counter

Бизнес

В Python количество всех элементов в списке или кортеже можно получить с помощью встроенной функции len(), а количество каждого элемента (количество вхождений каждого элемента) можно получить с помощью метода count().

Кроме того, класс Counter из коллекций стандартной библиотеки Python может быть использован для получения элементов в порядке возрастания количества вхождений.

В этом разделе мы обсудим следующее

  • Подсчитайте общее количество элементов:len()
  • Подсчитайте количество каждого элемента (количество вхождений каждого элемента):count()
  • Использование.collections.Counter
  • Элементы извлекаются в порядке убывания частоты встречаемости:most_common()
  • Подсчитайте количество (тип) непересекающихся элементов (уникальных элементов).
  • Подсчитайте количество элементов, удовлетворяющих условию.

Кроме того, в качестве конкретного примера ниже приведен пример кода.

  • Подсчитывает количество вхождений слова в строку.
  • Подсчет количества вхождений символа в строку.

Образец представляет собой список, но та же обработка может быть выполнена и с кортежами.

Подсчитайте общее количество элементов: len()

Чтобы подсчитать общее количество элементов в списке или кортеже, используйте встроенную функцию len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(len(l))
# 7

Подсчет количества каждого элемента (количество вхождений каждого элемента): метод count()

Чтобы подсчитать количество каждого элемента (количество вхождений каждого элемента), используйте метод count() для списков, кортежей и т.д.

Если в качестве аргумента передается значение, не существующее как элемент, возвращается 0.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

print(l.count('a'))
# 4

print(l.count('b'))
# 1

print(l.count('c'))
# 2

print(l.count('d'))
# 0

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

Как использовать collections.Counter

В коллекциях стандартной библиотеки Python есть класс Counter.

Counter() является подклассом словаря типа dict, который имеет данные в виде элементов в качестве ключей и вхождений в качестве значений.

import collections

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']

c = collections.Counter(l)
print(c)
# Counter({'a': 4, 'c': 2, 'b': 1})

print(type(c))
# <class 'collections.Counter'>

print(issubclass(type(c), dict))
# True

Если в качестве ключа указан элемент, можно получить количество элементов. Если в качестве элемента указано значение, которое не существует, возвращается 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Вы также можете использовать методы типа словаря, такие как keys(), values(), items() и т.д.

print(c.keys())
# dict_keys(['a', 'b', 'c'])

print(c.values())
# dict_values([4, 1, 2])

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

Эти методы возвращают объекты типа dict_keys и т.д. Их можно использовать как есть, если вы хотите выполнить оператор for. Если вы хотите преобразовать их в список, используйте list().

Получение элементов в порядке частоты появления: метод most_common()

У счетчика есть метод most_common(), который возвращает список кортежей вида (элемент, количество вхождений), отсортированных по количеству вхождений.

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 1)]

Элемент с наибольшим числом вхождений можно получить, указав индекс, например [0] для наибольшего числа вхождений и [-1] для наименьшего числа вхождений. Если вы хотите получить только элементы или только количество вхождений, вы можете указать индекс дополнительно.

print(c.most_common()[0])
# ('a', 4)

print(c.most_common()[-1])
# ('b', 1)

print(c.most_common()[0][0])
# a

print(c.most_common()[0][1])
# 4

Если вы хотите отсортировать их в порядке уменьшения количества вхождений, используйте срез с инкрементом, установленным на -1.

print(c.most_common()[::-1])
# [('b', 1), ('c', 2), ('a', 4)]

Если для метода most_common() указан аргумент n, возвращаются только n элементов с наибольшим числом вхождений. Если он опущен, возвращаются все элементы.

print(c.most_common(2))
# [('a', 4), ('c', 2)]

Если вам нужен отдельный список элементов\occurrences, упорядоченный по количеству вхождений, а не кортеж (элемент, количество вхождений), вы можете разложить его следующим образом

values, counts = zip(*c.most_common())

print(values)
# ('a', 'c', 'b')

print(counts)
# (4, 2, 1)

Встроенная функция zip() используется для транспонирования двумерного списка (в данном случае списка кортежей), а затем его распаковки и извлечения.

Подсчитайте количество (тип) непересекающихся элементов (уникальных элементов).

Чтобы подсчитать, сколько непересекающихся элементов (уникальных элементов) содержится в списке или кортеже (сколько в нем типов), используйте Counter или set(), как описано выше.

Количество элементов в объекте Counter равно количеству непересекающихся элементов в исходном списке, которое можно получить с помощью функции len().

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(len(c))
# 3

Вы также можете использовать set(), конструктор для типа набора set, что проще, если вам не нужен объект Counter.

Тип set — это тип данных, который не имеет дублирующихся элементов. Передача списка в set() игнорирует дублирующиеся значения и возвращает объект типа set, элементами которого являются только уникальные значения. Количество элементов этого типа определяется функцией len().

print(set(l))
# {'a', 'c', 'b'}

print(len(set(l)))
# 3

Подсчитайте количество элементов, удовлетворяющих условию.

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

В качестве примера подсчитайте количество элементов с отрицательными значениями для следующего списка чисел

l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

Применение условного выражения к каждому элементу в нотации понимания списка дает список, элементы которого являются булевыми типами bool (true, false). Булевский тип bool является подклассом целочисленного типа int, где true рассматривается как 1, а false — как 0. Поэтому количество истинных значений (количество элементов, удовлетворяющих условию) может быть подсчитано путем вычисления суммы с помощью sum().

print([i < 0 for i in l])
# [True, True, True, True, True, False, False, False, False, False, False]

print(sum([i < 0 for i in l]))
# 5

Если мы заменим [] в обозначении понимания списка на (), то получим выражение генератора. Нотация понимания списка создает список всех обрабатываемых элементов, в то время как выражение-генератор обрабатывает элементы последовательно и поэтому более эффективно использует память.

Когда выражение генератора является единственным аргументом, () может быть опущено, поэтому его можно записать как в последнем случае.

print(sum((i < 0 for i in l)))
# 5

print(sum(i < 0 for i in l))
# 5

Если вы хотите подсчитать количество ложных значений (количество элементов, не удовлетворяющих условию), используйте not. Обратите внимание, что > имеет больший приоритет, чем not (он вычисляется первым), поэтому скобки () в (i < 0) в следующем примере не нужны.

print([not (i < 0) for i in l])
# [False, False, False, False, False, True, True, True, True, True, True]

print(sum(not (i < 0) for i in l))
# 6

Конечно, сами условия могут быть изменены.

print(sum(i >= 0 for i in l))
# 6

Некоторые другие примеры приведены ниже.

Пример получения количества нечетных элементов для списка чисел.

print([i % 2 == 1 for i in l])
# [True, False, True, False, True, False, True, False, True, False, True]

print(sum(i % 2 == 1 for i in l))
# 6

Пример условия для списка строк.

l = ['apple', 'orange', 'banana']

print([s.endswith('e') for s in l])
# [True, True, False]

print(sum(s.endswith('e') for s in l))
# 2

Счетчик используется для подсчета на основе количества вхождений. items() извлекает кортеж (элемент, количество вхождений), а количество вхождений определяет условие.

Ниже приведен пример извлечения элементов с двумя или более вхождениями и подсчета общего количества вхождений. В этом примере есть четыре «а» и два «в», всего шесть.

l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)

print(c.items())
# dict_items([('a', 4), ('b', 1), ('c', 2)])

print([i for i in l if c[i] >= 2])
# ['a', 'a', 'a', 'a', 'c', 'c']

print([i[1] for i in c.items() if i[1] >= 2])
# [4, 2]

print(sum(i[1] for i in c.items() if i[1] >= 2))
# 6

Ниже приведен пример извлечения типов элементов с двумя и более вхождениями и подсчета количества вхождений. В этом примере есть два типа, a и c.

print([i[0] for i in c.items() if i[1] >= 2])
# ['a', 'c']

print([i[1] >= 2 for i in c.items()])
# [True, False, True]

print(sum(i[1] >= 2 for i in c.items()))
# 2

Подсчитывает количество вхождений слова в строку.

В качестве конкретного примера подсчитаем количество вхождений слова в строку.

Сначала замените ненужные запятые и точки пустой строкой с помощью метода replace(), а затем удалите их. Затем с помощью метода split() создайте список, разделенный пробелами.

s = 'government of the people, by the people, for the people.'

s_remove = s.replace(',', '').replace('.', '')

print(s_remove)
# government of the people by the people for the people

word_list = s_remove.split()

print(word_list)
# ['government', 'of', 'the', 'people', 'by', 'the', 'people', 'for', 'the', 'people']

Если вы можете составить список, вы можете получить количество раз, когда появляется каждое слово, типы слов, которые появляются, и с помощью most_common() из collections.Counter получить слово, которое появляется больше всего раз.

print(word_list.count('people'))
# 3

print(len(set(word_list)))
# 6

c = collections.Counter(word_list)

print(c)
# Counter({'the': 3, 'people': 3, 'government': 1, 'of': 1, 'by': 1, 'for': 1})

print(c.most_common()[0][0])
# the

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

Также в случае с японским текстом нельзя использовать split() для разделения текста, поскольку нет четкого разделения слов. Например, для этого можно использовать библиотеку Janome.

Подсчет количества вхождений символа в строку.

Поскольку строки также являются типом последовательности, их можно использовать с методом count() или передавать в качестве аргумента в конструктор collections.Counter().

s = 'supercalifragilisticexpialidocious'

print(s.count('p'))
# 2

c = collections.Counter(s)

print(c)
# Counter({'i': 7, 's': 3, 'c': 3, 'a': 3, 'l': 3, 'u': 2, 'p': 2, 'e': 2, 'r': 2, 'o': 2, 'f': 1, 'g': 1, 't': 1, 'x': 1, 'd': 1})

Пример поиска 5 наиболее часто встречающихся символов.

print(c.most_common(5))
# [('i', 7), ('s', 3), ('c', 3), ('a', 3), ('l', 3)]

values, counts = zip(*c.most_common(5))

print(values)
# ('i', 's', 'c', 'a', 'l')
Copied title and URL