Python’s Counter ဖြင့် စာရင်းတစ်ခုရှိ ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်ခြင်း။

Python တွင်၊ ထည့်သွင်းထားသောလုပ်ဆောင်ချက် len() ကို အသုံးပြု၍ စာရင်းတစ်ခု သို့မဟုတ် tuple အတွင်းရှိ ဒြပ်စင်အားလုံး၏ အရေအတွက်ကို ရရှိနိုင်ပြီး ဒြပ်စင်တစ်ခုစီ၏ အရေအတွက် (ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပျက်မှုအရေအတွက်) ကို count() နည်းလမ်းဖြင့် ရယူနိုင်သည်။ .

ထို့အပြင်၊ Python standard library collections ၏ Counter class ကို ဖြစ်ပျက်မှု အရေအတွက်အလိုက် element များကို ရယူရန် အသုံးပြုနိုင်သည်။

ဤအပိုင်းတွင် အောက်ပါတို့ကို ဆွေးနွေးပါမည်။

• စုစုပေါင်းဒြပ်စင်အရေအတွက်ကိုရေတွက်ပါ-len()
• ဒြပ်စင်တစ်ခုစီ၏ အရေအတွက် (ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပေါ်မှု အရေအတွက်)-count()
• အသုံးပြုမှု။collections.Counter
• ဖြစ်ပျက်မှုအကြိမ်ရေအလိုက် ဒြပ်စင်များကို ပြန်လည်ရယူသည်-most_common()
• ထပ်နေသောဒြပ်စင်များ (ထူးခြားသောဒြပ်စင်များ) ၏ နံပါတ် (အမျိုးအစား) ကို ရေတွက်ပါ။
• အခြေအနေအား ကျေနပ်စေသော အစိတ်အပိုင်းအရေအတွက်ကို ရေတွက်ပါ။

ထို့အပြင်၊ ခိုင်မာသောဥပမာအနေဖြင့်၊ အောက်ပါတို့ကို နမူနာကုဒ်ဖြင့် ရှင်းပြထားသည်။

• စာကြောင်းတစ်ခုရှိ စကားလုံးတစ်လုံး၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်သည်။
• စာကြောင်းတစ်ခုရှိ ဇာတ်ကောင်တစ်ခု၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်ပါ။

နမူနာသည် စာရင်းတစ်ခုဖြစ်သော်လည်း တူညီသောလုပ်ဆောင်မှုကို tuples ဖြင့် လုပ်ဆောင်နိုင်သည်။

ဒြပ်စင်များ၏ စုစုပေါင်းအရေအတွက်ကို ရေတွက်ပါ- len()

စာရင်းတစ်ခု သို့မဟုတ် tuple တစ်ခုရှိ ဒြပ်စင်စုစုပေါင်းအရေအတွက်ကို ရေတွက်ရန် တပ်ဆင်ထားသော လုပ်ဆောင်ချက် len() ကို အသုံးပြုပါ။

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

print(len(l))
# 7

ဒြပ်စင်တစ်ခုစီ၏ အရေအတွက် (ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပေါ်မှု အရေအတွက်)- count() နည်းလမ်း

ဒြပ်စင်တစ်ခုစီ၏ အရေအတွက် (ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပျက်မှုအရေအတွက်)၊ စာရင်းများ၊ tuple စသည်တို့အတွက် count() နည်းလမ်းကို အသုံးပြုပါ။

• Common Sequence Operations — Built-in Types — Python 3.10.0 Documentation

ဒြပ်စင်တစ်ခုအနေဖြင့် မတည်ရှိသောတန်ဖိုးကို အငြင်းအခုံတစ်ခုအဖြစ် ကျော်သွားပါက 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

ဒြပ်စင်တစ်ခုစီ၏ ဖြစ်ပေါ်မှုအရေအတွက်ကို တစ်ပြိုင်နက် ရယူလိုပါက၊ အောက်ပါ စုစည်းမှု။Counter သည် အသုံးဝင်သည်။

collections.Counter အသုံးပြုနည်း

Python စံပြစာကြည့်တိုက် စုစည်းမှုများတွင် Counter အတန်းရှိသည်။

• collections – Counter — Container datatypes — Python 3.10.0 Documentation

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

ဤနည်းလမ်းများသည် dict_keys အမျိုးအစား၏ အရာဝတ္ထုများကို ပြန်ပို့ပေးသည်။ ၎င်းကို စာရင်းတစ်ခုအဖြစ် ပြောင်းလဲလိုပါက list() ကို အသုံးပြုပါ။

အသွင်အပြင်၏ ကြိမ်နှုန်းအစဉ်လိုက် အစိတ်အပိုင်းများကို ရယူခြင်း- most_common() နည်းလမ်း

