पाइथनको काउन्टरको साथ सूचीमा प्रत्येक तत्वको घटनाहरूको संख्या गणना गर्दै

पाइथनमा, बिल्ट-इन प्रकार्य len() प्रयोग गरेर सूची वा टपलमा भएका सबै तत्वहरूको संख्या प्राप्त गर्न सकिन्छ, र प्रत्येक तत्वको संख्या (प्रत्येक तत्वको घटनाहरूको संख्या) गणना() विधि प्रयोग गरेर प्राप्त गर्न सकिन्छ। ।

थप रूपमा, पाइथन मानक पुस्तकालय संग्रहहरूको काउन्टर वर्ग घटनाहरूको संख्याको क्रममा तत्वहरू प्राप्त गर्न प्रयोग गर्न सकिन्छ।

यस खण्डमा, हामी निम्न छलफल गर्नेछौं

• तत्वहरूको कुल संख्या गणना गर्नुहोस्:len()
• प्रत्येक तत्वको संख्या गणना गर्नुहोस् (प्रत्येक तत्वको घटनाहरूको संख्या):count()
• प्रयोग।collections.Counter
• घटनाको आवृत्तिको क्रममा तत्वहरू प्राप्त गरिन्छ:most_common()
• गैर-ओभरल्यापिङ तत्वहरू (अद्वितीय तत्वहरू) को संख्या (प्रकार) गणना गर्नुहोस्।
• सर्त पूरा गर्ने तत्वहरूको संख्या गणना गर्नुहोस्।

थप रूपमा, ठोस उदाहरणको रूपमा, निम्नलाई नमूना कोडको साथ व्याख्या गरिएको छ।

• स्ट्रिङमा शब्दको घटनाहरूको सङ्ख्या गणना गर्छ।
• स्ट्रिङमा क्यारेक्टरको घटनाहरूको संख्या गणना गर्नुहोस्।

नमूना एक सूची हो, तर समान प्रशोधन tuples संग गर्न सकिन्छ।

तत्वहरूको कुल संख्या गणना गर्नुहोस्: len()

सूची वा टपलमा तत्वहरूको कुल संख्या गणना गर्न, निर्मित प्रकार्य len() प्रयोग गर्नुहोस्।

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

print(len(l))
# 7

प्रत्येक तत्वको संख्या गणना गर्दै (प्रत्येक तत्वको घटनाहरूको संख्या): गणना() विधि

प्रत्येक तत्वको संख्या (प्रत्येक तत्वको घटनाहरूको संख्या) गणना गर्न, सूचीहरू, टपलहरू, आदिका लागि गणना() विधि प्रयोग गर्नुहोस्।

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

यदि तत्वको रूपमा अवस्थित नभएको मानलाई तर्कको रूपमा पारित गरियो भने, ० फर्काइन्छ।

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

यदि तपाइँ एकैचोटि प्रत्येक तत्वको घटनाहरूको संख्या प्राप्त गर्न चाहनुहुन्छ भने, निम्न संग्रह। काउन्टर उपयोगी छ।

संग्रहहरू कसरी प्रयोग गर्ने। काउन्टर

पाइथन मानक पुस्तकालय संग्रहमा काउन्टर वर्ग छ।

• 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

यदि एक तत्व कुञ्जीको रूपमा निर्दिष्ट गरिएको छ भने, तत्वहरूको संख्या प्राप्त गर्न सकिन्छ। यदि तत्वको रूपमा अवस्थित नभएको मान निर्दिष्ट गरिएको छ भने, ० फर्काइन्छ।

print(c['a'])
# 4

print(c['b'])
# 1

print(c['c'])
# 2

print(c['d'])
# 0

तपाईले शब्दकोश प्रकारका विधिहरू पनि प्रयोग गर्न सक्नुहुन्छ जस्तै कुञ्जी(), मान(), वस्तु(), आदि।

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, आदि प्रकारका वस्तुहरू फर्काउँछन्। यदि तपाइँ स्टेटमेन्टको लागि चलाउन चाहनुहुन्छ भने तिनीहरू प्रयोग गर्न सकिन्छ। यदि तपाइँ यसलाई सूचीमा रूपान्तरण गर्न चाहनुहुन्छ भने, सूची () प्रयोग गर्नुहोस्।

उपस्थितिको आवृत्तिको क्रममा तत्वहरू प्राप्त गर्दै: most_common() विधि

