Python’s Counter सह सूचीतील प्रत्येक घटकाच्या घटनांची संख्या मोजणे

व्यवसाय

पायथनमध्ये, बिल्ट-इन फंक्शन len() वापरून सूची किंवा ट्यूपलमधील सर्व घटकांची संख्या मिळवता येते, आणि प्रत्येक घटकाची संख्या (प्रत्येक घटकाच्या घटनांची संख्या) count() पद्धत वापरून मिळवता येते. .

याव्यतिरिक्त, पायथन मानक लायब्ररी कलेक्शनच्या काउंटर क्लासचा वापर घटनांच्या संख्येनुसार घटक मिळविण्यासाठी केला जाऊ शकतो.

या विभागात आपण पुढील गोष्टींवर चर्चा करू

  • घटकांची एकूण संख्या मोजा:len()
  • प्रत्येक घटकाची संख्या मोजा (प्रत्येक घटकाच्या घटनांची संख्या):count()
  • वापर.collections.Counter
  • घटनेच्या वारंवारतेच्या क्रमाने घटक पुनर्प्राप्त केले जातात:most_common()
  • नॉन-ओव्हरलॅपिंग घटकांची संख्या (प्रकार) मोजा (युनिक घटक).
  • स्थिती पूर्ण करणार्‍या घटकांची संख्या मोजा.

याव्यतिरिक्त, ठोस उदाहरण म्हणून, नमुना कोडसह खालील स्पष्ट केले आहे.

  • स्ट्रिंगमधील शब्दाच्या घटनांची संख्या मोजते.
  • स्ट्रिंगमधील वर्णांच्या घटनांची संख्या मोजा.

नमुना एक सूची आहे, परंतु समान प्रक्रिया ट्यूपल्ससह केली जाऊ शकते.

घटकांची एकूण संख्या मोजा: len()

सूची किंवा टपलमधील घटकांची एकूण संख्या मोजण्यासाठी, अंगभूत फंक्शन len() वापरा.

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

print(len(l))
# 7

प्रत्येक घटकाची संख्या मोजणे (प्रत्येक घटकाच्या घटनांची संख्या): count() पद्धत

प्रत्येक घटकाची संख्या मोजण्यासाठी (प्रत्येक घटकाच्या घटनांची संख्या), याद्या, ट्यूपल्स इत्यादींसाठी 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

जर तुम्हाला प्रत्येक घटकाच्या घटनांची संख्या एकाच वेळी मिळवायची असेल, तर खालील संग्रह. काउंटर उपयुक्त आहे.

संग्रह.काउंटर कसे वापरावे

पायथन मानक लायब्ररी संग्रहांमध्ये काउंटर वर्ग आहे.

काउंटर() हा डिक्शनरी प्रकाराचा उपवर्ग आहे, ज्यामध्ये की म्हणून घटक आणि मूल्ये म्हणून घटनांच्या स्वरूपात डेटा असतो.

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 इत्यादी प्रकारातील ऑब्जेक्ट्स परत करतात. ते तुम्हाला स्टेटमेंटसाठी चालवायचे असल्यास वापरता येतात. तुम्हाला ते सूचीमध्ये रूपांतरित करायचे असल्यास, list() वापरा.

दिसण्याच्या वारंवारतेच्या क्रमाने घटक प्राप्त करणे: 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 चा एक उपवर्ग आहे, जेथे सत्य 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’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']

जर तुम्ही सूची बनवू शकत असाल, तर तुम्हाला प्रत्येक शब्द किती वेळा दिसला, दिसणाऱ्या शब्दांचे प्रकार आणि सर्वात जास्त वेळा दिसणारे शब्द मिळवण्यासाठी सर्वात जास्त_कॉमन() संग्रह मिळवू शकता. काउंटर.

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 सारख्या लायब्ररीचा वापर करणे चांगले आहे.

तसेच, जपानी मजकूराच्या बाबतीत, स्प्लिट() मजकूर विभाजित करण्यासाठी वापरला जाऊ शकत नाही कारण स्पष्ट शब्द वेगळे नाही. उदाहरणार्थ, हे साध्य करण्यासाठी तुम्ही Janome लायब्ररी वापरू शकता.

स्ट्रिंगमधील वर्णांच्या घटनांची संख्या मोजा.

स्ट्रिंग्स देखील अनुक्रम प्रकार असल्याने, ते count() पद्धतीसह वापरले जाऊ शकतात किंवा कलेक्शन. काउंटर() च्या कन्स्ट्रक्टरला वितर्क म्हणून पास केले जाऊ शकतात.

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