Bi Hejmarê Python re hejmara rûdanên her hêmanekê di lîsteyê de jimartin

Dikan

Di Python de, hejmara hemî hêmanên di navnîşek an pirjimar de bi karanîna fonksiyona çêkirî ya len() dikare were bidestxistin, û hejmara her elementek (hejmara bûyerên her hêmanek) bi rêbaza hejmartinê () dikare were bidestxistin. .

Wekî din, çîna Counter a berhevokên pirtûkxaneya standard a Python dikare were bikar anîn da ku hêmanan li gorî hejmara bûyeran bigire.

Di vê beşê de, em ê li jêr nîqaş bikin

  • Hejmara giştî ya hêmanan bijmêre:len()
  • Hejmara her hêmanekê bijmêre (hejmara rûdanên her hêmanekê):count()
  • Bikaranîna.collections.Counter
  • Hêman li gorî frekansa rûdanan têne wergirtin:most_common()
  • Hejmara (cure) hêmanên nelihev (hêmanên yekta) bijmêre.
  • Hejmara hêmanên ku şertê têr dikin bijmêre.

Wekî din, wekî mînakek berbiçav, jêrîn bi koda nimûneyê tê rave kirin.

  • Hejmara peydabûna peyvekê di rêzekê de dihejmêre.
  • Hejmara rûdanên karakterekê di rêzekê de bijmêre.

Nimûne lîsteyek e, lê heman pêvajo dikare bi tîpan were kirin.

Hejmara giştî ya hêmanan bijmêre: len()

Ji bo jimartina hejmara giştî ya hêmanên di navnîşek an pirtikê de, fonksiyona çêkirî len() bikar bînin.

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

print(len(l))
# 7

Jimartina hejmara her hêmanekê (hejmara rûdana her hêmanekê): rêbaza count().

Ji bo jimartina hejmara her hêmanekê (hejmara rûdanên her hêmanekê), ji bo navnîşan, tîpan, û hwd rêbaza count() bikar bînin.

Ger nirxek ku wekî hêmanek tune wekî arguman were derbas kirin, 0 tê vegerandin.

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

Heke hûn dixwazin jimara qewimîna her hêmanekê di carekê de bi dest bixin, berhevoka jêrîn.Hejmar bikêr e.

Meriv çawa berhevokan bikar tîne.Hejmar

Koleksiyonên pirtûkxaneya standard ên Python xwedan çînek Counter e.

Counter() binkifla cureya ferhengê dict e, ku daneyan di forma hêmanan de wekî key û rûdanên wekî nirxan heye.

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

Ger hêmanek wekî mifteyê were destnîşan kirin, hejmara hêmanan dikare were bidestxistin. Ger nirxek ku wekî hêmanek tune were destnîşan kirin, 0 tê vegerandin.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Her weha hûn dikarin şêwazên tîpên ferhengê yên wekî keys(), nirx(), hêman(), hwd jî bikar bînin.

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

Van rêbazan tiştên ji cureyê dict_keys, hwd vedigerînin. Heke hûn bixwazin gotinek ji bo rêve bibin, dikarin wekî ku têne bikar anîn. Heke hûn dixwazin wê veguherînin navnîşek, lîsteya ().

Wergirtina hêmanan li gorî frekansa xuyangê: Rêbaza most_common().

Counter xwedan rêbaza most_common() ye, ku lîsteyek ji tîpên formê (hêman, hejmara bûyeran) ku li gorî hejmara bûyeran hatine rêz kirin vedigerîne.

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

Hêmana ku hejmara herî zêde ya rûdanan heye dikare bi destnîşankirina îndeksekê were bidestxistin, wekî [0] ji bo hejmara herî zêde bûyeran û [-1] ji bo hejmara herî kêm bûyeran. Heke hûn dixwazin tenê hêmanan an tenê hejmara bûyeran bistînin, hûn dikarin pêvekê bêtir diyar bikin.

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

Ger hûn dixwazin wan li gorî kêmbûna hejmara rûdanan rêz bikin, perçeya bi zêdekirina -1-ê hatî danîn bikar bînin.

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

Ger argumana n ji bo rêbaza most_common()-ê were destnîşan kirin, tenê n hêmanên ku jimara herî zêde bûyeran hene têne vegerandin. Heke ew ji holê rabe, hemî hêman.

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

Heke hûn dixwazin navnîşek veqetandî ya hêmanan/bûyanên ku li gorî hejmara bûyeran hatine rêz kirin, ji bilî pirjimarek (hêman, hejmartina bûyeran), hûn dikarin wê bi vî rengî veqetînin.

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

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

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

Fonksiyona çêkirî zip () ji bo veguheztina navnîşek du-alî (di vê rewşê de, navnîşek lûtkeyan) tê bikar anîn, û dûv re wê veke û jê derxe.

Hejmara (cure) hêmanên nelihev (hêmanên yekta) bijmêre.

Ji bo hejmartina çend hêmanên nelihevkirî (hêmanên yekta) di navnîşek an pirtikê de hene (çend celeb hene), wekî ku li jor hatî destnîşan kirin Counter an set() bikar bînin.

