பைதான் கவுண்டர் மூலம் பட்டியலில் உள்ள ஒவ்வொரு தனிமத்தின் நிகழ்வுகளின் எண்ணிக்கையைக் கணக்கிடுகிறது

வணிக

பைத்தானில், ஒரு பட்டியல் அல்லது டூபிளில் உள்ள அனைத்து உறுப்புகளின் எண்ணிக்கையையும் உள்ளமைக்கப்பட்ட லென்() செயல்பாட்டைப் பயன்படுத்தி பெறலாம், மேலும் ஒவ்வொரு தனிமத்தின் எண்ணிக்கையையும் (ஒவ்வொரு தனிமத்தின் நிகழ்வுகளின் எண்ணிக்கை) எண்ணிக்கை() முறையைப் பயன்படுத்தி பெறலாம். .

கூடுதலாக, பைதான் நிலையான நூலக சேகரிப்புகளின் கவுண்டர் வகுப்பைப் பயன்படுத்தி, நிகழ்வுகளின் எண்ணிக்கையின்படி உறுப்புகளைப் பெறலாம்.

இந்த பிரிவில், பின்வருவனவற்றைப் பற்றி விவாதிப்போம்

  • உறுப்புகளின் மொத்த எண்ணிக்கையை எண்ணுங்கள்:len()
  • ஒவ்வொரு தனிமத்தின் எண்ணிக்கையையும் எண்ணுங்கள் (ஒவ்வொரு தனிமத்தின் நிகழ்வுகளின் எண்ணிக்கை):count()
  • பயன்பாடு.collections.Counter
  • நிகழ்வின் அதிர்வெண் வரிசையில் உறுப்புகள் மீட்டெடுக்கப்படுகின்றன:most_common()
  • ஒன்றுடன் ஒன்று அல்லாத உறுப்புகளின் (தனித்துவ கூறுகள்) எண்ணிக்கையை (வகை) எண்ணுங்கள்.
  • நிபந்தனையை பூர்த்தி செய்யும் உறுப்புகளின் எண்ணிக்கையை எண்ணுங்கள்.

கூடுதலாக, ஒரு உறுதியான உதாரணமாக, பின்வருபவை மாதிரி குறியீட்டுடன் விளக்கப்பட்டுள்ளது.

  • ஒரு சரத்தில் ஒரு வார்த்தையின் நிகழ்வுகளின் எண்ணிக்கையைக் கணக்கிடுகிறது.
  • ஒரு சரத்தில் ஒரு பாத்திரத்தின் நிகழ்வுகளின் எண்ணிக்கையை எண்ணுங்கள்.

மாதிரி ஒரு பட்டியல், ஆனால் அதே செயலாக்கத்தை tuples மூலம் செய்ய முடியும்.

உறுப்புகளின் மொத்த எண்ணிக்கையை எண்ணுங்கள்: 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

ஒவ்வொரு தனிமத்தின் நிகழ்வுகளின் எண்ணிக்கையை நீங்கள் ஒரே நேரத்தில் பெற விரும்பினால், பின்வரும் சேகரிப்பு. கவுண்டர் பயனுள்ளதாக இருக்கும்.

சேகரிப்புகளை எவ்வாறு பயன்படுத்துவது.கவுண்டர்

பைதான் நிலையான நூலக சேகரிப்புகளில் ஒரு எதிர் வகுப்பு உள்ளது.

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

விசைகள்(), மதிப்புகள்(), உருப்படிகள்() போன்ற அகராதி வகை முறைகளையும் நீங்கள் பயன்படுத்தலாம்.

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() என்பது இரு பரிமாண பட்டியலை இடமாற்றம் செய்யப் பயன்படுகிறது (இந்த விஷயத்தில், டூப்பிள்களின் பட்டியல்), பின்னர் அதைத் திறந்து பிரித்தெடுக்கவும்.

ஒன்றுடன் ஒன்று அல்லாத உறுப்புகளின் (தனித்துவ கூறுகள்) எண்ணிக்கையை (வகை) எண்ணுங்கள்.

ஒரு பட்டியல் அல்லது டூபிளில் (எத்தனை வகைகள் உள்ளன) ஒன்றுடன் ஒன்று சேராத உறுப்புகள் (தனித்துவமான கூறுகள்) உள்ளன என்பதைக் கணக்கிட, மேலே விவரிக்கப்பட்டுள்ளபடி Counter அல்லது set() ஐப் பயன்படுத்தவும்.

எதிர் பொருளில் உள்ள உறுப்புகளின் எண்ணிக்கையானது அசல் பட்டியலில் உள்ள ஒன்றுடன் ஒன்று அல்லாத உறுப்புகளின் எண்ணிக்கைக்கு சமமாக இருக்கும், அதை 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]

பட்டியல் புரிதல் குறியீட்டில் உள்ள ஒவ்வொரு உறுப்புக்கும் ஒரு நிபந்தனை வெளிப்பாட்டைப் பயன்படுத்துவதால், பூலியன் பூல்ஸ் (உண்மை, தவறு) கூறுகளின் பட்டியல் கிடைக்கும். பூலியன் வகை பூல் என்பது முழு எண் வகை 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

ஒரு சரத்தில் ஒரு வார்த்தையின் நிகழ்வுகளின் எண்ணிக்கையைக் கணக்கிடுகிறது.

ஒரு உறுதியான உதாரணமாக, ஒரு சரத்தில் ஒரு வார்த்தையின் நிகழ்வுகளின் எண்ணிக்கையை எண்ணுவோம்.

முதலில், தேவையற்ற காற்புள்ளிகள் மற்றும் காலங்களை மாற்றவும் () முறையைப் பயன்படுத்தி வெற்று சரம் கொண்டு, பின்னர் அவற்றை நீக்கவும். பின்னர், இடைவெளிகளால் பிரிக்கப்பட்ட பட்டியலை உருவாக்க பிளவு() முறையைப் பயன்படுத்தவும்.

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 நூலகத்தைப் பயன்படுத்தலாம்.

ஒரு சரத்தில் ஒரு பாத்திரத்தின் நிகழ்வுகளின் எண்ணிக்கையை எண்ணுங்கள்.

சரங்களும் ஒரு வரிசை வகை என்பதால், அவை கவுண்ட்() முறையுடன் பயன்படுத்தப்படலாம் அல்லது சேகரிப்புகளின் கட்டமைப்பாளருக்கு ஒரு வாதமாக அனுப்பப்படும். கவுண்டர்().

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