पायथन के काउंटर के साथ सूची में प्रत्येक तत्व की घटनाओं की संख्या की गणना करना

पायथन में, किसी सूची या टपल में सभी तत्वों की संख्या बिल्ट-इन फ़ंक्शन लेन () का उपयोग करके प्राप्त की जा सकती है, और प्रत्येक तत्व की संख्या (प्रत्येक तत्व की घटनाओं की संख्या) गणना () विधि का उपयोग करके प्राप्त की जा सकती है। .

इसके अलावा, पायथन मानक पुस्तकालय संग्रह के काउंटर वर्ग का उपयोग तत्वों को घटनाओं की संख्या के क्रम में प्राप्त करने के लिए किया जा सकता है।

इस खंड में, हम निम्नलिखित पर चर्चा करेंगे:

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

इसके अलावा, एक ठोस उदाहरण के रूप में, निम्नलिखित को नमूना कोड के साथ समझाया गया है।

• एक स्ट्रिंग में एक शब्द की घटनाओं की संख्या की गणना करता है।
• एक स्ट्रिंग में एक चरित्र की घटनाओं की संख्या की गणना करें।

नमूना एक सूची है, लेकिन वही प्रसंस्करण टुपल्स के साथ किया जा सकता है।

तत्वों की कुल संख्या की गणना करें: लेन ()

किसी सूची या टपल में तत्वों की कुल संख्या की गणना करने के लिए, अंतर्निहित फ़ंक्शन लेन () का उपयोग करें।

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

print(len(l))
# 7

प्रत्येक तत्व की संख्या की गणना (प्रत्येक तत्व की घटनाओं की संख्या): गणना () विधि

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

• 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

यदि आप एक बार में प्रत्येक तत्व की घटनाओं की संख्या प्राप्त करना चाहते हैं, तो निम्न संग्रह। काउंटर उपयोगी है।

संग्रह का उपयोग कैसे करें। काउंटर

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

• collections – Counter — Container datatypes — Python 3.10.0 Documentation

काउंटर () डिक्शनरी टाइप डिक्शनरी का एक उपवर्ग है, जिसमें तत्वों के रूप में कुंजी और घटनाओं के रूप में मान के रूप में डेटा होता है।

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

आप शब्दकोश प्रकार के तरीकों का भी उपयोग कर सकते हैं जैसे कि कुंजियाँ (), मान (), आइटम (), आदि।

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() विधि

काउंटर में मोस्ट_कॉमन () विधि है, जो फॉर्म के टुपल्स की एक सूची देता है (तत्व, घटनाओं की संख्या) घटनाओं की संख्या के अनुसार क्रमबद्ध।

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)

अंतर्निहित फ़ंक्शन ज़िप () का उपयोग दो-आयामी सूची (इस मामले में, टुपल्स की एक सूची) को स्थानांतरित करने के लिए किया जाता है, और फिर इसे अनपैक और निकालने के लिए किया जाता है।

गैर-अतिव्यापी तत्वों (अद्वितीय तत्वों) की संख्या (प्रकार) की गणना करें।

यह गिनने के लिए कि किसी सूची या टपल में कितने गैर-अतिव्यापी तत्व (अद्वितीय तत्व) हैं (कितने प्रकार हैं), ऊपर बताए अनुसार काउंटर या सेट () का उपयोग करें।

काउंटर ऑब्जेक्ट में तत्वों की संख्या मूल सूची में गैर-अतिव्यापी तत्वों की संख्या के बराबर है, जिसे लेन () के साथ प्राप्त किया जा सकता है।

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

print(len(c))
# 3

आप सेट प्रकार सेट के लिए सेट (), कंस्ट्रक्टर का भी उपयोग कर सकते हैं, जो कि काउंटर ऑब्जेक्ट की आवश्यकता नहीं होने पर आसान है।

सेट प्रकार एक डेटा प्रकार है जिसमें डुप्लिकेट तत्व नहीं होते हैं। सेट करने के लिए एक सूची पास करना () डुप्लिकेट मानों को अनदेखा करता है और तत्वों के रूप में केवल अद्वितीय मानों के साथ सेट प्रकार का ऑब्जेक्ट देता है। इस प्रकार के तत्वों की संख्या लेन () द्वारा प्राप्त की जाती है।

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 का एक उपवर्ग है, जहां सत्य को 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

यदि आप झूठे मूल्यों की संख्या की गणना करना चाहते हैं (उन तत्वों की संख्या जो शर्त को पूरा नहीं करते हैं), नहीं का उपयोग करें। ध्यान दें कि > नहीं की तुलना में उच्च प्राथमिकता है (इसकी गणना पहले की जाती है), इसलिए निम्नलिखित उदाहरण में कोष्ठक () in (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

निम्नलिखित दो या दो से अधिक घटनाओं वाले तत्वों के प्रकार निकालने और घटनाओं की संख्या की गणना करने का एक उदाहरण है। इस उदाहरण में, दो प्रकार हैं, ए और सी।

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

यदि आप एक सूची बना सकते हैं, तो आप प्रत्येक शब्द के प्रकट होने की संख्या, प्रकट होने वाले शब्दों के प्रकार, और संग्रहों का सबसे_आम () प्राप्त कर सकते हैं। सबसे अधिक बार प्रकट होने वाले शब्द को प्राप्त करने के लिए काउंटर।

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

उपरोक्त एक बहुत ही सरल प्रक्रिया है, इसलिए अधिक जटिल प्राकृतिक भाषा प्रसंस्करण के लिए एनएलटीके जैसे पुस्तकालयों का उपयोग करना बेहतर है।

• Natural Language Toolkit — NLTK 3.6.5 documentation

साथ ही, जापानी पाठ के मामले में, विभाजन () का उपयोग पाठ को विभाजित करने के लिए नहीं किया जा सकता है क्योंकि कोई स्पष्ट शब्द पृथक्करण नहीं है। उदाहरण के लिए, आप इसे प्राप्त करने के लिए जेनोम लाइब्रेरी का उपयोग कर सकते हैं।

एक स्ट्रिंग में एक चरित्र की घटनाओं की संख्या की गणना करें।

चूंकि तार भी एक अनुक्रम प्रकार हैं, उनका उपयोग गिनती () विधि के साथ किया जा सकता है या संग्रह के निर्माता के लिए एक तर्क के रूप में पारित किया जा सकता है। काउंटर ()।

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