Iga elemendi esinemiste arvu loendamine loendis Pythoni loenduri abil

Äri

Pythonis saab kõigi elementide arvu loendis või tuplis kasutada sisseehitatud funktsiooni len() ja iga elemendi arvu (iga elemendi esinemiste arvu) saab kasutada meetodit count().

Lisaks saab Pythoni standardraamatukogu kollektsioonide klassi Counter kasutada elementide saamiseks esinemiste arvu järjekorras.

Selles jaotises arutame järgmist

  • Loendage elementide koguarv:len()
  • loendage iga elemendi arv (iga elemendi esinemiste arv):count()
  • Kasutamine.collections.Counter
  • Elemendid otsitakse välja esinemissageduse järjekorras:most_common()
  • Loendage mittekattuvate elementide (unikaalsete elementide) arv (tüüp).
  • Loendage tingimusele vastavate elementide arv.

Lisaks selgitatakse konkreetse näitena näidiskoodiga järgmist.

  • Loeb sõna esinemiste arvu stringis.
  • Loeb tähemärgi esinemiste arvu stringis.

Näide on nimekiri, kuid sama töötlemist saab teha ka tuppidega.

Arvutab elementide koguarvu: len()

Nimekirja või tupli elementide koguarvu loendamiseks kasutage sisseehitatud funktsiooni len().

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

print(len(l))
# 7

Iga elemendi arvu loendamine (iga elemendi esinemiste arv): meetod count()

Iga elemendi arvu (iga elemendi esinemiste arvu) loendamiseks kasutage loendite, tuplite jne puhul meetodit count().

Kui argumendina antakse üle väärtus, mida ei ole elemendina olemas, tagastatakse 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

Kui soovite saada iga elemendi esinemiste arvu korraga, on kasulik järgmine collection.Counter.

Kuidas kasutada collections.Counter

Pythoni standardraamatukogus collections on klass Counter.

Counter() on sõnastiku tüübi dict alamklass, mille andmed on elemendid võtmetena ja esinemised väärtustena.

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

Kui võtmeks on määratud element, saab elementide arvu. Kui elemendina on määratud väärtus, mida ei ole olemas, tagastatakse 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Võite kasutada ka sõnastiku tüüpi meetodeid nagu keys(), values(), items() jne.

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

Need meetodid tagastavad tüübilt dict_keys jne. objektid. Neid saab kasutada sellisena, kui soovite käivitada for-avaldust. Kui te soovite seda muuta loeteluks, kasutage list().

Elementide saamine esinemissageduse järjekorras: meetod most_common()

Loenduril on meetod most_common(), mis tagastab loendi toplidest kujul (element, esinemiste arv), mis on sorteeritud esinemiste arvu järgi.

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

Kõige suurema esinemiste arvuga elemendi saab kätte, kui määrata indeks, näiteks [0] suurima esinemiste arvu puhul ja [-1] väikseima esinemiste arvu puhul. Kui soovite saada ainult elemente või ainult esinemiste arvu, saate indeksi täpsemalt määrata.

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

Kui soovite neid sorteerida väheneva esinemissageduse järjekorras, kasutage viilu, mille kasvuks on määratud -1.

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

Kui meetodile most_common() on määratud argument n, tagastatakse ainult n elementi, mille esinemiste arv on suurim. Kui see jäetakse ära, siis kõik elemendid.

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

Kui soovite eraldi elementide \esinemiste nimekirja, mis on järjestatud esinemiste arvu järgi, mitte tupli (element, esinemiste arv), saate selle lahutada järgmiselt.

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

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

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

Sisseehitatud funktsiooni zip() kasutatakse kahemõõtmelise loendi (antud juhul tuplite loendi) transponeerimiseks ning seejärel selle lahtipakkimiseks ja väljavõtmiseks.

Loendage mittekattuvate elementide (unikaalsete elementide) arv (tüüp).

Selleks, et lugeda, mitu mittekattuvat elementi (unikaalset elementi) on loendis või tuplis (mitu tüüpi on), kasutage Counter või set(), nagu eespool kirjeldatud.

