Ngetung nomer kedadeyan saben unsur ing dhaftar karo Counter Python

Bisnis

Ing Python, nomer kabeh unsur ing dhaptar utawa tuple bisa dipikolehi kanthi nggunakake fungsi len (), lan nomer saben unsur (jumlah kedadeyan saben unsur) bisa dipikolehi kanthi nggunakake metode count (). .

Kajaba iku, kelas Counter saka Python koleksi perpustakaan standar bisa digunakake kanggo njaluk unsur ing urutan nomer kedadean.

Ing bagean iki, kita bakal ngrembug babagan ing ngisor iki

  • Hitung jumlah total unsur:len()
  • Etung nomer saben unsur (jumlah kedadeyan saben unsur):count()
  • Panganggone.collections.Counter
  • Unsur dijupuk miturut urutan frekuensi kedadeyan:most_common()
  • Etung nomer (jinis) unsur sing ora tumpang tindih (unsur unik).
  • Etung jumlah unsur sing marem kondisi.

Kajaba iku, minangka conto konkrit, ing ngisor iki diterangake kanthi kode sampel.

  • Ngetung jumlah kedadeyan tembung ing senar.
  • Etung jumlah kedadeyan karakter ing senar.

Sampel minangka dhaptar, nanging pangolahan sing padha bisa ditindakake kanthi tuple.

Hitung jumlah total unsur: len()

Kanggo count nomer total unsur ing dhaftar utawa tuple, nggunakake dibangun ing fungsi len ().

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

print(len(l))
# 7

Ngetung nomer saben unsur (jumlah kedadeyan saben unsur): count () cara

Kanggo ngetung nomer saben unsur (jumlah kedadeyan saben unsur), nggunakake cara count () kanggo dhaptar, tuple, etc.

Yen nilai sing ora ana minangka unsur diterusake minangka argumen, 0 bakal bali.

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

Yen sampeyan pengin entuk nomer kedadeyan saben unsur bebarengan, koleksi ing ngisor iki.Counter migunani.

Carane nggunakake collections.Counter

Koleksi perpustakaan standar Python duwe kelas Counter.

Counter () minangka subclass saka dict jinis kamus, sing nduweni data ing wangun unsur minangka kunci lan kedadeyan minangka nilai.

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

Yen unsur kasebut minangka kunci, jumlah unsur bisa dipikolehi. Yen nilai sing ora ana minangka unsur ditemtokake, 0 bali.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Sampeyan uga bisa nggunakake cara jinis kamus kayata tombol (), nilai (), item (), etc.

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

Cara iki bali obyek saka jinis dict_keys, etc. Padha bisa digunakake minangka yen sampeyan pengin mbukak kanggo statement. Yen sampeyan pengin Ngonversi menyang dhaftar, nggunakake dhaftar ().

Entuk unsur ing urutan frekuensi katon: paling_common () cara

Counter wis paling_common () cara, kang ngasilake dhaftar tuples wangun (unsur, nomer kedadean) diurutake miturut nomer kedadean.

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

Unsur kanthi jumlah kedadeyan paling akeh bisa dipikolehi kanthi nemtokake indeks, kayata [0] kanggo jumlah kedadeyan paling dhuwur lan [-1] kanggo jumlah kedadeyan paling sithik. Yen sampeyan pengin entuk mung unsur utawa mung jumlah kedadeyan, sampeyan bisa nemtokake indeks luwih lanjut.

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

Yen sampeyan pengin ngurutake supaya bisa nyuda jumlah kedadeyan, gunakake irisan kanthi tambahan disetel dadi -1.

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

Yen argumen n ditemtokake kanggo metode most_common (), mung unsur n kanthi jumlah kedadeyan paling dhuwur sing bakal bali. Yen diilangi, kabeh unsur.

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

Yen sampeyan pengin dhaptar unsur / kedadeyan sing kapisah miturut jumlah kedadeyan, tinimbang tuple (unsur, count kedadeyan), sampeyan bisa ngurai kaya ing ngisor iki

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

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

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

Dibangun ing fungsi zip () digunakake kanggo transpose dhaftar loro-dimensi (ing kasus iki, dhaftar tuple), lan banjur unpack lan extract.

Etung nomer (jinis) unsur sing ora tumpang tindih (unsur unik).

Kanggo count carane akeh unsur non-tumpang tindih (unsur unik) ana ing dhaftar utawa tuple (pinten jinis ana), nggunakake Counter utawa pesawat () minangka diterangake ing ndhuwur.

