Падлік колькасці ўваходжанняў кожнага элемента ў спіс з дапамогай лічыльніка 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]

Прымяненне ўмоўнага выразу да кожнага элемента ў абазначэнні разумення спісу дае спіс, элементамі якога з’яўляюцца булевы булевы (праўда, ілжыва). Булевы тып 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() здабывае картэж (элемент, колькасць уваходжанняў), а колькасць уваходжанняў вызначае ўмову.

Ніжэй прыведзены прыклад вылучэння элементаў з двума і больш уваходжаннямі і падліку агульнай колькасці ўваходжанняў. У гэтым прыкладзе ёсць чатыры а і два с, усяго шэсць.

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