Štetje števila pojavitev vsakega elementa na seznamu s Pythonovim števcem

Posel

V Pythonu lahko število vseh elementov v seznamu ali tupleju dobite z vgrajeno funkcijo len(), število vsakega elementa (število pojavitev vsakega elementa) pa z metodo count().

Poleg tega lahko razred Counter iz zbirk standardne knjižnice Python uporabite za pridobivanje elementov po vrstnem redu glede na število pojavitev.

V tem poglavju bomo obravnavali naslednje.

  • Preštejte skupno število elementov:len()
  • Preštejte število posameznih elementov (število pojavitev posameznega elementa):count()
  • Uporaba.collections.Counter
  • Elementi se prikličejo po vrstnem redu glede na pogostost pojavljanja:most_common()
  • Preštejte število (vrsto) neprekrivajočih se elementov (edinstvenih elementov).
  • Preštejte število elementov, ki izpolnjujejo pogoj.

Poleg tega je kot konkreten primer z vzorčno kodo razloženo naslednje.

  • Prešteje število pojavitev besede v nizu.
  • Preštejte število pojavitev znaka v nizu.

Vzorec je seznam, vendar je mogoče enako obdelavo opraviti tudi s tupli.

Preštejte skupno število elementov: len()

Če želite prešteti skupno število elementov na seznamu ali v nizu, uporabite vgrajeno funkcijo len().

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

print(len(l))
# 7

Štetje števila posameznih elementov (število pojavitev posameznega elementa): metoda count()

Če želite prešteti število posameznih elementov (število pojavitev posameznega elementa), uporabite metodo count() za sezname, kupole itd.

Če je kot argument posredovana vrednost, ki ne obstaja kot element, se vrne vrednost 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

Če želite pridobiti število pojavitev vsakega elementa naenkrat, je uporaben naslednji način collection.Counter.

Kako uporabljati collections.Counter

Zbirke standardne knjižnice Python imajo razred Counter.

Counter() je podrazred slovarskega tipa dict, ki ima podatke v obliki elementov kot ključev in pojavitev kot vrednosti.

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

Če je kot ključ naveden element, je mogoče dobiti število elementov. Če je kot element navedena vrednost, ki ne obstaja, se vrne vrednost 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Uporabite lahko tudi metode tipa slovar, kot so keys(), values(), items() itd.

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

Te metode vračajo predmete tipa dict_keys itd. Uporabite jih lahko kot take, če želite zagnati stavek for. Če jih želite pretvoriti v seznam, uporabite list().

Pridobivanje elementov po pogostosti pojavljanja: metoda most_common()

Števec ima metodo most_common(), ki vrne seznam nizov v obliki (element, število pojavitev), razvrščenih po številu pojavitev.

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

Element z največjim številom pojavitev lahko dobite z navedbo indeksa, na primer [0] za največje število pojavitev in [-1] za najmanjše število pojavitev. Če želite dobiti samo elemente ali samo število pojavitev, lahko dodatno določite indeks.

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

Če jih želite razvrstiti po padajočem številu pojavitev, uporabite rezino s prirastkom, nastavljenim na -1.

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

Če je za metodo most_common() naveden argument n, se vrne samo n elementov z največjim številom pojavitev. Če ga izpustite, se vrnejo vsi elementi.

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

Če želite ločen seznam elementov in pojavitev, urejen po številu pojavitev, in ne tuple (element, število pojavitev), ga lahko razčlenite na naslednji način

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

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

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

Vgrajena funkcija zip() se uporablja za transpozicijo dvodimenzionalnega seznama (v tem primeru seznama tuplov), nato pa ga razpakira in izvleče.

Preštejte število (vrsto) neprekrivajočih se elementov (edinstvenih elementov).

Če želite prešteti, koliko neprekrivajočih se elementov (edinstvenih elementov) je na seznamu ali tuplu (koliko je tipov), uporabite Counter ali set(), kot je opisano zgoraj.

