Mengira bilangan kejadian setiap elemen dalam senarai dengan Python’s Counter

Perniagaan

Dalam Python, bilangan semua elemen dalam senarai atau tupel boleh diperoleh menggunakan fungsi terbina dalam len(), dan bilangan setiap elemen (bilangan kejadian setiap elemen) boleh diperoleh menggunakan kaedah count() .

Di samping itu, kelas Counter koleksi perpustakaan standard Python boleh digunakan untuk mendapatkan elemen mengikut urutan bilangan kejadian.

Dalam bahagian ini, kita akan membincangkan perkara berikut

  • Kira jumlah bilangan elemen:len()
  • Kira bilangan setiap elemen (bilangan kejadian setiap elemen):count()
  • Penggunaan.collections.Counter
  • Elemen diambil mengikut urutan kekerapan kejadian:most_common()
  • Kira bilangan (jenis) elemen tidak bertindih (elemen unik).
  • Kira bilangan unsur yang memenuhi syarat.

Di samping itu, sebagai contoh konkrit, berikut dijelaskan dengan kod sampel.

  • Mengira bilangan kemunculan perkataan dalam rentetan.
  • Kira bilangan kemunculan aksara dalam rentetan.

Sampel ialah senarai, tetapi pemprosesan yang sama boleh dilakukan dengan tupel.

Kira jumlah bilangan elemen: len()

Untuk mengira jumlah bilangan elemen dalam senarai atau tupel, gunakan fungsi terbina dalam len().

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

print(len(l))
# 7

Mengira bilangan setiap elemen (bilangan kejadian setiap elemen): kaedah count().

Untuk mengira bilangan setiap elemen (bilangan kejadian setiap elemen), gunakan kaedah count() untuk senarai, tupel, dsb.

Jika nilai yang tidak wujud sebagai elemen diluluskan sebagai hujah, 0 dikembalikan.

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

Jika anda ingin mendapatkan bilangan kejadian setiap elemen sekali gus, koleksi berikut. Kaunter berguna.

Cara menggunakan koleksi.Kaunter

Koleksi perpustakaan standard Python mempunyai kelas Counter.

Counter() ialah subkelas jenis kamus dict, yang mempunyai data dalam bentuk elemen sebagai kunci dan kejadian sebagai 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

Jika elemen dinyatakan sebagai kunci, bilangan elemen boleh diperolehi. Jika nilai yang tidak wujud sebagai elemen ditentukan, 0 dikembalikan.

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

Anda juga boleh menggunakan kaedah jenis kamus seperti kekunci(), nilai(), item(), dsb.

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

Kaedah ini mengembalikan objek jenis dict_keys, dsb. Ia boleh digunakan seolah-olah anda ingin menjalankan pernyataan for. Jika anda ingin menukarnya kepada senarai, gunakan list().

Mendapatkan elemen mengikut urutan kekerapan penampilan: kaedah most_common().

Counter mempunyai kaedah most_common(), yang mengembalikan senarai tupel bentuk (elemen, bilangan kejadian) diisih mengikut bilangan kejadian.

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

Unsur dengan bilangan kejadian tertinggi boleh diperolehi dengan menentukan indeks, seperti [0] untuk bilangan kejadian tertinggi dan [-1] untuk bilangan kejadian terendah. Jika anda ingin mendapatkan hanya elemen atau hanya bilangan kejadian, anda boleh menentukan indeks dengan lebih 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

Jika anda ingin mengisihnya mengikut urutan mengurangkan bilangan kejadian, gunakan kepingan dengan kenaikan ditetapkan kepada -1.

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

Jika hujah n ditentukan untuk kaedah most_common(), hanya elemen n dengan bilangan kejadian tertinggi dikembalikan. Jika ia ditinggalkan, semua elemen.

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

Jika anda mahukan senarai elemen/kejadian yang berasingan disusun mengikut bilangan kejadian, dan bukannya satu tuple (elemen, kiraan kejadian), anda boleh menguraikannya seperti berikut

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

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

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

Fungsi terbina dalam zip() digunakan untuk menukar senarai dua dimensi (dalam kes ini, senarai tupel), dan kemudian membongkar dan mengekstraknya.

Kira bilangan (jenis) elemen tidak bertindih (elemen unik).

Untuk mengira berapa banyak elemen tidak bertindih (elemen unik) yang terdapat dalam senarai atau tuple (berapa banyak jenis yang ada), gunakan Counter atau set() seperti yang diterangkan di atas.

