Binibilang ang bilang ng mga paglitaw ng bawat elemento sa isang listahan gamit ang Python’s Counter

Negosyo

Sa Python, ang bilang ng lahat ng elemento sa isang listahan o tuple ay maaaring makuha gamit ang built-in na function na len(), at ang bilang ng bawat elemento (ang bilang ng mga paglitaw ng bawat elemento) ay maaaring makuha gamit ang count() method. .

Bilang karagdagan, ang Counter class ng Python standard na koleksyon ng library ay maaaring gamitin upang makuha ang mga elemento sa pagkakasunud-sunod ng bilang ng mga paglitaw.

Sa bahaging ito, tatalakayin natin ang mga sumusunod

  • Bilangin ang kabuuang bilang ng mga elemento:len()
  • Bilangin ang bilang ng bawat elemento (ang bilang ng mga paglitaw ng bawat elemento):count()
  • Paggamit.collections.Counter
  • Kinukuha ang mga elemento sa pagkakasunud-sunod ng dalas ng paglitaw:most_common()
  • Bilangin ang bilang (uri) ng mga hindi magkakapatong na elemento (mga natatanging elemento).
  • Bilangin ang bilang ng mga elemento na nakakatugon sa kundisyon.

Bilang karagdagan, bilang isang kongkretong halimbawa, ang mga sumusunod ay ipinaliwanag sa sample code.

  • Binibilang ang bilang ng paglitaw ng isang salita sa isang string.
  • Bilangin ang bilang ng mga paglitaw ng isang character sa isang string.

Ang sample ay isang listahan, ngunit ang parehong pagproseso ay maaaring gawin sa mga tuple.

Bilangin ang kabuuang bilang ng mga elemento: len()

Upang mabilang ang kabuuang bilang ng mga elemento sa isang listahan o tuple, gamitin ang built-in na function na len().

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

print(len(l))
# 7

Pagbibilang ng bilang ng bawat elemento (ang bilang ng mga paglitaw ng bawat elemento): count() method

Upang mabilang ang bilang ng bawat elemento (ang bilang ng mga paglitaw ng bawat elemento), gamitin ang count() na paraan para sa mga listahan, tuple, atbp.

Kung ang isang halaga na hindi umiiral bilang isang elemento ay ipinasa bilang isang argumento, 0 ay ibinalik.

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

Kung gusto mong makuha ang bilang ng mga paglitaw ng bawat elemento nang sabay-sabay, ang sumusunod na koleksyon. Ang Counter ay kapaki-pakinabang.

Paano gamitin ang mga koleksyon.Counter

Ang mga koleksyon ng Python standard library ay may Counter class.

Ang Counter() ay isang subclass ng dict na uri ng diksyunaryo, na mayroong data sa anyo ng mga elemento bilang mga susi at mga paglitaw bilang mga halaga.

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

Kung ang isang elemento ay tinukoy bilang isang susi, ang bilang ng mga elemento ay maaaring makuha. Kung ang isang halaga na hindi umiiral bilang isang elemento ay tinukoy, 0 ay ibinalik.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Maaari ka ring gumamit ng mga paraan ng uri ng diksyunaryo tulad ng mga key(), values(), item(), atbp.

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

Ang mga pamamaraang ito ay nagbabalik ng mga bagay na may uri ng dict_keys, atbp. Magagamit ang mga ito kung gusto mong magpatakbo ng for statement. Kung gusto mong i-convert ito sa isang listahan, gamitin ang list().

Pagkuha ng mga elemento sa pagkakasunud-sunod ng dalas ng paglitaw: most_common() method

Ang Counter ay may most_common() na pamamaraan, na nagbabalik ng isang listahan ng mga tuple ng form (elemento, bilang ng mga pangyayari) na pinagsunod-sunod ayon sa bilang ng mga pangyayari.

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

Ang elementong may pinakamataas na bilang ng mga paglitaw ay maaaring makuha sa pamamagitan ng pagtukoy ng isang index, gaya ng [0] para sa pinakamataas na bilang ng mga paglitaw at [-1] para sa pinakamababang bilang ng mga paglitaw. Kung nais mong makuha lamang ang mga elemento o ang bilang lamang ng mga paglitaw, maaari mong tukuyin ang index nang higit pa.

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

Kung gusto mong pag-uri-uriin ang mga ito sa pagkakasunud-sunod ng pagbaba ng bilang ng mga paglitaw, gamitin ang slice na may increment na nakatakda sa -1.

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

Kung ang argumento n ay tinukoy para sa most_common() na pamamaraan, tanging ang n elemento na may pinakamataas na bilang ng mga pangyayari ang ibabalik. Kung ito ay tinanggal, ang lahat ng mga elemento.

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

Kung gusto mo ng hiwalay na listahan ng mga elemento/pangyayari na nakaayos ayon sa bilang ng mga paglitaw, sa halip na isang tuple ng (elemento, bilang ng pangyayari), maaari mo itong i-decompose bilang mga sumusunod

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

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

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

Ang built-in na function na zip() ay ginagamit upang i-transpose ang isang two-dimensional na listahan (sa kasong ito, isang listahan ng mga tuple), at pagkatapos ay i-unpack at i-extract ito.

Bilangin ang bilang (uri) ng mga hindi magkakapatong na elemento (mga natatanging elemento).

Upang mabilang kung gaano karaming mga elementong hindi nagsasapawan (mga natatanging elemento) ang nasa isang listahan o tuple (kung gaano karaming mga uri ang mayroon), gamitin ang Counter o set() gaya ng inilarawan sa itaas.

