Преброяване на броя на срещите на всеки елемент в списък с функцията Counter на 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.

Как да използвате 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)]

Ако искате отделен списък от елементи\появления, подреден по броя на появяванията, а не кортеж от (елемент, брой появявания), можете да го разложите по следния начин

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]

Прилагането на условен израз към всеки елемент в запис за разбиране на списък води до списък, чиито елементи са булеви булеви стойности (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