Hejmara hêmanên di objeya Counter de bi hejmara hêmanên nelihevkirî yên di navnîşa orîjînal de ye, ku dikare bi len(-ê) were bidestxistin.

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

print(len(c))
# 3

Di heman demê de hûn dikarin set(), çêkerê ji bo celebê setê bikar bînin, ku heke hewcedariya we bi objeyek Counter tune be hêsantir e.

Tîpa set cureyek daneyê ye ku hêmanên dubare nînin. Derbaskirina lîsteyek ji bo set() nirxên dubare paşguh dike û tiştek ji celebê set bi tenê nirxên yekta wekî hêman vedigerîne. Hejmara hêmanên vê cureyê bi len() tê wergirtin.

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

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

Hejmara hêmanên ku şertê têr dikin bijmêre.

Ji bo jimartina hêjmara hêmanên di navnîşek an pirtikê de ku şertek diyarkirî têr dikin, nîşana têgihîştina navnîşê an jî bêjeyên çêker bikar bînin.

Mînakî, ji bo navnîşa hejmarên jêrîn hejmara hêmanên bi nirxên neyînî bijmêre

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

Di nîşaneya têgihîştina navnîşê de ji bo her hêmanek birêkûpêkek şertî tê sepandin lîsteyek ku hêmanên wê yên Boolean (rast, xelet) ne. Bool tîpa Boolean binklassek ji tîpa yekjimar int e, li wir rast wekî 1 û xelet wekî 0 tê hesibandin. Ji ber vê yekê, hejmara nirxên rastîn (hejmara hêmanên ku şertê têr dikin) dikare bi hesabkirina berhevokê bi berhevokê were hejmartin. ().

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

Ger em di navnîşa têgihîştina navnîşê de [] bi () veguherînin, em ravekek çêker werdigirin. Nîşana têgihîştina navnîşê navnîşek hemî hêmanên ku hatine pêvajo kirin diafirîne, dema ku vegotina jeneratorê hêmanan bi rêkûpêk pêvajoyê dike û ji ber vê yekê bîranîn bikêrtir e.

Dema ku îfadeya jeneratorê yekane arguman be, () dikare were jêbirin, ji ber vê yekê dikare wekî rewşa paşîn were nivîsandin.

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

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

Heke hûn dixwazin hejmara nirxên derewîn (hejmara hêmanên ku şertê têr nakin) bijmêrin, nekarin. Bala xwe bidinê ku & gt; pêşanîyek ji nebûnê mezintir e (ew pêşî tê hesibandin), ji ber vê yekê di mînaka jêrîn de parantez () di (i < 0) de ne hewce ne.

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

Bê guman, şert û mercên xwe dikarin bêne guhertin.

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

Hin mînakên din li jêr têne nîşandan.

Nimûneya bidestxistina hejmara hêmanên cêwî ji bo navnîşek jimareyan.

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

Mînak şertek ji bo navnîşek rêzan.

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

Counter ji bo hejmartina li ser bingeha hejmara bûyeran tê bikar anîn. hêman() jimareyek ji (hêman, hejmara rûdanan) vedigire, û hejmara rûdanan şertê diyar dike.

Ya jêrîn mînakek derxistina hêmanên bi du an zêdetir bûyeran û jimartina hejmara giştî ya bûyeran e. Di vê nimûneyê de çar a û du c hene, bi tevahî şeş.

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

Li jêr mînakek derxistina cureyên hêmanên bi du yan zêdetir bûyeran û jimartina hejmara rûdanan e. Di vê nimûneyê de du celeb hene, 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

Hejmara peydabûna peyvekê di rêzekê de dihejmêre.

Weke mînakeke şênber, ka em hejmara peydabûna peyvekê di rêzekê de bijmêrin.

Pêşî, bi karanîna rêbaza ()-ê, kommas û xalên nepêwist bi rêzek vala biguhezînin, û dûv re wan jêbirin. Dûv re, rêbaza split() bikar bînin da ku navnîşek ji hêla cîhan veqetandî biafirînin.

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

Heke hûn dikarin lîsteyek çêkin, hûn dikarin çend caran ku her peyvek xuya dike, celebên peyvên ku xuya dibin, û herî_common() ya berhevokan bi dest bixin. Ji bo peyva ku herî zêde xuya dibe, jimarvan bigire.

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

Ya jorîn pêvajoyek pir hêsan e, ji ber vê yekê çêtir e ku meriv pirtûkxaneyên wekî NLTK ji bo pêvajoyek zimanê xwezayî ya tevlihevtir bikar bînin.

Di heman demê de, di mijara nivîsa Japonî de, split() ji bo perçekirina nivîsê nayê bikar anîn ji ber ku veqetandina peyvan a zelal tune. Mînakî, hûn dikarin pirtûkxaneya Janome bikar bînin ku vê yekê bi dest bixin.

Hejmara rûdanên karakterekê di rêzekê de bijmêre.

Ji ber ku rêzik jî celebek rêzikan in, ew dikarin bi rêbaza count()-ê werin bikar anîn an jî wekî argumanek ji çêkerê berhevokan re derbas bibin.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})

Mînaka wergirtina 5 tîpên herî zêde ku diqewimin.

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