Numërimi i numrit të dukurive të secilit element në një listë me numëruesin e Python

biznes

Në Python, numri i të gjithë elementëve në një listë ose tuple mund të merret duke përdorur funksionin e integruar len(), dhe numri i secilit element (numri i dukurive të secilit element) mund të merret duke përdorur metodën count() .

Përveç kësaj, klasa Counter e koleksioneve standarde të bibliotekës Python mund të përdoret për të marrë elementet sipas numrit të dukurive.

Në këtë seksion, ne do të diskutojmë në vijim

  • Numëroni numrin e përgjithshëm të elementeve:len()
  • Numëroni numrin e secilit element (numrin e shfaqjeve të secilit element):count()
  • Përdorimi.collections.Counter
  • Elementet merren sipas frekuencës së shfaqjes:most_common()
  • Numëroni numrin (llojin) e elementeve që nuk mbivendosen (elemente unike).
  • Numëroni numrin e elementeve që plotësojnë kushtin.

Përveç kësaj, si shembull konkret, në vijim shpjegohet me kodin e mostrës.

  • Numëron numrin e shfaqjes së një fjale në një varg.
  • Numëroni numrin e shfaqjeve të një karakteri në një varg.

Mostra është një listë, por i njëjti përpunim mund të bëhet me tuples.

Numëroni numrin total të elementeve: len()

Për të numëruar numrin total të elementeve në një listë ose tuple, përdorni funksionin e integruar len().

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

print(len(l))
# 7

Numërimi i numrit të secilit element (numri i dukurive të secilit element): metoda count().

Për të numëruar numrin e secilit element (numrin e dukurive të secilit element), përdorni metodën count() për listat, tuples, etj.

Nëse një vlerë që nuk ekziston si element kalohet si argument, 0 kthehet.

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

Nëse dëshironi të merrni numrin e dukurive të secilit element menjëherë, koleksioni i mëposhtëm.Numëruesi është i dobishëm.

Si të përdorim koleksionet.Bashkues

Koleksionet standarde të bibliotekës Python kanë një klasë Counter.

Counter() është një nënklasë e llojit të fjalorit dict, e cila ka të dhëna në formën e elementeve si çelësa dhe dukuritë si vlera.

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

Nëse një element specifikohet si çelës, mund të merret numri i elementeve. Nëse specifikohet një vlerë që nuk ekziston si element, 0 kthehet.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Ju gjithashtu mund të përdorni metoda të llojit të fjalorit si çelësat (), vlerat (), artikujt (), etj.

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

Këto metoda kthejnë objekte të tipit dict_keys, etj. Ato mund të përdoren si janë nëse dëshironi të ekzekutoni një deklaratë for. Nëse dëshironi ta konvertoni atë në një listë, përdorni list().

Marrja e elementeve sipas frekuencës së paraqitjes: metoda most_common().

Numëruesi ka metodën most_common(), e cila kthen një listë me tuple të formës (element, numri i dukurive) të renditura sipas numrit të dukurive.

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

Elementi me numrin më të madh të dukurive mund të merret duke specifikuar një indeks, si p.sh. [0] për numrin më të madh të dukurive dhe [-1] për numrin më të ulët të dukurive. Nëse dëshironi të merrni vetëm elementet ose vetëm numrin e dukurive, mund të specifikoni më tej indeksin.

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

Nëse dëshironi t’i renditni ato sipas renditjes së numrit zvogëlues të dukurive, përdorni fetën me shtimin e vendosur në -1.

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

Nëse argumenti n specifikohet për metodën most_common(), kthehen vetëm n elementët me numrin më të madh të dukurive. Nëse hiqet, të gjithë elementët.

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

Nëse dëshironi një listë të veçantë elementesh/shfaqjesh të renditura sipas numrit të dukurive, në vend të një dyfishi (elementi, numërimi i dukurive), mund ta zbërtheni si më poshtë

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

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

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

Funksioni i integruar zip() përdoret për të transpozuar një listë dy-dimensionale (në këtë rast, një listë me tuples), dhe më pas shpaketoni dhe ekstraktoni atë.

Numëroni numrin (llojin) e elementeve që nuk mbivendosen (elemente unike).

Për të numëruar sa elementë jo të mbivendosur (elementë unikë) ka në një listë ose tuple (sa lloje ka), përdorni Counter ose set() siç përshkruhet më sipër.

Numri i elementeve në objektin Counter është i barabartë me numrin e elementeve që nuk mbivendosen në listën origjinale, i cili mund të merret me len().

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