ကောင်တာတွင် ဖြစ်ပျက်မှုအရေအတွက်အလိုက် စီထားသော ပုံစံ (ဒြပ်စင်၊ အကြိမ်အရေအတွက်) ၏ tuples စာရင်းကို ပြန်ပေးသည့် most_common() နည်းလမ်း ရှိသည်။

print(c.most_common())
# [('a', 4), ('c', 2), ('b', 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)]

argument n ကို most_common() method အတွက် သတ်မှတ်ထားပါက၊ ဖြစ်ပေါ်မှု အများဆုံး အရေအတွက်ရှိသော n element များကိုသာ ပြန်ပို့ပေးပါသည်။ ချန်လှပ်ထားလျှင် အစိတ်အပိုင်းအားလုံး။

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

(ဒြပ်စင်၊ ဖြစ်ပျက်မှုရေတွက်) ၏ tuple ထက် ဖြစ်ရပ်အရေအတွက်အလိုက် သီးခြားစီထားသော ဒြပ်စင်များ/ဖြစ်ပွားမှုစာရင်းကို လိုချင်ပါက အောက်ပါအတိုင်း ပြိုကွဲနိုင်သည်။

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

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

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

Built-in လုပ်ဆောင်ချက် zip() ကို နှစ်ဘက်မြင်စာရင်း (ဤကိစ္စတွင်၊ tuples စာရင်း) ကို လွှဲပြောင်းရန် အသုံးပြုပြီး ၎င်းကို ထုပ်ပိုးပြီး ဖြည်ပါ။

ထပ်နေသောဒြပ်စင်များ (ထူးခြားသောဒြပ်စင်များ) ၏ နံပါတ် (အမျိုးအစား) ကို ရေတွက်ပါ။

စာရင်းတစ်ခုတွင် ထပ်နေသောဒြပ်စင်များ (ထူးခြားသောဒြပ်စင်များ) မည်မျှရှိသည်ကို ရေတွက်ရန် သို့မဟုတ် tuple (အမျိုးအစားမည်မျှရှိသနည်း)၊ အထက်တွင်ဖော်ပြထားသည့်အတိုင်း Counter သို့မဟုတ် set() ကို အသုံးပြုပါ။

Counter အရာဝတ္ထုရှိ ဒြပ်စင်အရေအတွက်သည် len() ဖြင့်ရရှိနိုင်သည့် မူရင်းစာရင်းရှိ ထပ်နေခြင်းမရှိသောဒြပ်စင်အရေအတွက်နှင့် ညီမျှသည်။

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

print(len(c))
# 3

Counter object မလိုအပ်ပါက set type set အတွက် constructor ကိုလည်း set() ကိုသုံးနိုင်သည်။

သတ်မှတ်အမျိုးအစားသည် ထပ်နေသောဒြပ်စင်များမပါသော ဒေတာအမျိုးအစားဖြစ်သည်။ set() မှ စာရင်းတစ်ခုအား ဖြတ်သန်းခြင်းသည် မိတ္တူတန်ဖိုးများကို လျစ်လျူရှုပြီး ဒြပ်စင်များအဖြစ် သီးသန့်တန်ဖိုးများသာရှိသော သတ်မှတ်ထားသည့် အမျိုးအစားအရာဝတ္ထုကို ပြန်ပေးသည်။ ဤအမျိုးအစား၏ ဒြပ်စင်အရေအတွက်ကို len() ဖြင့် ရရှိသည်။

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

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

အခြေအနေအား ကျေနပ်စေသော အစိတ်အပိုင်းအရေအတွက်ကို ရေတွက်ပါ။

အချို့သောအခြေအနေတစ်ခုကို ကျေနပ်စေသော စာရင်းတစ်ခု သို့မဟုတ် tuple တစ်ခုရှိ ဒြပ်စင်အရေအတွက်ကို ရေတွက်ရန်၊ list comprehension notation သို့မဟုတ် generator expressions ကို အသုံးပြုပါ။

ဥပမာအနေဖြင့်၊ အောက်ပါနံပါတ်များစာရင်းအတွက် အနုတ်တန်ဖိုးများဖြင့် ဒြပ်စင်အရေအတွက်ကို ရေတွက်ပါ။

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

စာရင်းနားလည်မှု အမှတ်အသားရှိ ဒြပ်စင်တစ်ခုစီသို့ အခြေအနေအလိုက် ဖော်ပြချက်တစ်ခုကို အသုံးချခြင်းသည် Boolean bools (မှန်၊ မမှန်) ဟူသော ဒြပ်စင်များဖြစ်သည့် စာရင်းကို ထုတ်ပေးသည်။ Boolean အမျိုးအစား bool သည် ကိန်းပြည့်အမျိုးအစား int ၏ အတန်းခွဲတစ်ခုဖြစ်ပြီး true ကို 1 နှင့် false အဖြစ် 0 အဖြစ် မှတ်ယူပါသည်။ ထို့ကြောင့်၊ တန်ဖိုးများ (အခြေအနေအား ကျေနပ်စေသော ဒြပ်စင်အရေအတွက်) ကို sum ကို အသုံးပြု၍ 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