Counter-objekti elementide arv on võrdne esialgse loendi mittekattuvate elementide arvuga, mis saadakse len() abil.

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

print(len(c))
# 3

Võite kasutada ka set(), set-tüübi set konstruktorit, mis on lihtsam, kui te ei vaja Counter-objekti.

Kogumitüüp on andmetüüp, millel ei ole dubleerivaid elemente. Nimekirja üleandmine funktsioonile set() ignoreerib dubleerivaid väärtusi ja tagastab set-tüüpi objekti, mille elementidena on ainult unikaalsed väärtused. Selle tüübi elementide arvu saab len() abil.

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

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

Loendage tingimusele vastavate elementide arv.

Teatud tingimusele vastavate elementide arvu loendamiseks loendis või tuplis kasutage loendi mõistmise notatsiooni või generaatorväljendeid.

Lugege näiteks negatiivsete väärtustega elementide arv järgmise arvude loendi puhul.

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

Rakendades tingimusavaldust igale elemendile loendi mõistmise notatsioonis, saadakse loend, mille elemendid on boolused boolused (true, false). Boole'i tüüp bool on täisarvu tüübi int alamklass, kus true on 1 ja false 0. Seetõttu saab tõeväärtuste arvu (tingimusele vastavate elementide arvu) lugeda summa arvutamisega sum() abil.

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

Kui me asendame [] loendi mõistmise märkimisviisis (), saame generaatorväljendi. Nimekirja mõistmise notatsioon genereerib nimekirja kõikidest töödeldavatest elementidest, samas kui generaatorväljend töötleb elemente järjestikku ja on seetõttu mälutõhusam.

Kui generaatorväljend on ainus argument, võib () ära jätta, nii et seda saab kirjutada nagu viimasel juhul.

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

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

Kui soovite loendada valede väärtuste arvu (nende elementide arv, mis ei vasta tingimusele), kasutage not. Pange tähele, et > on kõrgema prioriteediga kui not (seda arvutatakse esimesena), seega ei ole sulgud () järgmises näites (i < 0) vajalikud.

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

Loomulikult saab tingimusi ise muuta.

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

Allpool on toodud mõned muud näited.

Näide numbrite loendi paaritute elementide arvu leidmiseks.

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

Näide stringide loendi tingimuse kohta.

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

Loendurit kasutatakse loendamiseks esinemiste arvu alusel. items() hangib tupli (element, esinemiste arv) ja esinemiste arv määrab tingimuse.

Järgnevalt on toodud näide kahe või enama esinemisega elementide väljavõttest ja esinemiste koguarvu lugemisest. Selles näites on neli a-d ja kaks c-d, kokku kuus.

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

Järgnevalt on toodud näide kahe või enama esinemisega elementide tüüpide väljavõttest ja esinemiste arvu lugemisest. Selles näites on kaks tüüpi, a ja 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

Loeb sõna esinemiste arvu stringis.

Konkreetse näitena loeme sõna esinemiste arvu stringis.

Esmalt asendage mittevajalikud komad ja punktid tühja stringiga, kasutades meetodit replace(), ja seejärel kustutage need. Seejärel kasutage meetodit split(), et luua tühikutega eraldatud nimekiri.

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

Kui saate koostada nimekirja, saate iga sõna esinemiskordade arvu, esinevate sõnade tüübid ja kollektsiooni most_common() funktsiooni collections.Counter abil saada kõige sagedamini esineva sõna.

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

Ülaltoodud protsess on väga lihtne, nii et keerulisemaks loomulikuks keeletöötluseks on parem kasutada selliseid raamatukogusid nagu NLTK.

Samuti ei saa jaapani teksti puhul kasutada split() funktsiooni teksti jagamiseks, sest puudub selge sõnade eraldamine. Selle saavutamiseks saab kasutada näiteks Janome'i raamatukogu.

Loeb tähemärgi esinemiste arvu stringis.

Kuna stringid on samuti jadatüüp, saab neid kasutada meetodiga count() või edastada argumendina konstruktorile 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})

Näide 5 kõige sagedamini esineva tähemärgi väljaselgitamisest.

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