ការរាប់ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗនៅក្នុងបញ្ជីជាមួយ Counter របស់ Python

អាជីវកម្ម

នៅក្នុង Python ចំនួននៃធាតុទាំងអស់នៅក្នុងបញ្ជី ឬ tuple អាចទទួលបានដោយប្រើមុខងារដែលភ្ជាប់មកជាមួយ len() ហើយចំនួននៃធាតុនីមួយៗ (ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗ) អាចទទួលបានដោយប្រើវិធីសាស្ត្រ count() .

លើសពីនេះទៀត Counter class នៃការប្រមូលបណ្ណាល័យស្តង់ដារ Python អាចត្រូវបានប្រើដើម្បីទទួលបានធាតុតាមលំដាប់នៃចំនួនកើតឡើង។

នៅក្នុងផ្នែកនេះយើងនឹងពិភាក្សាដូចខាងក្រោម

  • រាប់ចំនួនធាតុសរុប៖len()
  • រាប់ចំនួនធាតុនីមួយៗ (ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗ)៖count()
  • ការប្រើប្រាស់។collections.Counter
  • ធាតុត្រូវបានទាញយកតាមលំដាប់លំដោយនៃភាពញឹកញាប់នៃការកើតឡើង៖most_common()
  • រាប់ចំនួន (ប្រភេទ) នៃធាតុមិនត្រួតស៊ីគ្នា (ធាតុតែមួយគត់) ។
  • រាប់ចំនួនធាតុដែលបំពេញលក្ខខណ្ឌ។

លើសពីនេះទៀត ជាឧទាហរណ៍ជាក់ស្តែង ខាងក្រោមនេះត្រូវបានពន្យល់ជាមួយនឹងកូដគំរូ។

  • រាប់ចំនួននៃការកើតឡើងនៃពាក្យនៅក្នុងខ្សែអក្សរមួយ។
  • រាប់ចំនួននៃការកើតឡើងនៃតួអក្សរនៅក្នុងខ្សែអក្សរមួយ។

គំរូគឺជាបញ្ជីមួយប៉ុន្តែដំណើរការដូចគ្នាអាចត្រូវបានធ្វើជាមួយ tuples ។

រាប់ចំនួនធាតុសរុប៖ len()

ដើម្បីរាប់ចំនួនសរុបនៃធាតុនៅក្នុងបញ្ជី ឬ tuple សូមប្រើមុខងារដែលភ្ជាប់មកជាមួយ len()។

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

print(len(l))
# 7

រាប់ចំនួនធាតុនីមួយៗ (ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗ)៖ រាប់() វិធីសាស្ត្រ

ដើម្បីរាប់ចំនួនធាតុនីមួយៗ (ចំនួននៃការកើតឡើងនៃធាតុនីមួយៗ) សូមប្រើវិធីសាស្ត្រ count() សម្រាប់បញ្ជី ដុំពក។ល។

ប្រសិនបើតម្លៃដែលមិនមានជាធាតុមួយត្រូវបានឆ្លងកាត់ជាអាគុយម៉ង់ 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

ប្រសិនបើអ្នកចង់ទទួលបានចំនួននៃការកើតឡើងនៃធាតុនីមួយៗក្នុងពេលតែមួយនោះ collection.Counter ខាងក្រោមមានប្រយោជន៍។

របៀបប្រើ collections.Counter

ការប្រមូលបណ្ណាល័យស្តង់ដារ Python មានថ្នាក់ Counter ។

Counter() គឺជាថ្នាក់រងនៃប្រភេទវចនានុក្រម dict ដែលមានទិន្នន័យក្នុងទម្រង់ជាធាតុជាកូនសោ និងកើតឡើងជាតម្លៃ។

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

ប្រសិនបើធាតុមួយត្រូវបានបញ្ជាក់ជាសោ នោះចំនួនធាតុអាចទទួលបាន។ ប្រសិនបើតម្លៃដែលមិនមានជាធាតុមួយត្រូវបានបញ្ជាក់នោះ 0 ត្រូវបានត្រឡប់។

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