Ang bilang ng mga elemento sa Counter object ay katumbas ng bilang ng mga hindi magkakapatong na elemento sa orihinal na listahan, na maaaring makuha gamit ang len().

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

print(len(c))
# 3

Maaari mo ring gamitin ang set(), ang constructor para sa set type set, na mas madali kung hindi mo kailangan ng Counter object.

Ang uri ng hanay ay isang uri ng data na walang mga duplicate na elemento. Ang pagpasa ng isang listahan sa set() ay binabalewala ang mga duplicate na halaga at ibinabalik ang isang object ng uri na itinakda na may mga natatanging halaga lamang bilang mga elemento. Ang bilang ng mga elemento ng ganitong uri ay nakuha ng len().

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

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

Bilangin ang bilang ng mga elemento na nakakatugon sa kundisyon.

Upang mabilang ang bilang ng mga elemento sa isang listahan o tuple na nakakatugon sa isang partikular na kundisyon, gumamit ng notasyon sa pag-unawa sa listahan o mga expression ng generator.

Bilang halimbawa, bilangin ang bilang ng mga elemento na may mga negatibong halaga para sa sumusunod na listahan ng mga numero

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

Ang paglalapat ng conditional expression sa bawat elemento sa notasyon ng pag-unawa sa listahan ay magbubunga ng isang listahan na ang mga elemento ay Boolean bools (true, false). Ang Boolean type na bool ay isang subclass ng integer type int, kung saan ang true ay itinuturing bilang 1 at false bilang 0. Samakatuwid, ang bilang ng mga true value (ang bilang ng mga elemento na nakakatugon sa kundisyon) ay mabibilang sa pamamagitan ng pagkalkula ng kabuuan gamit ang 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

Kung papalitan natin ang [] sa notasyon ng pag-unawa sa listahan ng (), makakakuha tayo ng expression ng generator. Ang listahan ng pag-unawa sa notasyon ay bumubuo ng isang listahan ng lahat ng mga elementong naproseso, habang ang generator expression ay nagpoproseso ng mga elemento nang sunud-sunod at samakatuwid ay mas mahusay sa memorya.

Kapag ang generator expression ay ang tanging argumento, () ay maaaring tanggalin, kaya maaari itong isulat tulad ng sa huling kaso.

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

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

Kung gusto mong bilangin ang bilang ng mga maling halaga (ang bilang ng mga elemento na hindi nakakatugon sa kundisyon), huwag gamitin. Tandaan na > ay may mas mataas na precedence kaysa sa hindi (ito ay kinakalkula muna), kaya ang mga panaklong () sa (i < 0) sa sumusunod na halimbawa ay hindi kinakailangan.

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

Siyempre, ang mga kondisyon mismo ay maaaring mabago.

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

Ang ilang iba pang mga halimbawa ay ipinapakita sa ibaba.

Halimbawa ng pagkuha ng bilang ng mga kakaibang elemento para sa isang listahan ng mga numero.

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

Halimbawa ng isang kundisyon para sa isang listahan ng mga string.

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

Ginagamit ang counter upang mabilang batay sa bilang ng mga paglitaw. items() ay kinukuha ang isang tuple ng (elemento, bilang ng mga pangyayari), at ang bilang ng mga pangyayari ay tumutukoy sa kundisyon.

Ang sumusunod ay isang halimbawa ng pagkuha ng mga elemento na may dalawa o higit pang paglitaw at pagbibilang ng kabuuang bilang ng mga paglitaw. Sa halimbawang ito, mayroong apat na a at dalawang c, para sa kabuuang anim.

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

Ang sumusunod ay isang halimbawa ng pagkuha ng mga uri ng mga elemento na may dalawa o higit pang mga pangyayari at pagbibilang ng bilang ng mga pangyayari. Sa halimbawang ito, mayroong dalawang uri, a at 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

Binibilang ang bilang ng paglitaw ng isang salita sa isang string.

Bilang isang kongkretong halimbawa, bilangin natin ang bilang ng mga paglitaw ng isang salita sa isang string.

Una, palitan ang mga hindi kinakailangang kuwit at tuldok ng walang laman na string gamit ang replace() na paraan, at pagkatapos ay tanggalin ang mga ito. Pagkatapos, gamitin ang split() na paraan upang lumikha ng isang listahan na pinaghihiwalay ng mga puwang.

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

Kung makakagawa ka ng isang listahan, maaari mong makuha ang dami ng beses na lumilitaw ang bawat salita, ang mga uri ng mga salitang lumalabas, at ang pinaka_karaniwan() ng mga koleksyon. Counter upang makuha ang salitang pinakamadalas na lumalabas.

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

Ang nasa itaas ay isang napakasimpleng proseso, kaya mas mainam na gumamit ng mga aklatan tulad ng NLTK para sa mas kumplikadong natural na pagproseso ng wika.

Gayundin, sa kaso ng Japanese text, hindi magagamit ang split() para hatiin ang text dahil walang malinaw na paghihiwalay ng salita. Halimbawa, maaari mong gamitin ang Janome library para makamit ito.

Bilangin ang bilang ng mga paglitaw ng isang character sa isang string.

Dahil ang mga string ay isa ring uri ng pagkakasunud-sunod, maaari silang gamitin kasama ang count() method o ipasa bilang argumento sa constructor ng mga 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})

Halimbawa ng pagkuha ng nangungunang 5 pinakamadalas na paglitaw ng mga character.

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