Bilangan elemen dalam objek Counter adalah sama dengan bilangan elemen tidak bertindih dalam senarai asal, yang boleh diperoleh dengan len().

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

print(len(c))
# 3

Anda juga boleh menggunakan set(), pembina untuk set jenis set, yang lebih mudah jika anda tidak memerlukan objek Counter.

Jenis set ialah jenis data yang tidak mempunyai unsur pendua. Melepasi senarai ke set() mengabaikan nilai pendua dan mengembalikan objek jenis set dengan hanya nilai unik sebagai elemen. Bilangan unsur jenis ini diperolehi oleh len().

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

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

Kira bilangan unsur yang memenuhi syarat.

Untuk mengira bilangan elemen dalam senarai atau tuple yang memenuhi syarat tertentu, gunakan tatatanda pemahaman senarai atau ungkapan penjana.

Sebagai contoh, kira bilangan elemen dengan nilai negatif untuk senarai nombor berikut

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

Menggunakan ungkapan bersyarat pada setiap elemen dalam tatatanda pemahaman senarai menghasilkan senarai yang elemennya ialah bool Boolean (benar, palsu). Bool jenis Boolean ialah subkelas jenis integer int, di mana benar dianggap sebagai 1 dan palsu sebagai 0. Oleh itu, bilangan nilai benar (bilangan elemen yang memenuhi syarat) boleh dikira dengan mengira jumlah menggunakan 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

Jika kita menggantikan [] dalam tatatanda pemahaman senarai dengan (), kita mendapat ungkapan penjana. Notasi pemahaman senarai menjana senarai semua elemen yang diproses, manakala ekspresi penjana memproses elemen secara berurutan dan oleh itu lebih cekap memori.

Apabila ungkapan penjana adalah satu-satunya hujah, () boleh ditinggalkan, jadi ia boleh ditulis seperti dalam kes kedua.

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

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

Jika anda ingin mengira bilangan nilai palsu (bilangan elemen yang tidak memenuhi syarat), gunakan jangan. Ambil perhatian bahawa > mempunyai keutamaan yang lebih tinggi daripada tidak (ia dikira dahulu), jadi tanda kurungan () dalam (i < 0) dalam contoh berikut tidak diperlukan.

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

Sudah tentu, syarat itu sendiri boleh diubah.

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

Beberapa contoh lain ditunjukkan di bawah.

Contoh mendapatkan bilangan elemen ganjil untuk senarai nombor.

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

Contoh syarat untuk senarai rentetan.

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

Pembilang digunakan untuk mengira berdasarkan bilangan kejadian. items() mendapatkan semula tuple (elemen, bilangan kejadian), dan bilangan kejadian menentukan keadaan.

Berikut ialah contoh mengekstrak unsur dengan dua atau lebih kejadian dan mengira jumlah bilangan kejadian. Dalam contoh ini, terdapat empat a dan dua c, dengan jumlah enam.

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

Berikut ialah contoh mengekstrak jenis unsur dengan dua atau lebih kejadian dan mengira bilangan kejadian. Dalam contoh ini, terdapat dua jenis, a dan 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

Mengira bilangan kemunculan perkataan dalam rentetan.

Sebagai contoh konkrit, mari kita mengira bilangan kemunculan perkataan dalam rentetan.

Mula-mula, gantikan koma dan noktah yang tidak perlu dengan rentetan kosong menggunakan kaedah replace(), dan kemudian padamkannya. Kemudian, gunakan kaedah split() untuk membuat senarai yang dipisahkan oleh ruang.

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

Jika anda boleh membuat senarai, anda boleh mendapatkan bilangan kali setiap perkataan muncul, jenis perkataan yang muncul dan koleksi paling_biasa(). Kaunter untuk mendapatkan perkataan yang paling kerap muncul.

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

Di atas adalah proses yang sangat mudah, jadi lebih baik menggunakan perpustakaan seperti NLTK untuk pemprosesan bahasa semula jadi yang lebih kompleks.

Juga, dalam kes teks Jepun, split() tidak boleh digunakan untuk membelah teks kerana tiada pemisahan perkataan yang jelas. Sebagai contoh, anda boleh menggunakan perpustakaan Janome untuk mencapai ini.

Kira bilangan kemunculan aksara dalam rentetan.

Oleh kerana rentetan juga merupakan jenis jujukan, ia boleh digunakan dengan kaedah count() atau diluluskan sebagai hujah kepada pembina 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})

Contoh mendapatkan semula 5 aksara teratas yang paling kerap muncul.

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