Počítanie počtu výskytov jednotlivých prvkov v zozname pomocou funkcie Counter jazyka Python

obchodné

V jazyku Python možno počet všetkých prvkov v zozname alebo tuple získať pomocou vstavanej funkcie len() a počet jednotlivých prvkov (počet výskytov každého prvku) možno získať pomocou metódy count().

Okrem toho možno na získanie prvkov v poradí podľa počtu výskytov použiť triedu Counter zo štandardných kolekcií knižnice Python.

V tejto časti sa budeme zaoberať týmito otázkami

  • Spočítajte celkový počet prvkov:len()
  • Spočítajte počet jednotlivých prvkov (počet výskytov jednotlivých prvkov):count()
  • Použitie.collections.Counter
  • Prvky sa vyhľadávajú v poradí podľa frekvencie výskytu:most_common()
  • Spočítajte počet (typ) neprekrývajúcich sa prvkov (jedinečných prvkov).
  • Spočítajte počet prvkov, ktoré spĺňajú podmienku.

Okrem toho je ako konkrétny príklad vysvetlený nasledujúci postup so vzorovým kódom.

  • Spočíta počet výskytov slova v reťazci.
  • Spočíta počet výskytov znaku v reťazci.

Ukážka je zoznam, ale rovnaké spracovanie sa dá vykonať aj s kôpkami.

Spočítajte celkový počet prvkov: len()

Ak chcete spočítať celkový počet prvkov v zozname alebo tuple, použite vstavanú funkciu len().

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

print(len(l))
# 7

Počítanie počtu jednotlivých prvkov (počet výskytov jednotlivých prvkov): metóda count()

Ak chcete spočítať počet jednotlivých prvkov (počet výskytov každého prvku), použite metódu count() pre zoznamy, tuply atď.

Ak sa ako argument odovzdá hodnota, ktorá ako prvok neexistuje, vráti sa 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

Ak chcete získať počet výskytov každého prvku naraz, je užitočná nasledujúca funkcia collection.Counter.

Ako používať collections.Counter

V kolekciách štandardnej knižnice Python sa nachádza trieda Counter.

Čítač() je podtriedou slovníkového typu dict, ktorý má údaje vo forme prvkov ako kľúčov a výskytov ako hodnôt.

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

Ak je prvok zadaný ako kľúč, možno získať počet prvkov. Ak je ako prvok zadaná hodnota, ktorá neexistuje, vráti sa 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Môžete tiež použiť metódy typu slovník, ako sú keys(), values(), items() atď.

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

Tieto metódy vracajú objekty typu dict_keys atď. Môžu sa použiť tak, ako sú, ak chcete spustiť príkaz for. Ak ich chcete previesť na zoznam, použite list().

Získanie prvkov v poradí podľa frekvencie výskytu: metóda most_common()

Čítač má metódu most_common(), ktorá vráti zoznam kôpok v tvare (prvok, počet výskytov) zoradených podľa počtu výskytov.

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

Prvok s najvyšším počtom výskytov možno získať zadaním indexu, napríklad [0] pre najvyšší počet výskytov a [-1] pre najnižší počet výskytov. Ak chcete získať len prvky alebo len počet výskytov, môžete index špecifikovať ďalej.

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

Ak ich chcete zoradiť podľa klesajúceho počtu výskytov, použite rez s prírastkom nastaveným na -1.

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

Ak je pre metódu most_common() zadaný argument n, vráti sa len n prvkov s najvyšším počtom výskytov. Ak je vynechaný, zobrazia sa všetky prvky.

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

Ak chcete samostatný zoznam prvkov\výskytov usporiadaný podľa počtu výskytov, a nie tuple (prvok, počet výskytov), môžete ho rozložiť takto

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

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

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

Vstavaná funkcia zip() sa používa na transpozíciu dvojrozmerného zoznamu (v tomto prípade zoznamu tuplov) a jeho následné rozbalenie a extrakciu.

Spočítajte počet (typ) neprekrývajúcich sa prvkov (jedinečných prvkov).

Ak chcete spočítať, koľko neprekrývajúcich sa prvkov (jedinečných prvkov) sa nachádza v zozname alebo tuple (koľko typov existuje), použite funkciu Counter alebo set(), ako je opísané vyššie.

