Python හි, ලැයිස්තුවක හෝ tuple හි ඇති සියලුම මූලද්රව්ය සංඛ්යාව len() යන බිල්ට් ශ්‍රිතය භාවිතයෙන් ලබා ගත හැකි අතර, එක් එක් මූලද්‍රව්‍යයේ සංඛ්යාව (එක් එක් මූලද්‍රව්‍යයේ ඇති වන සංඛ්යාව) ගණන්() ක්රමය භාවිතයෙන් ලබා ගත හැක. .
මීට අමතරව, Python සම්මත පුස්තකාල එකතුවෙහි Counter class එක මගින් සිද්ධි සංඛ්යාව අනුව මූලද්රව්ය ලබා ගත හැක.
මෙම කොටසේදී අපි පහත සඳහන් කරුණු සාකච්ඡා කරමු
- සම්පූර්ණ මූලද්රව්ය ගණන ගණන් කරන්න:
len() - එක් එක් මූලද්රව්ය ගණන ගණන් කරන්න (එක් එක් මූලද්‍රව්‍යයේ සිදුවීම් ගණන):
count() - භාවිතය.
collections.Counter - සිදුවීමේ වාර ගණන අනුව මූලද්රව්ය ලබා ගනී:
most_common() - අතිච්ඡාදනය නොවන මූලද්රව්ය (අද්විතීය මූලද්රව්ය) සංඛ්යාව (වර්ගය) ගණන් කරන්න.
- කොන්දේසිය තෘප්තිමත් කරන මූලද්රව්ය සංඛ්යාව ගණන් කරන්න.
ඊට අමතරව, සංයුක්ත උදාහරණයක් ලෙස, නියැදි කේතය සමඟ පහත විස්තර කර ඇත.
- තන්තුවක වචනයක සිදුවීම් ගණන ගණන් කරයි.
- තන්තුවක අක්ෂරයක සිදුවීම් ගණන ගණන් කරන්න.
නියැදිය ලැයිස්තුවකි, නමුත් එම සැකසුම් ටියුපල් සමඟ සිදු කළ හැකිය.
- මුළු මූලද්රව්ය ගණන ගණන් කරන්න: len()
- එක් එක් මූලද්‍රව්‍යයේ සංඛ්යාව ගණනය කිරීම (එක් එක් මූලද්‍රව්‍යයේ සිදුවීම් ගණන): ගණන් () ක්රමය
- එකතු කිරීම් භාවිතා කරන්නේ කෙසේද. කවුන්ටරය
- පෙනුමේ සංඛ්යාතය අනුව මූලද්රව්ය ලබා ගැනීම: most_common() ක්රමය
- අතිච්ඡාදනය නොවන මූලද්රව්ය (අද්විතීය මූලද්රව්ය) සංඛ්යාව (වර්ගය) ගණන් කරන්න.
- කොන්දේසිය තෘප්තිමත් කරන මූලද්රව්ය සංඛ්යාව ගණන් කරන්න.
- තන්තුවක වචනයක සිදුවීම් ගණන ගණන් කරයි.
- තන්තුවක අක්ෂරයක සිදුවීම් ගණන ගණන් කරන්න.
මුළු මූලද්රව්ය ගණන ගණන් කරන්න: len()
ලැයිස්තුවක හෝ ටපල් එකක ඇති මුලද්‍රව්‍ය ගණන ගණනය කිරීමට, len() යන බිල්ට් ශ්‍රිතය භාවිතා කරන්න.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
print(len(l))
# 7
එක් එක් මූලද්‍රව්‍යයේ සංඛ්යාව ගණනය කිරීම (එක් එක් මූලද්‍රව්‍යයේ සිදුවීම් ගණන): ගණන් () ක්රමය
එක් එක් මූලද්‍රව්‍යයේ සංඛ්යාව (එක් එක් මූලද්‍රව්‍යයේ සිදුවන සංඛ්යාව) ගණන් කිරීමට, ලැයිස්තු, ටූපල් ආදිය සඳහා ගණන් () ක්රමය භාවිතා කරන්න.
මූලද්‍රව්‍යයක් ලෙස නොපවතින අගයක් තර්කයක් ලෙස සම්මත කළහොත් 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
ඔබට එක් එක් මූලද්‍රව්‍යයේ සිදුවීම් ගණන එකවර ලබා ගැනීමට අවශ්‍ය නම්, පහත එකතුව. කවුන්ටරය ප්‍රයෝජනවත් වේ.
එකතු කිරීම් භාවිතා කරන්නේ කෙසේද. කවුන්ටරය
Python සම්මත පුස්තකාල එකතුවෙහි Counter class එකක් ඇත.
Counter() යනු මූලද්රව්ය ආකාරයෙන් දත්ත යතුරු ලෙසත් සිද්ධීන් අගයන් ලෙසත් ඇති ශබ්ද කෝෂ වර්ගයේ ආඥාවෙහි උප පංතියකි.
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() ක්රමය
කවුන්ටරය සතුව වඩාත්_සාමාන්‍ය() ක්රමය ඇත, එය සිදුවීම් ගණන අනුව වර්ග කරන ලද පෝරමයේ (මූලද්‍රව්‍යය, සිදුවීම් ගණන) ටියුපල් ලැයිස්තුවක් ලබා දෙයි.
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 තර්කය නියම කර ඇත්නම්, වැඩිම සිදුවීම් සංඛ්‍යාවක් ඇති 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() ශ්‍රිතය ද්විමාන ලැයිස්තුවක් (මෙම අවස්ථාවේදී, ටියුපල් ලැයිස්තුවක්) ප්‍රතිවර්තනය කිරීමට භාවිතා කරයි, ඉන්පසු එය අසුරා උපුටා ගැනීම.
අතිච්ඡාදනය නොවන මූලද්රව්ය (අද්විතීය මූලද්රව්ය) සංඛ්යාව (වර්ගය) ගණන් කරන්න.
ලැයිස්තුවක හෝ ටුපල් (වර්ග කීයක් තිබේද) අතිච්ඡාදනය නොවන මූලද්රව්ය (අද්විතීය මූලද්රව්ය) කීයක් තිබේද යන්න ගණනය කිරීමට, ඉහත විස්තර කර ඇති පරිදි කවුන්ටරය හෝ කට්ටලය() භාවිතා කරන්න.
කවුන්ටර වස්තුවේ ඇති මූලද්රව්ය ගණන len() සමඟින් ලබාගත හැකි මුල් ලැයිස්තුවේ ඇති අතිච්ඡාදනය නොවන මූලද්රව්ය ගණනට සමාන වේ.
l = ['a', 'a', 'a', 'a', 'b', 'c', 'c']
c = collections.Counter(l)
print(len(c))
# 3
ඔබට ප්‍රතිවිරෝධී වස්තුවක් අවශ්‍ය නොවන්නේ නම්, කට්ටල වර්ග කට්ටලය සඳහා කන්ස්ට්‍රක්ටරය වන set(), භාවිතා කළ හැක.
කට්ටල වර්ගය යනු අනුපිටපත් මූලද්රව්ය නොමැති දත්ත වර්ගයකි. set() වෙත ලැයිස්තුවක් පසු කිරීමෙන් අනුපිටපත් අගයන් නොසලකා හරින අතර මූලද්රව්ය ලෙස අනන්‍ය අගයන් පමණක් ඇති ආකාරයේ වස්තුවක් ආපසු ලබා දේ. මෙම වර්ගයේ මූලද්රව්ය සංඛ්යාව len() මගින් ලබා ගනී.
print(set(l))
# {'a', 'c', 'b'}
print(len(set(l)))
# 3
කොන්දේසිය තෘප්තිමත් කරන මූලද්රව්ය සංඛ්යාව ගණන් කරන්න.
යම් කොන්දේසියක් තෘප්තිමත් කරන ලැයිස්තුවක හෝ ටියුපල්වල ඇති මූලද්රව්ය ගණන ගණනය කිරීමට, ලැයිස්තු අවබෝධතා අංකනය හෝ උත්පාදක ප්‍රකාශන භාවිතා කරන්න.
උදාහරණයක් ලෙස, පහත සංඛ්‍යා ලැයිස්තුව සඳහා සෘණ අගයන් සහිත මූලද්රව්ය ගණන ගණන් කරන්න
l = list(range(-5, 6))
print(l)
# [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
ලැයිස්තු අවබෝධතා අංකනයේ එක් එක් මූලද්රව්ය සඳහා කොන්දේසි සහිත ප්‍රකාශනයක් යෙදීමෙන් බූලියන් බූල් (සත්‍ය, අසත්‍ය) මූලද්රව්ය ලැයිස්තුවක් ලැබේ. Boolean වර්ගයේ bool යනු පූර්ණ සංඛ්‍යා වර්ගයේ int හි උප පංතියකි, එහිදී true 1 ලෙසත් අසත්‍යය 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
සිදුවීම් ගණන අනුව ගණන් කිරීමට කවුන්ටරය භාවිතා කරයි. අයිතම() මගින් (මූලද්රව්ය, සිද්ධි ගණන) ටියුපල් ලබා ගනී, සහ සිදුවීම් සංඛ්යාව කොන්දේසිය නියම කරයි.
පහත දැක්වෙන්නේ සිදුවීම් දෙකක් හෝ වැඩි ගණනක් සහිත මූලද්රව්ය නිස්සාරණය කිරීම සහ සම්පූර්ණ සිදුවීම් ගණන ගණනය කිරීම සඳහා උදාහරණයකි. මෙම උදාහරණයේ, a හතරක් සහ c දෙකක් ඇත, මුළු හයක් සඳහා.
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']
ඔබට ලැයිස්තුවක් සෑදිය හැකි නම්, ඔබට එක් එක් වචනය දිස්වන වාර ගණන, දිස්වන වචන වර්ග සහ වැඩිපුරම_පොදු() එකතු කිරීම් ලබා ගත හැක. වැඩිම වාර ගණනක් දිස්වන වචනය ලබා ගැනීමට 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 පුස්තකාලය භාවිතා කළ හැකිය.
තන්තුවක අක්ෂරයක සිදුවීම් ගණන ගණන් කරන්න.
තන්තු ද අනුක්‍රමික වර්ගයක් වන බැවින්, ඒවා ගණන්() ක්රමය සමඟ භාවිතා කළ හැකිය, නැතහොත් එකතු කිරීම් වල නිර්මාපකයා වෙත තර්කයක් ලෙස යැවිය හැක.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')
