Að telja fjölda tilvika hvers þáttar á lista með Python’s Counter

Viðskipti

Í Python er hægt að fá fjölda allra þátta í lista eða tuple með því að nota innbyggða fallið len(), og fjölda hvers staks (fjölda tilvika hvers staks) er hægt að fá með því að nota count() aðferðina .

Að auki er hægt að nota Counter flokkinn í Python staðlaða bókasafnssöfnunum til að fá þættina í röð eftir fjölda atvika.

Í þessum kafla munum við ræða eftirfarandi

  • Teldu heildarfjölda þátta:len()
  • Telja fjölda hvers þáttar (fjöldi tilvika hvers þáttar):count()
  • Notkun.collections.Counter
  • Hlutir eru sóttir í röð eftir tíðni:most_common()
  • Telja fjölda (tegund) þátta sem ekki skarast (einkvæmir þættir).
  • Teldu fjölda þátta sem uppfylla skilyrðið.

Að auki, sem áþreifanlegt dæmi, er eftirfarandi útskýrt með sýnishornskóða.

  • Telur fjölda tilvika orðs í streng.
  • Teldu fjölda tilvika stafs í streng.

Sýnið er listi, en sömu vinnslu er hægt að gera með tuple.

Telja heildarfjölda þátta: len()

Til að telja heildarfjölda þátta í lista eða túllu, notaðu innbyggðu fallið len().

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

print(len(l))
# 7

Talning á fjölda hvers staks (fjöldi tilvika hvers staks): count() aðferð

Til að telja fjölda hvers staks (fjölda tilvika hvers staks), notaðu count() aðferðina fyrir lista, túlla osfrv.

Ef gildi sem er ekki til sem frumefni er sent sem viðfang, er 0 skilað.

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

Ef þú vilt fá fjölda tilvika hvers þáttar í einu er eftirfarandi safn.Counter gagnlegt.

Hvernig á að nota söfn.Counter

Python staðlaða bókasafnssöfnin eru með Counter class.

Counter() er undirflokkur af orðabókargerðinni dict, sem hefur gögn í formi þátta sem lykla og tilvik sem gildi.

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

Ef þáttur er tilgreindur sem lykill er hægt að fá fjölda staka. Ef gildi sem ekki er til sem frumefni er tilgreint er 0 skilað.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Þú getur líka notað orðabókartegundaraðferðir eins og lykla(), gildi(), atriði() osfrv.

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

Þessar aðferðir skila hlutum af gerðinni dict_keys o.s.frv. Hægt er að nota þær eins og þær eru ef þú vilt keyra for yfirlýsingu. Ef þú vilt breyta því í lista, notaðu list().

Að fá þætti í röð eftir útlitstíðni: most_common() aðferð

Teljari hefur most_common() aðferðina, sem skilar lista yfir túllur af forminu (eining, fjöldi tilvika) raðað eftir fjölda tilvika.

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

Stofninn sem er með mestan fjölda tilvika er hægt að fá með því að tilgreina vísitölu eins og [0] fyrir flesta tilvik og [-1] fyrir lægsta fjölda tilvika. Ef þú vilt fá aðeins þættina eða aðeins fjölda tilvika geturðu tilgreint vísitöluna frekar.

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

Ef þú vilt raða þeim í röð eftir fækkandi fjölda tilvika, notaðu sneiðina með aukninguna stillt á -1.

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

Ef röksemdin n er tilgreind fyrir most_common() aðferðina, eru aðeins n þættirnir sem hafa flestar tilvik skilað. Ef því er sleppt, allir þættir.

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

Ef þú vilt sérstakan lista yfir þætti/tilvik raðað eftir fjölda tilvika, frekar en túllu af (þáttur, fjöldi tilvika), geturðu sundurliðað það sem hér segir

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

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

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

Innbyggða aðgerðin zip() er notuð til að yfirfæra tvívíddar lista (í þessu tilviki lista yfir túlla) og pakka honum síðan upp og draga hann út.

Telja fjölda (tegund) þátta sem ekki skarast (einkvæmir þættir).

Til að telja hversu margir þættir sem ekki skarast (einkvæmir þættir) eru í lista eða túllu (hversu margar tegundir eru), notaðu Counter eða set() eins og lýst er hér að ofan.

