Brojanje broja pojavljivanja svakog elementa na popisu s Pythonovim brojačem

Poslovanje

U Pythonu se broj svih elemenata na popisu ili torci može dobiti pomoću ugrađene funkcije len(), a broj svakog elementa (broj pojavljivanja svakog elementa) može se dobiti pomoću metode count() .

Osim toga, klasa Counter zbirki standardne biblioteke Python može se koristiti za dobivanje elemenata po broju pojavljivanja.

U ovom ćemo odjeljku raspravljati o sljedećem

  • Izbrojite ukupan broj elemenata:len()
  • Izbrojite broj svakog elementa (broj pojavljivanja svakog elementa):count()
  • Korištenje.collections.Counter
  • Elementi se dohvaćaju redoslijedom učestalosti pojavljivanja:most_common()
  • Prebrojite broj (vrstu) elemenata koji se ne preklapaju (jedinstveni elementi).
  • Izbrojite broj elemenata koji zadovoljavaju uvjet.

Osim toga, kao konkretan primjer, sljedeće je objašnjeno s uzorkom koda.

  • Broji broj pojavljivanja riječi u nizu.
  • Izbrojite broj pojavljivanja znaka u nizu.

Uzorak je popis, ali ista se obrada može obaviti s torkama.

Izbroji ukupan broj elemenata: len()

Za prebrojavanje ukupnog broja elemenata na popisu ili torci koristite ugrađenu funkciju len().

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

print(len(l))
# 7

Brojenje broja svakog elementa (broj pojavljivanja svakog elementa): metoda count().

Za prebrojavanje broja svakog elementa (broj pojavljivanja svakog elementa), koristite metodu count() za popise, torke itd.

Ako se kao argument prosljeđuje vrijednost koja ne postoji kao element, vraća se 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

Ako želite dobiti broj pojavljivanja svakog elementa odjednom, korisna je sljedeća zbirka.

Kako koristiti zbirke.Counter

Zbirke standardne biblioteke Python imaju klasu Counter.

Counter() je podklasa tipa rječnika dict, koja ima podatke u obliku elemenata kao ključeve i pojavljivanja kao vrijednosti.

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

Ako je element naveden kao ključ, može se dobiti broj elemenata. Ako je navedena vrijednost koja ne postoji kao element, vraća se 0.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Također možete koristiti metode tipa rječnika kao što su tipke(), vrijednosti(), stavke() 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)])

Ove metode vraćaju objekte tipa dict_keys, itd. Mogu se koristiti kao što jesu ako želite pokrenuti izraz for. Ako ga želite pretvoriti u popis, koristite list().

Dobijanje elemenata po učestalosti pojavljivanja: metoda most_common().

Brojač ima metodu most_common() koja vraća popis torki oblika (element, broj pojavljivanja) sortiranih prema broju pojavljivanja.

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

Element s najvećim brojem pojavljivanja može se dobiti navođenjem indeksa, kao što je [0] za najveći broj pojavljivanja i [-1] za najmanji broj pojavljivanja. Ako želite dobiti samo elemente ili samo broj pojavljivanja, možete dodatno odrediti 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

Ako ih želite sortirati prema opadajućem broju pojavljivanja, upotrijebite odsječak s povećanjem postavljenim na -1.

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

Ako je argument n naveden za metodu most_common(), vraća se samo n elemenata s najvećim brojem pojavljivanja. Ako je izostavljen, svi elementi.

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

Ako želite zaseban popis elemenata/pojava poredanih po broju pojavljivanja, a ne po nizu (element, broj pojavljivanja), možete ga razložiti na sljedeći način

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

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

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

Ugrađena funkcija zip() koristi se za transponiranje dvodimenzionalnog popisa (u ovom slučaju popis torki), a zatim ga raspakira i ekstrahira.

Prebrojite broj (vrstu) elemenata koji se ne preklapaju (jedinstveni elementi).

Da biste izbrojali koliko elemenata koji se ne preklapaju (jedinstveni elementi) postoji na popisu ili torci (koliko vrsta ima), koristite Counter ili set() kako je gore opisano.