អ្នកក៏អាចប្រើវិធីសាស្ត្រប្រភេទវចនានុក្រមដូចជា keys(), values(), items() ជាដើម។

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

វិធីសាស្រ្ដទាំងនេះត្រឡប់វត្ថុនៃប្រភេទ dict_keys ជាដើម។ ពួកវាអាចត្រូវបានប្រើដូចដែលអ្នកចង់ដំណើរការសម្រាប់សេចក្តីថ្លែងការណ៍។ ប្រសិនបើអ្នកចង់បំប្លែងវាទៅជាបញ្ជី សូមប្រើ list()។

ការទទួលបានធាតុតាមលំដាប់នៃភាពញឹកញាប់នៃរូបរាង៖ វិធីសាស្ត្រ most_common()

Counter មានវិធីសាស្រ្ត most_common() ដែលត្រឡប់បញ្ជីនៃ tuples នៃទម្រង់ (ធាតុ ចំនួននៃការកើតឡើង) តម្រៀបតាមចំនួននៃការកើតឡើង។

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

ធាតុដែលមានចំនួនកើតឡើងខ្ពស់បំផុតអាចទទួលបានដោយការបញ្ជាក់សន្ទស្សន៍ដូចជា [0] សម្រាប់ចំនួននៃការកើតឡើងខ្ពស់បំផុត និង [-1] សម្រាប់ចំនួននៃការកើតឡើងទាបបំផុត។ ប្រសិនបើអ្នកចង់ទទួលបានតែធាតុ ឬចំនួននៃការកើតឡើង អ្នកអាចបញ្ជាក់លិបិក្រមបន្ថែមទៀត។

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

ប្រសិនបើ​អ្នក​ចង់​តម្រៀប​ពួកវា​តាម​លំដាប់​នៃ​ការ​កាត់បន្ថយ​ចំនួន​កើតឡើង សូម​ប្រើ​ចំណែក​ដោយ​ការ​បង្កើន​កំណត់​ទៅ -1 ។

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

ប្រសិនបើអាគុយម៉ង់ n ត្រូវបានបញ្ជាក់សម្រាប់វិធីសាស្រ្ត most_common() នោះមានតែធាតុ n ដែលមានចំនួនកើតឡើងច្រើនបំផុតប៉ុណ្ណោះដែលត្រូវបានប្រគល់មកវិញ។ ប្រសិនបើវាត្រូវបានលុបចោល ធាតុទាំងអស់។

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

ប្រសិនបើ​អ្នក​ចង់​បាន​បញ្ជី​ដាច់ដោយឡែក​នៃ​ធាតុ/ការកើតឡើង​ដែល​បាន​តម្រៀប​តាម​ចំនួន​នៃ​ការកើតឡើង ជាជាង​ចំនួន​នៃ (ធាតុ​ចំនួន​កើតឡើង) អ្នកអាច​បំបែក​វា​ដូចខាងក្រោម

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

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

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

zip() ដែលភ្ជាប់មកជាមួយមុខងារ ត្រូវបានប្រើដើម្បីបញ្ជូនបញ្ជីពីរវិមាត្រ (ក្នុងករណីនេះ បញ្ជីនៃ tuples) ហើយបន្ទាប់មកពន្លា និងស្រង់វាចេញ។

រាប់ចំនួន (ប្រភេទ) នៃធាតុមិនត្រួតស៊ីគ្នា (ធាតុតែមួយគត់) ។

ដើម្បីរាប់ចំនួនធាតុដែលមិនត្រួតស៊ីគ្នា (ធាតុតែមួយគត់) មាននៅក្នុងបញ្ជី ឬ tuple (មានប៉ុន្មានប្រភេទ) សូមប្រើ Counter ឬ set() ដូចដែលបានពិពណ៌នាខាងលើ។

ចំនួនធាតុនៅក្នុង Counter object គឺស្មើនឹងចំនួនធាតុដែលមិនត្រួតលើគ្នានៅក្នុងបញ្ជីដើម ដែលអាចទទួលបានជាមួយ len()។

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

print(len(c))
# 3

អ្នកក៏អាចប្រើ set() constructor សម្រាប់ set type set ដែលងាយស្រួលជាង ប្រសិនបើអ្នកមិនត្រូវការ Counter object។