print(len(c))
# 3

Ju gjithashtu mund të përdorni set(), konstruktorin për grupin e tipit set, i cili është më i lehtë nëse nuk keni nevojë për një objekt Counter.

Lloji i grupit është një lloj i të dhënave që nuk ka elemente të dyfishta. Kalimi i një liste në set() injoron vlerat e dyfishta dhe kthen një objekt të tipit të vendosur me vetëm vlera unike si elementë. Numri i elementeve të këtij lloji merret nga len().

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

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

Numëroni numrin e elementeve që plotësojnë kushtin.

Për të numëruar numrin e elementeve në një listë ose tuple që plotësojnë një kusht të caktuar, përdorni shënimin e kuptimit të listës ose shprehjet e gjeneratorit.

Si shembull, numëroni numrin e elementeve me vlera negative për listën e mëposhtme të numrave

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

Zbatimi i një shprehjeje të kushtëzuar për çdo element në shënimin e kuptimit të listës jep një listë, elementët e së cilës janë Boolean Boolean (true, false). Lloji Boolean bool është një nënklasë e llojit të plotë int, ku true trajtohet si 1 dhe false si 0. Prandaj, numri i vlerave të vërteta (numri i elementeve që plotësojnë kushtin) mund të numërohet duke llogaritur shumën duke përdorur shumën ().

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

Nëse zëvendësojmë [] në shënimin e kuptimit të listës me (), marrim një shprehje gjenerator. Shënimi i kuptimit të listës gjeneron një listë të të gjithë elementëve të përpunuar, ndërsa shprehja e gjeneratorit i përpunon elementët në mënyrë sekuenciale dhe për këtë arsye është më efikase në memorie.

Kur shprehja gjenerator është argumenti i vetëm, () mund të hiqet, kështu që mund të shkruhet si në rastin e fundit.

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

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

Nëse dëshironi të numëroni numrin e vlerave false (numrin e elementeve që nuk plotësojnë kushtin), mos përdorni. Vini re se > ka një përparësi më të lartë se jo (llogaritet së pari), kështu që kllapat () në (i < 0) në shembullin e mëposhtëm nuk janë të nevojshme.

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

Sigurisht, vetë kushtet mund të ndryshohen.

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

Disa shembuj të tjerë janë paraqitur më poshtë.

Shembull i marrjes së numrit të elementeve tek për një listë numrash.

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

Shembull i një kushti për një listë vargjesh.

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

Numëruesi përdoret për të numëruar në bazë të numrit të dukurive. Items() merr një tuple të (elementit, numrit të dukurive), dhe numri i dukurive specifikon kushtin.

Më poshtë është një shembull i nxjerrjes së elementeve me dy ose më shumë dukuri dhe numërimit të numrit total të dukurive. Në këtë shembull, ka katër a dhe dy c, për një total prej gjashtë.

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

Më poshtë është një shembull i nxjerrjes së llojeve të elementeve me dy ose më shumë dukuri dhe numërimit të numrit të dukurive. Në këtë shembull, ekzistojnë dy lloje, a dhe 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

Numëron numrin e shfaqjes së një fjale në një varg.

Si shembull konkret, le të numërojmë numrin e paraqitjeve të një fjale në një varg.

Fillimisht, zëvendësoni presjet dhe pikat e panevojshme me një varg të zbrazët duke përdorur metodën e zëvendësimit () dhe më pas fshijini ato. Pastaj, përdorni metodën split() për të krijuar një listë të ndarë me hapësira.

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

Nëse mund të bëni një listë, mund të merrni numrin e herëve që shfaqet secila fjalë, llojet e fjalëve që shfaqen dhe most_common() e koleksioneve. Counter për të marrë fjalën që shfaqet më shumë herë.

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

Sa më sipër është një proces shumë i thjeshtë, kështu që është më mirë të përdoren biblioteka të tilla si NLTK për përpunim më kompleks të gjuhës natyrore.

Gjithashtu, në rastin e tekstit japonez, split() nuk mund të përdoret për të ndarë tekstin sepse nuk ka ndarje të qartë të fjalëve. Për shembull, mund të përdorni bibliotekën Janome për ta arritur këtë.

Numëroni numrin e shfaqjeve të një karakteri në një varg.

Meqenëse vargjet janë gjithashtu një lloj sekuence, ato mund të përdoren me metodën count() ose t’i kalojnë si argument konstruktorit të koleksioneve.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})

Shembull i marrjes së 5 karaktereve kryesore që shfaqen më shpesh.

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