Število elementov v objektu Števec je enako številu neprekrivajočih se elementov v prvotnem seznamu, ki ga lahko dobite s funkcijo len().

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

print(len(c))
# 3

Uporabite lahko tudi set(), konstruktor za tip množice set, kar je lažje, če ne potrebujete predmeta števec.

Vrsta množice je podatkovna vrsta, ki nima podvojenih elementov. Pri posredovanju seznama funkciji set() se podvojene vrednosti ne upoštevajo in vrne se objekt tipa set, katerega elementi so samo edinstvene vrednosti. Število elementov tega tipa dobimo s funkcijo len().

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

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

Preštejte število elementov, ki izpolnjujejo pogoj.

Če želite prešteti število elementov v seznamu ali tuplu, ki izpolnjujejo določen pogoj, uporabite zapis za razumevanje seznama ali generatorske izraze.

Kot primer preštejte število elementov z negativnimi vrednostmi za naslednji seznam števil

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

Z uporabo pogojnega izraza za vsak element v zapisu za razumevanje seznama dobimo seznam, katerega elementi so logični booli (true, false). Boolovski tip bool je podrazred celoštevilskega tipa int, pri katerem se true obravnava kot 1, false pa kot 0. Zato lahko število resničnih vrednosti (število elementov, ki izpolnjujejo pogoj) preštejemo z izračunom vsote z uporabo funkcije 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

Če v zapisu za razumevanje seznama nadomestimo [] z (), dobimo generatorski izraz. Zapis za razumevanje seznama ustvari seznam vseh obdelanih elementov, generatorski izraz pa elemente obdeluje zaporedno in je zato pomnilniško učinkovitejši.

Kadar je izraz generatorja edini argument, lahko () izpustimo, tako da ga lahko zapišemo kot v zadnjem primeru.

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

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

Če želite šteti število lažnih vrednosti (število elementov, ki ne izpolnjujejo pogoja), uporabite not. Upoštevajte, da ima > večjo prednost kot not (najprej se izračuna), zato oklepaji () v (i < 0) v naslednjem primeru niso potrebni.

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

Seveda je mogoče spremeniti tudi same pogoje.

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

Nekaj drugih primerov je prikazanih v nadaljevanju.

Primer pridobivanja števila lihih elementov za seznam števil.

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

Primer pogoja za seznam nizov.

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

Števec se uporablja za štetje na podlagi števila pojavitev. funkcija items() pridobi tuple (element, število pojavitev), število pojavitev pa določa pogoj.

V nadaljevanju je prikazan primer izločanja elementov z dvema ali več pojavitvami in štetja skupnega števila pojavitev. V tem primeru so štiri črke a in dve črki c, skupaj torej šest.

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

V nadaljevanju je prikazan primer izločanja vrst elementov z dvema ali več pojavitvami in štetja števila pojavitev. V tem primeru sta dve vrsti, a in 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

Prešteje število pojavitev besede v nizu.

Kot konkreten primer preštejmo število pojavitev besede v nizu.

Nepotrebne vejice in pike najprej nadomestite s praznim nizom z metodo replace() in jih nato izbrišite. Nato z metodo split() ustvarite seznam, ločen s presledki.

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

Če lahko sestavite seznam, lahko dobite število pojavitev posamezne besede, vrste besed, ki se pojavljajo, in s funkcijo most_common() zbirke.Counter dobite besedo, ki se pojavi največkrat.

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

Zgoraj opisani postopek je zelo preprost, zato je za kompleksnejšo obdelavo naravnega jezika bolje uporabiti knjižnice, kot je NLTK.

Tudi v primeru japonskega besedila funkcije split() ni mogoče uporabiti za razdelitev besedila, ker ni jasnega ločevanja besed. Za to lahko na primer uporabite knjižnico Janome.

Preštejte število pojavitev znaka v nizu.

Ker so nizi prav tako tip zaporedja, jih lahko uporabimo z metodo count() ali jih posredujemo kot argument konstruktorju zbirke.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})

Primer iskanja petih najpogostejših znakov.

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