Fjöldi þátta í Counter hlutnum er jafn og fjöldi þátta sem ekki skarast í upprunalega listanum, sem hægt er að fá með len().

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

print(len(c))
# 3

Þú getur líka notað set(), smiðinn fyrir mengitegundasettið, sem er auðveldara ef þú þarft ekki Counter hlut.

Setjagerðin er gagnategund sem hefur ekki afrita þætti. Að senda lista til set() hunsar tvítekin gildi og skilar hlut af gerðinni setti með aðeins einstökum gildum sem þætti. Fjöldi frumefna af þessari gerð er fenginn með len().

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

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

Teldu fjölda þátta sem uppfylla skilyrðið.

Til að telja fjölda þátta í lista eða túllu sem uppfylla tiltekið skilyrði, notaðu listaskilningsnátnun eða rafallatjáningu.

Sem dæmi, teldu fjölda þátta með neikvæðum gildum fyrir eftirfarandi lista yfir tölur

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

Með því að beita skilyrtri tjáningu á hvern þátt í nótnaskilningi lista fæst lista þar sem þættirnir eru Boolean bools (satt, ósatt). Boolean gerð bool er undirflokkur heiltölugerðarinnar int, þar sem satt er meðhöndlað sem 1 og ósatt sem 0. Því er hægt að telja fjölda sannra gilda (fjölda þátta sem uppfylla skilyrðið) með því að reikna summan með summu ().

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

Ef við skiptum út [] í listaskilningstákninu fyrir (), fáum við rafallatjáningu. Listaskilningurinn myndar lista yfir alla þætti sem eru unnin, en rafallatjáningin vinnur þættina í röð og er því minni skilvirkari.

Þegar rafallatjáningin er einu rökin er hægt að sleppa () þannig að hægt er að skrifa hana eins og í síðara tilvikinu.

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

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

Ef þú vilt telja fjölda rangra gilda (fjöldi þátta sem uppfylla ekki skilyrðið), notaðu ekki. Athugaðu að > hefur hærri forgang en ekki (það er fyrst reiknað), þannig að svigarnir () í (i < 0) í eftirfarandi dæmi eru ekki nauðsynlegir.

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

Auðvitað er hægt að breyta forsendum sjálfum.

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

Nokkur önnur dæmi eru sýnd hér að neðan.

Dæmi um að fá fjölda staka staka fyrir lista yfir tölur.

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

Dæmi um skilyrði fyrir lista yfir strengi.

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

Teljari er notaður til að telja miðað við fjölda atvika. items() sækir tuple af (þáttur, fjöldi tilvika), og fjöldi tilvika tilgreinir skilyrðið.

Eftirfarandi er dæmi um að draga út þætti með tvö eða fleiri tilvik og telja heildarfjölda tilvika. Í þessu dæmi eru fjögur a og tvö c, samtals sex.

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

Eftirfarandi er dæmi um að draga út tegundir frumefna með tveimur eða fleiri tilvikum og telja fjölda tilvika. Í þessu dæmi eru tvær tegundir, a og 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

Telur fjölda tilvika orðs í streng.

Sem áþreifanlegt dæmi skulum við telja fjölda tilvika orðs í streng.

Fyrst skaltu skipta út óþarfa kommum og punktum fyrir tóman streng með því að nota replace() aðferðina og eyða þeim síðan. Notaðu síðan split() aðferðina til að búa til lista aðskilinn með bilum.

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

Ef þú getur búið til lista geturðu fengið fjölda skipta sem hvert orð birtist, tegundir orða sem birtast og mest_algengt() safn. Teljari til að fá það orð sem kemur oftast fyrir.

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

Ofangreint er mjög einfalt ferli, svo það er betra að nota bókasöfn eins og NLTK fyrir flóknari náttúrulega málvinnslu.

Einnig, þegar um japanskan texta er að ræða, er ekki hægt að nota split() til að skipta textanum því það er enginn skýr orðaskilnaður. Til dæmis geturðu notað Janome bókasafnið til að ná þessu.

Teldu fjölda tilvika stafs í streng.

Þar sem strengir eru líka röð tegunda, þá er hægt að nota þá með count() aðferðinni eða senda sem rök til byggingaraðila safnsins.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})

Dæmi um að sækja efstu 5 stafi sem koma oftast fyrir.

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