काउन्टरमा 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 लाई 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() दुई-आयामी सूची ट्रान्सपोज गर्न प्रयोग गरिन्छ (यस अवस्थामा, ट्युपलहरूको सूची), र त्यसपछि यसलाई अनप्याक गर्नुहोस् र निकाल्नुहोस्।

गैर-ओभरल्यापिङ तत्वहरू (अद्वितीय तत्वहरू) को संख्या (प्रकार) गणना गर्नुहोस्।

सूची वा टुपलमा कतिवटा गैर-ओभरल्यापिङ तत्वहरू (अद्वितीय तत्वहरू) छन् गणना गर्न (त्यहाँ कति प्रकारहरू छन्), माथि वर्णन गरिए अनुसार काउन्टर वा सेट() प्रयोग गर्नुहोस्।

काउन्टर वस्तुमा तत्वहरूको संख्या मूल सूचीमा गैर-ओभरल्यापिङ तत्वहरूको संख्या बराबर छ, जुन len() सँग प्राप्त गर्न सकिन्छ।

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

print(len(c))
# 3

तपाईले सेट प्रकार सेटको लागि सेट(), कन्स्ट्रक्टर पनि प्रयोग गर्न सक्नुहुन्छ, यदि तपाईलाई काउन्टर वस्तु आवश्यक पर्दैन भने सजिलो हुन्छ।

सेट प्रकार एक डेटा प्रकार हो जसमा डुप्लिकेट तत्वहरू छैनन्। सेट() मा सूची पास गर्दा डुप्लिकेट मानहरूलाई बेवास्ता गर्छ र तत्वहरूको रूपमा अद्वितीय मानहरूको साथ सेट प्रकारको वस्तु फर्काउँछ। यस प्रकारका तत्वहरूको संख्या 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]

सूची बुझाइ सङ्केतमा प्रत्येक तत्वमा सशर्त अभिव्यक्ति लागू गर्दा बुलियन बूल्स (सत्य, गलत) भएका तत्वहरू सूची उत्पन्न हुन्छ। बुलियन टाइप बूल पूर्णांक प्रकारको 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

काउन्टर घटनाहरूको संख्यामा आधारित गणना गर्न प्रयोग गरिन्छ। वस्तुहरू() ले (तत्व, घटनाहरूको संख्या) को टपल प्राप्त गर्दछ, र घटनाहरूको संख्याले अवस्था निर्दिष्ट गर्दछ।

तल दुई वा बढी घटनाहरू भएका तत्वहरू निकाल्ने र घटनाहरूको कुल संख्या गणना गर्ने उदाहरण हो। यस उदाहरणमा, जम्मा छ को लागि चार 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

स्ट्रिङमा शब्दको घटनाहरूको सङ्ख्या गणना गर्छ।

ठोस उदाहरणको रूपमा, स्ट्रिङमा शब्दको घटनाहरूको संख्या गणना गरौं।

पहिले, रिप्लेस() विधि प्रयोग गरेर खाली स्ट्रिङको साथ अनावश्यक अल्पविराम र अवधिहरू बदल्नुहोस्, र त्यसपछि तिनीहरूलाई मेटाउनुहोस्। त्यसपछि, स्पेस द्वारा छुट्याएको सूची सिर्जना गर्न 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']

यदि तपाईंले सूची बनाउन सक्नुहुन्छ भने, तपाईंले प्रत्येक शब्द कत्ति पटक देखा पर्दछ, शब्दहरूको प्रकारहरू र सङ्कलनहरूको most_common() प्राप्त गर्न सक्नुहुन्छ। धेरै पटक देखा पर्ने शब्द प्राप्त गर्न काउन्टर।

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() पाठ विभाजित गर्न प्रयोग गर्न सकिँदैन ’cause त्यहाँ कुनै स्पष्ट शब्द विभाजन छैन। उदाहरण को लागी, तपाईले यो प्राप्त गर्न Janome पुस्तकालय प्रयोग गर्न सक्नुहुन्छ।

स्ट्रिङमा क्यारेक्टरको घटनाहरूको संख्या गणना गर्नुहोस्।

स्ट्रिङहरू पनि एक अनुक्रम प्रकारका हुनाले, तिनीहरू काउन्ट() विधिसँग प्रयोग गर्न सकिन्छ वा सङ्ग्रहको कन्स्ट्रक्टरलाई तर्कको रूपमा पास गर्न सकिन्छ। काउन्टर()।

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