పైథాన్ కౌంటర్‌తో జాబితాలోని ప్రతి మూలకం యొక్క సంఘటనల సంఖ్యను లెక్కించడం

పైథాన్‌లో, అంతర్నిర్మిత ఫంక్షన్ లెన్()ని ఉపయోగించి జాబితా లేదా టుపుల్‌లోని అన్ని మూలకాల సంఖ్యను పొందవచ్చు మరియు ప్రతి మూలకం యొక్క సంఖ్యను (ప్రతి మూలకం యొక్క సంఘటనల సంఖ్య) కౌంట్() పద్ధతిని ఉపయోగించి పొందవచ్చు. .

అదనంగా, పైథాన్ స్టాండర్డ్ లైబ్రరీ సేకరణల కౌంటర్ క్లాస్ సంఘటనల సంఖ్య క్రమంలో మూలకాలను పొందడానికి ఉపయోగించబడుతుంది.

ఈ విభాగంలో, మేము ఈ క్రింది వాటిని చర్చిస్తాము

• మొత్తం మూలకాల సంఖ్యను లెక్కించండి:len()
• ప్రతి మూలకం యొక్క సంఖ్యను లెక్కించండి (ప్రతి మూలకం యొక్క సంఘటనల సంఖ్య):count()
• వాడుక.collections.Counter
• సంభవించే ఫ్రీక్వెన్సీ క్రమంలో మూలకాలు తిరిగి పొందబడతాయి:most_common()
• అతివ్యాప్తి చెందని మూలకాల (ప్రత్యేక అంశాలు) సంఖ్య (రకం) లెక్కించండి.
• పరిస్థితిని సంతృప్తిపరిచే మూలకాల సంఖ్యను లెక్కించండి.

అదనంగా, ఒక నిర్దిష్ట ఉదాహరణగా, క్రింది నమూనా కోడ్‌తో వివరించబడింది.

• స్ట్రింగ్‌లో పదం యొక్క సంఘటనల సంఖ్యను గణిస్తుంది.
• స్ట్రింగ్‌లో అక్షరం యొక్క సంఘటనల సంఖ్యను లెక్కించండి.

నమూనా జాబితా, కానీ అదే ప్రాసెసింగ్ టుపుల్స్‌తో చేయవచ్చు.

మొత్తం మూలకాల సంఖ్యను లెక్కించండి: 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

మూలకం వలె లేని విలువను ఆర్గ్యుమెంట్‌గా పంపితే, 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)

అంతర్నిర్మిత ఫంక్షన్ జిప్() ద్విమితీయ జాబితాను (ఈ సందర్భంలో, టుపుల్స్ జాబితా) బదిలీ చేయడానికి ఉపయోగించబడుతుంది, ఆపై దాన్ని అన్‌ప్యాక్ చేసి సంగ్రహిస్తుంది.

అతివ్యాప్తి చెందని మూలకాల (ప్రత్యేక అంశాలు) సంఖ్య (రకం) లెక్కించండి.

జాబితా లేదా టుపుల్‌లో (ఎన్ని రకాలు ఉన్నాయి) ఎన్ని అతివ్యాప్తి చెందని మూలకాలు (ప్రత్యేక అంశాలు) ఉన్నాయో లెక్కించడానికి, పైన వివరించిన విధంగా కౌంటర్ లేదా సెట్()ని ఉపయోగించండి.

కౌంటర్ ఆబ్జెక్ట్‌లోని మూలకాల సంఖ్య అసలైన జాబితాలోని అతివ్యాప్తి చెందని మూలకాల సంఖ్యకు సమానంగా ఉంటుంది, వీటిని len()తో పొందవచ్చు.

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

print(len(c))
# 3

మీరు సెట్ టైప్ సెట్ కోసం కన్స్ట్రక్టర్ అయిన set()ని కూడా ఉపయోగించవచ్చు, మీకు కౌంటర్ ఆబ్జెక్ట్ అవసరం లేకుంటే ఇది సులభం.

సెట్ రకం అనేది డూప్లికేట్ ఎలిమెంట్స్ లేని డేటా రకం. సెట్()కి జాబితాను పంపడం వలన నకిలీ విలువలు విస్మరించబడతాయి మరియు మూలకాలుగా మాత్రమే ప్రత్యేక విలువలతో సెట్ చేయబడిన రకం వస్తువును అందిస్తుంది. ఈ రకమైన మూలకాల సంఖ్య లెన్() ద్వారా పొందబడుతుంది.

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]

జాబితా కాంప్రహెన్షన్ సంజ్ఞామానంలోని ప్రతి మూలకానికి షరతులతో కూడిన వ్యక్తీకరణను వర్తింపజేయడం వలన బూలియన్ బూల్స్ (నిజం, తప్పు) ఉన్న మూలకాల జాబితా వస్తుంది. బూలియన్ రకం బూల్ అనేది పూర్ణాంకం రకం పూర్ణాంకం యొక్క ఉపవర్గం, ఇక్కడ నిజమైన 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']

మీరు జాబితాను రూపొందించగలిగితే, మీరు ప్రతి పదం ఎన్నిసార్లు కనిపిస్తుందో, కనిపించే పదాల రకాలు మరియు అత్యంత_సాధారణ() సేకరణలను పొందవచ్చు. ఎక్కువ సార్లు కనిపించే పదాన్ని పొందడానికి కౌంటర్.

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

అలాగే, జపనీస్ టెక్స్ట్ విషయంలో, టెక్స్ట్‌ను విభజించడానికి స్ప్లిట్() ఉపయోగించబడదు ఎందుకంటే స్పష్టమైన పద విభజన లేదు. ఉదాహరణకు, మీరు దీన్ని సాధించడానికి జానోమ్ లైబ్రరీని ఉపయోగించవచ్చు.

స్ట్రింగ్‌లో అక్షరం యొక్క సంఘటనల సంఖ్యను లెక్కించండి.

స్ట్రింగ్స్ కూడా సీక్వెన్స్ రకం కాబట్టి, వాటిని కౌంట్() పద్ధతితో ఉపయోగించవచ్చు లేదా సేకరణల కన్స్ట్రక్టర్‌కు ఆర్గ్యుమెంట్‌గా పంపవచ్చు.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')