Jumlah unsur ing obyek Counter padha karo nomer unsur non-tumpang tindih ing dhaftar asli, kang bisa dipikolehi karo len ().

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

print(len(c))
# 3

Sampeyan uga bisa nggunakake pesawat (), konstruktor kanggo pesawat jinis pesawat, kang luwih gampang yen sampeyan ora perlu obyek Counter.

Jinis set yaiku jinis data sing ora duwe unsur duplikat. Nglirwakake dhaptar kanggo nyetel () nglirwakake duplikat nilai lan ngasilake obyek saka jinis pesawat karo mung nilai unik minangka unsur. Jumlah unsur saka jinis iki dijupuk dening len ().

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

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

Etung jumlah unsur sing marem kondisi.

Kanggo ngetung jumlah unsur ing dhaptar utawa tuple sing nyukupi kondisi tartamtu, gunakake notasi pangerten dhaptar utawa ekspresi generator.

Contone, etung nomer unsur kanthi nilai negatif kanggo dhaptar nomer ing ngisor iki

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

Nerapake ekspresi kondisional kanggo saben unsur ing notasi pangerten dhaptar ngasilake dhaptar sing unsur Boolean bools (bener, salah). Bool jinis Boolean minangka subkelas saka integer tipe integer, ing ngendi bener dianggep minangka 1 lan palsu minangka 0. Mulane, jumlah nilai bener (jumlah unsur sing nyukupi kondisi) bisa diitung kanthi ngitung jumlah nggunakake jumlah. ().

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

Yen kita ngganti [] ing notasi pangerten dhaftar karo (), kita njaluk expression generator. Notasi pangerten dhaptar ngasilake dhaptar kabeh unsur sing diproses, nalika ekspresi generator ngolah unsur kasebut kanthi urutan lan mulane luwih efisien memori.

Nalika ekspresi generator mung argumen, () bisa diilangi, supaya bisa ditulis kaya ing kasus terakhir.

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

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

Yen sampeyan pengin ngetung jumlah nilai palsu (jumlah unsur sing ora marem kondisi), gunakake ora. Elinga yen & gt; wis precedence luwih saka ora (wis diwilang pisanan), supaya kurung () ing (i & lt; 0) ing conto ing ngisor iki ora perlu.

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

Mesthi wae, kahanan kasebut bisa diganti.

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

Sawetara conto liyane ditampilake ing ngisor iki.

Conto njupuk nomer unsur aneh kanggo dhaptar nomer.

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

Conto kahanan kanggo dhaptar strings.

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

Counter digunakake kanggo ngitung adhedhasar jumlah kedadeyan. item () njupuk tuple saka (unsur, nomer kedadean), lan nomer kedadean nemtokake kondisi.

Ing ngisor iki minangka conto ngekstrak unsur kanthi rong utawa luwih kedadeyan lan ngetung gunggunge kedadeyan. Ing conto iki, ana papat a lan loro c, kanthi total enem.

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

Ing ngisor iki minangka conto ngekstrak jinis unsur kanthi rong utawa luwih kedadeyan lan ngitung jumlah kedadeyan. Ing conto iki, ana rong jinis, a lan 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

Ngetung jumlah kedadeyan tembung ing senar.

Minangka conto konkrit, ayo ngetung jumlah kedadeyan tembung ing senar.

Pisanan, ganti koma lan titik sing ora perlu nganggo senar kosong nggunakake cara ngganti (), banjur mbusak. Banjur, gunakake cara pamisah () kanggo nggawe dhaptar sing dipisahake dening spasi.

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

Yen sampeyan bisa nggawe dhaftar, sampeyan bisa njaluk nomer kaping saben tembung katon, jinis tembung sing katon, lan paling_common () koleksi.Counter kanggo njaluk tembung sing katon paling kaping.

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

Ing ndhuwur minangka proses sing gampang banget, mula luwih becik nggunakake perpustakaan kayata NLTK kanggo pangolahan basa alami sing luwih rumit.

Uga, ing kasus teks Jepang, pamisah () ora bisa digunakake kanggo pamisah teks amarga ora ana pamisah tembung sing cetha. Contone, sampeyan bisa nggunakake perpustakaan Janome kanggo entuk iki.

Etung jumlah kedadeyan karakter ing senar.

Wiwit strings uga jinis urutan, padha bisa digunakake karo count () cara utawa liwati minangka bantahan kanggo konstruktor koleksi. 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})

Conto njupuk ndhuwur 5 karakter sing paling kerep kedadean.

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