[] ကို list comprehension notation တွင် () ဖြင့် အစားထိုးပါက၊ ကျွန်ုပ်တို့သည် generator expression ကိုရရှိမည်ဖြစ်သည်။ စာရင်းနားလည်မှုအမှတ်အသားသည် လုပ်ဆောင်ပြီးသားဒြပ်စင်အားလုံး၏စာရင်းကိုထုတ်ပေးသည်၊ ဂျင်နရေတာအသုံးအနှုန်းသည် ဒြပ်စင်များကို အစဉ်လိုက်လုပ်ဆောင်ပြီး ထို့ကြောင့် မှတ်ဉာဏ်ပိုမိုထိရောက်သည်။

generator expression သည် တစ်ခုတည်းသော argument ဖြစ်သောအခါ၊ () ကို ချန်လှပ်ထားနိုင်သည်၊ ထို့ကြောင့် ၎င်းကို နောက်ဆုံး case တွင် ရေးသားနိုင်သည်။

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

ကောင်တာသည် အကြိမ်အရေအတွက်ပေါ်မူတည်၍ ရေတွက်ရန်အသုံးပြုသည်။ items() ၏ tuple (ဒြပ်စင်၊ ဖြစ်ပျက်မှု အရေအတွက်) ကို ရယူပြီး ဖြစ်ပေါ်မှု အရေအတွက်သည် အခြေအနေ ကို သတ်မှတ်သည်။

အောက်ဖော်ပြပါသည် နှစ်ခု သို့မဟုတ် ထို့ထက်ပိုသော ဖြစ်ပျက်မှုများဖြင့် အစိတ်အပိုင်းများကို ထုတ်ယူပြီး ဖြစ်ပျက်မှုစုစုပေါင်းကို ရေတွက်ခြင်း၏ ဥပမာတစ်ခုဖြစ်သည်။ ဤဥပမာတွင် a’s 4′ နှင့် two 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

စာကြောင်းတစ်ခုရှိ စကားလုံးတစ်လုံး၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်သည်။

ခိုင်မာသော ဥပမာအနေဖြင့်၊ စာကြောင်းတစ်ခုရှိ စကားလုံးတစ်လုံး၏ ဖြစ်ပေါ်မှုအရေအတွက်ကို ရေတွက်ကြည့်ကြပါစို့။

ပထမဦးစွာ အစားထိုး()နည်းလမ်းကို အသုံးပြု၍ မလိုအပ်သော ကော်မာများနှင့် အပိုင်းများကို အလွတ်စာကြောင်းဖြင့် အစားထိုးပြီး ၎င်းတို့ကို ဖျက်ပါ။ ထို့နောက် နေရာလွတ်များဖြင့် ခြားထားသော စာရင်းတစ်ခုကို ဖန်တီးရန် split() နည်းလမ်းကို အသုံးပြုပါ။

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

စာရင်းတစ်ခုပြုလုပ်နိုင်ပါက၊ စကားလုံးတစ်ခုစီပေါ်လာသည့်အကြိမ်အရေအတွက်၊ ပေါ်လာသည့်စကားလုံးအမျိုးအစားများနှင့် collections ၏အများဆုံး_အသုံးအများဆုံး() ကိုရနိုင်သည်။ အကြိမ်အများဆုံးပေါ်လာသည့်စကားလုံးကိုရရန် တန်ပြန်။

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 ကဲ့သို့သော စာကြည့်တိုက်များကို အသုံးပြုခြင်းက ပိုကောင်းပါတယ်။

• Natural Language Toolkit — NLTK 3.6.5 documentation

ထို့အပြင်၊ ဂျပန်စာသားကိစ္စတွင် ရှင်းရှင်းလင်းလင်း စကားလုံးခွဲခြားမှုမရှိသောကြောင့် စာသားကိုခွဲရန် split() ကို အသုံးမပြုနိုင်ပါ။ ဥပမာအားဖြင့်၊ သင်သည်ဤအောင်မြင်ရန် Janome စာကြည့်တိုက်ကိုသုံးနိုင်သည်။

စာကြောင်းတစ်ခုရှိ ဇာတ်ကောင်တစ်ခု၏ ဖြစ်ပျက်မှုအရေအတွက်ကို ရေတွက်ပါ။

strings များသည် sequence type တစ်ခုဖြစ်သောကြောင့်၊ ၎င်းတို့ကို count() method ဖြင့်သုံးနိုင်သည် သို့မဟုတ် collections ၏ constructor ထံသို့ argument တစ်ခုအဖြစ် ပေးပို့နိုင်ပါသည်။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})

အဖြစ်အများဆုံး ထိပ်တန်း စာလုံး ၅ လုံးကို ပြန်လည်ရယူခြင်း ဥပမာ။

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