Počet prvkov v objekte Counter sa rovná počtu neprekrývajúcich sa prvkov v pôvodnom zozname, ktorý možno získať pomocou funkcie len().

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

print(len(c))
# 3

Môžete tiež použiť set(), konštruktor pre typ set, čo je jednoduchšie, ak nepotrebujete objekt Counter.

Typ množiny je dátový typ, ktorý nemá duplicitné prvky. Pri odovzdaní zoznamu funkcii set() sa duplicitné hodnoty ignorujú a vráti sa objekt typu set, ktorého prvkami sú len jedinečné hodnoty. Počet prvkov tohto typu sa získava pomocou funkcie len().

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

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

Spočítajte počet prvkov, ktoré spĺňajú podmienku.

Ak chcete spočítať počet prvkov v zozname alebo tuple, ktoré spĺňajú určitú podmienku, použite zápis porozumenia zoznamu alebo generátorové výrazy.

Ako príklad spočítajte počet prvkov so zápornými hodnotami pre nasledujúci zoznam čísel

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

Aplikovaním podmienkového výrazu na každý prvok v zápise porozumenia zoznamu získame zoznam, ktorého prvkami sú logické booly (true, false). Boolovský typ bool je podtriedou celočíselného typu int, kde sa true považuje za 1 a false za 0. Počet pravdivých hodnôt (počet prvkov, ktoré spĺňajú podmienku) sa preto dá spočítať výpočtom súčtu pomocou funkcie 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

Ak nahradíme [] v zápise chápania zoznamu za (), dostaneme generátorový výraz. Zápis porozumenia zoznamu generuje zoznam všetkých spracovaných prvkov, zatiaľ čo generátorový výraz spracúva prvky postupne, a preto je pamäťovo efektívnejší.

Ak je generátorový výraz jediným argumentom, () sa môže vynechať, takže ho možno zapísať ako v druhom prípade.

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

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

Ak chcete spočítať počet nepravdivých hodnôt (počet prvkov, ktoré nespĺňajú podmienku), použite not. Všimnite si, že > má vyššiu prioritu ako not (počíta sa ako prvé), takže zátvorky () v (i < 0) v nasledujúcom príklade nie sú potrebné.

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

Samozrejme, samotné podmienky sa dajú zmeniť.

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

Niektoré ďalšie príklady sú uvedené nižšie.

Príklad získania počtu nepárnych prvkov pre zoznam čísel.

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

Príklad podmienky pre zoznam reťazcov.

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

Čítač sa používa na počítanie na základe počtu výskytov. items() získava tuple (prvok, počet výskytov) a počet výskytov určuje podmienku.

Nasleduje príklad extrakcie prvkov s dvoma alebo viacerými výskytmi a spočítanie celkového počtu výskytov. V tomto príklade sú štyri a a dve c, spolu šesť.

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

Nasleduje príklad extrakcie typov prvkov s dvoma alebo viacerými výskytmi a počítanie počtu výskytov. V tomto príklade sú dva typy, a 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

Spočíta počet výskytov slova v reťazci.

Ako konkrétny príklad uveďme počet výskytov slova v reťazci.

Najprv nahraďte nepotrebné čiarky a bodky prázdnym reťazcom pomocou metódy replace() a potom ich odstráňte. Potom pomocou metódy split() vytvorte zoznam oddelený medzerami.

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

Ak dokážete vytvoriť zoznam, môžete získať počet výskytov jednotlivých slov, typy slov, ktoré sa v ňom vyskytujú, a pomocou funkcie most_common() funkcie collections.Counter získať slovo, ktoré sa v ňom vyskytuje najčastejšie.

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

Uvedený postup je veľmi jednoduchý, preto je lepšie používať knižnice, ako je NLTK, na zložitejšie spracovanie prirodzeného jazyka.

V prípade japonského textu sa na rozdelenie textu nedá použiť funkcia split(), pretože nie je možné jasne oddeliť slová. Na dosiahnutie tohto cieľa môžete použiť napríklad knižnicu Janome.

Spočíta počet výskytov znaku v reťazci.

Keďže reťazce sú tiež typom sekvencie, možno ich použiť pomocou metódy count() alebo ich odovzdať ako argument konštruktoru metódy 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})

Príklad načítania 5 najčastejšie sa vyskytujúcich 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