Підрахунок кількості входжень кожного елемента в список за допомогою лічильника Python

Бізнес

У 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.

Як користуватися колекціями. Лічильник

Колекції стандартної бібліотеки 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)]

Якщо вам потрібен окремий список елементів/виходів, упорядкований за кількістю зустрічей, а не за набором (елемент, кількість випадків), ви можете розкласти його наступним чином

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 із лише унікальними значеннями як елементами. Кількість елементів цього типу отримуємо за допомогою 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 є підкласом цілого типу int, де true розглядається як 1, а false як 0. Отже, кількість істинних значень (кількість елементів, які задовольняють умову) можна підрахувати шляхом обчислення суми за допомогою суми ().

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. Зверніть увагу, що > має більший пріоритет, ніж ні (вона обчислюється спочатку), тому дужки () в (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() отримує кортеж (елемент, кількість випадків), а кількість випадків визначає умову.

Нижче наведено приклад вилучення елементів з двома або більше входженнями та підрахунку загальної кількості входів. У цьому прикладі чотири символи a і два c, всього шість.

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']

Якщо ви можете скласти список, ви можете дізнатися, скільки разів з’являється кожне слово, типи слів, які з’являються, і найбільше_поширених() колекцій. Лічильник, щоб отримати слово, яке зустрічається найчастіше.

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