ប្រភេទសំណុំគឺជាប្រភេទទិន្នន័យដែលមិនមានធាតុស្ទួន។ ការបញ្ជូនបញ្ជីទៅ set() មិនអើពើនឹងតម្លៃស្ទួន ហើយត្រឡប់វត្ថុនៃប្រភេទដែលបានកំណត់ជាមួយនឹងតម្លៃតែមួយគត់ជាធាតុ។ ចំនួនធាតុនៃប្រភេទនេះត្រូវបានទទួលដោយ len() ។

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

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

រាប់ចំនួនធាតុដែលបំពេញលក្ខខណ្ឌ។

ដើម្បីរាប់ចំនួនធាតុនៅក្នុងបញ្ជី ឬ tuple ដែលបំពេញលក្ខខណ្ឌជាក់លាក់មួយ សូមប្រើការយល់ឃើញក្នុងបញ្ជី ឬកន្សោមម៉ាស៊ីនភ្លើង។

ជាឧទាហរណ៍ រាប់ចំនួនធាតុដែលមានតម្លៃអវិជ្ជមានសម្រាប់បញ្ជីលេខខាងក្រោម

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

ការ​អនុវត្ត​កន្សោម​តាម​លក្ខខណ្ឌ​ចំពោះ​ធាតុ​នីមួយៗ​ក្នុង​ការ​យល់​ដឹង​បញ្ជី​ផ្ដល់​លទ្ធផល​នូវ​បញ្ជី​ដែល​ធាតុ​របស់​វា​ជា​ប៊ូល​ប៊ូល (ពិត មិន​ពិត)។ Boolean type bool គឺជា subclass នៃ integer type int ដែល true ត្រូវបានចាត់ទុកជា 1 និង false ជា 0។ ដូច្នេះហើយ ចំនួនពិត (ចំនួនធាតុដែលបំពេញលក្ខខណ្ឌ) អាចត្រូវបានរាប់ដោយការគណនាផលបូកដោយប្រើផលបូក ( ).

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

ប្រសិន​បើ​យើង​ជំនួស [] ក្នុង​បញ្ជី​កំណត់​ចំណាំ​ការ​យល់​ដឹង​ដោយ () យើង​ទទួល​បាន​កន្សោម​ម៉ាស៊ីន​ភ្លើង។ កំណត់ចំណាំក្នុងបញ្ជីបង្កើតបញ្ជីនៃធាតុទាំងអស់ដែលបានដំណើរការ ខណៈពេលដែលកន្សោមម៉ាស៊ីនភ្លើងដំណើរការធាតុតាមលំដាប់លំដោយ ដូច្នេះហើយការចងចាំកាន់តែមានប្រសិទ្ធភាព។

នៅពេលដែលកន្សោមម៉ាស៊ីនភ្លើងគឺជាអាគុយម៉ង់តែមួយគត់ () អាចត្រូវបានលុបចោល ដូច្នេះវាអាចត្រូវបានសរសេរដូចនៅក្នុងករណីចុងក្រោយនេះ។

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

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

ប្រសិនបើអ្នកចង់រាប់ចំនួននៃតម្លៃមិនពិត (ចំនួនធាតុដែលមិនបំពេញលក្ខខណ្ឌ) សូមប្រើទេ។ ចំណាំថា > មានអាទិភាពខ្ពស់ជាងនេះ (វាត្រូវបានគណនាជាមុន) ដូច្នេះវង់ក្រចក () ក្នុង (i < 0) ក្នុងឧទាហរណ៍ខាងក្រោមគឺមិនចាំបាច់ទេ។

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

ជាការពិតណាស់លក្ខខណ្ឌខ្លួនឯងអាចត្រូវបានផ្លាស់ប្តូរ។

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

ឧទាហរណ៍មួយចំនួនផ្សេងទៀតត្រូវបានបង្ហាញខាងក្រោម។

ឧទាហរណ៍នៃការទទួលបានលេខសេសសម្រាប់បញ្ជីលេខ។

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