Broj elemenata u objektu Counter jednak je broju elemenata koji se ne preklapaju u izvornom popisu, koji se može dobiti pomoću len().

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

print(len(c))
# 3

Također možete koristiti set(), konstruktor za set tipa skupa, što je lakše ako vam ne treba objekt Counter.

Vrsta skupa je tip podataka koji nema duplicirane elemente. Prosljeđivanje popisa u set() zanemaruje duplicirane vrijednosti i vraća objekt tipa skup sa samo jedinstvenim vrijednostima kao elementima. Broj elemenata ovog tipa dobiva se pomoću len().

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

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

Izbrojite broj elemenata koji zadovoljavaju uvjet.

Za prebrojavanje broja elemenata na popisu ili torci koji zadovoljavaju određeni uvjet, koristite zapis razumijevanja popisa ili izraze generatora.

Kao primjer, prebrojite broj elemenata s negativnim vrijednostima za sljedeći popis brojeva

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

Primjenom uvjetnog izraza na svaki element u zapisu za razumijevanje popisa dobiva se popis čiji su elementi Booleovi boolovi (true, false). Booleov tip bool je potklasa cjelobrojnog tipa int, gdje se true tretira kao 1, a false kao 0. Stoga se broj istinitih vrijednosti (broj elemenata koji zadovoljavaju uvjet) može prebrojati izračunavanjem zbroja pomoću zbroja ().

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

Zamijenimo li [] u zapisu za razumijevanje popisa s (), dobit ćemo izraz generatora. Zapis za razumijevanje popisa generira popis svih obrađenih elemenata, dok izraz generatora obrađuje elemente sekvencijalno i stoga je učinkovitiji u memoriji.

Kada je izraz generatora jedini argument, () se može izostaviti, pa se može napisati kao u potonjem slučaju.

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

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

Ako želite prebrojati broj lažnih vrijednosti (broj elemenata koji ne zadovoljavaju uvjet), upotrijebite not. Imajte na umu da > ima veći prioritet nego ne (prvi se izračunava), tako da zagrade () u (i < 0) u sljedećem primjeru nisu potrebne.

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

Naravno, sami uvjeti se mogu mijenjati.

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

Neki drugi primjeri prikazani su u nastavku.

Primjer dobivanja broja neparnih elemenata za popis brojeva.

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

Primjer uvjeta za popis nizova.

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

Brojač se koristi za brojanje na temelju broja pojavljivanja. items() dohvaća skup (element, broj pojavljivanja), a broj pojavljivanja specificira uvjet.

Slijedi primjer izdvajanja elemenata s dva ili više pojavljivanja i brojanja ukupnog broja pojavljivanja. U ovom primjeru postoje četiri a i dva c, ukupno š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

Slijedi primjer izdvajanja tipova elemenata s dva ili više pojavljivanja i brojanja broja pojavljivanja. U ovom primjeru postoje dvije vrste, a i 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

Broji broj pojavljivanja riječi u nizu.

Kao konkretan primjer, izbrojimo broj pojavljivanja riječi u nizu.

Prvo zamijenite nepotrebne zareze i točke praznim nizom pomoću metode replace(), a zatim ih izbrišite. Zatim upotrijebite metodu split() za stvaranje popisa odvojenih razmacima.

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

Ako možete napraviti popis, možete saznati koliko se puta svaka riječ pojavljuje, vrste riječi koje se pojavljuju i većina_common() zbirki. Brojač da biste dobili riječ koja se pojavljuje najviše puta.

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

Gore navedeno je vrlo jednostavan proces, pa je bolje koristiti knjižnice kao što je NLTK za složeniju obradu prirodnog jezika.

Također, u slučaju japanskog teksta, split() se ne može koristiti za cijepanje teksta jer nema jasnog odvajanja riječi. Na primjer, možete koristiti Janome biblioteku da biste to postigli.

Izbrojite broj pojavljivanja znaka u nizu.

Budući da su nizovi također vrsta sekvence, mogu se koristiti s metodom count() ili proslijediti kao argument konstruktoru zbirki.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})

Primjer dohvaćanja prvih 5 znakova koji se najčešće pojavljuju.

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