ឧទាហរណ៍នៃលក្ខខណ្ឌសម្រាប់បញ្ជីខ្សែអក្សរ។

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 ត្រូវបានប្រើដើម្បីរាប់ដោយផ្អែកលើចំនួននៃការកើតឡើង។ items() ទាញយក tuple នៃ (ធាតុ ចំនួននៃការកើតឡើង) ហើយចំនួននៃការកើតឡើងបញ្ជាក់លក្ខខណ្ឌ។

ខាង​ក្រោម​នេះ​គឺ​ជា​ឧទាហរណ៍​នៃ​ការ​ស្រង់​ធាតុ​ដែល​មាន​ការ​កើត​ឡើង​ពីរ​ឬ​ច្រើន​និង​រាប់​ចំនួន​សរុប​នៃ​ការ​កើត​ឡើង។ ក្នុងឧទាហរណ៍នេះ មាន a’s បួន និង c’s ពីរ សម្រាប់សរុបចំនួនប្រាំមួយ។

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

ខាង​ក្រោម​នេះ​គឺ​ជា​ឧទាហរណ៍​នៃ​ការ​ស្រង់​ចេញ​នូវ​ប្រភេទ​នៃ​ធាតុ​ដែល​មាន​ការ​កើត​ឡើង​ពីរ ឬ​ច្រើន ហើយ​រាប់​ចំនួន​ការ​កើត​ឡើង។ ក្នុងឧទាហរណ៍នេះមានពីរប្រភេទគឺ 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

រាប់ចំនួននៃការកើតឡើងនៃពាក្យនៅក្នុងខ្សែអក្សរមួយ។

ជាឧទាហរណ៍ជាក់ស្តែង ចូរយើងរាប់ចំនួននៃការកើតឡើងនៃពាក្យនៅក្នុងខ្សែអក្សរមួយ។

ដំបូង ជំនួសសញ្ញាក្បៀស និងសញ្ញាចុចដែលមិនចាំបាច់ដោយខ្សែអក្សរទទេ ដោយប្រើវិធីជំនួស() ហើយបន្ទាប់មកលុបពួកវា។ បន្ទាប់មកប្រើវិធីបំបែក() ដើម្បីបង្កើតបញ្ជីដែលបំបែកដោយដកឃ្លា។

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

ប្រសិនបើអ្នកអាចបង្កើតបញ្ជីមួយ អ្នកអាចទទួលបានចំនួនដងដែលពាក្យនីមួយៗលេចឡើង ប្រភេទនៃពាក្យដែលលេចឡើង និង most_common() នៃ collections.Counter ដើម្បីទទួលបានពាក្យដែលលេចឡើងច្រើនបំផុត។

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

ខាងលើគឺជាដំណើរការដ៏សាមញ្ញបំផុត ដូច្នេះវាជាការប្រសើរក្នុងការប្រើប្រាស់បណ្ណាល័យដូចជា NLTK សម្រាប់ដំណើរការភាសាធម្មជាតិដ៏ស្មុគស្មាញ។

ផងដែរ ក្នុងករណីអត្ថបទភាសាជប៉ុន split() មិនអាចប្រើដើម្បីបំបែកអត្ថបទបានទេ ដោយសារមិនមានការបំបែកពាក្យច្បាស់លាស់។ ជាឧទាហរណ៍ អ្នកអាចប្រើបណ្ណាល័យ Janome ដើម្បីសម្រេចបាន។

រាប់ចំនួននៃការកើតឡើងនៃតួអក្សរនៅក្នុងខ្សែអក្សរមួយ។

ដោយសារ​ខ្សែអក្សរ​ក៏​ជា​ប្រភេទ​លំដាប់​ដែរ ពួកវា​អាច​ត្រូវ​បាន​ប្រើ​ជាមួយ​នឹង​វិធីសាស្ត្រ count() ឬ​បញ្ជូន​ជា​អាគុយម៉ង់​ទៅ​អ្នក​បង្កើត​នៃ 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})

ឧទាហរណ៍នៃការទាញយកតួអក្សរកំពូល 5 ដែលកើតឡើងញឹកញាប់បំផុត។

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