પાયથોનના કાઉન્ટર સાથે સૂચિમાં દરેક તત્વની ઘટનાઓની સંખ્યા ગણવી

બિઝનેસ

પાયથોનમાં, બિલ્ટ-ઇન ફંક્શન લેન() નો ઉપયોગ કરીને સૂચિ અથવા ટપલમાંના તમામ ઘટકોની સંખ્યા મેળવી શકાય છે, અને દરેક ઘટકની સંખ્યા (દરેક તત્વની ઘટનાઓની સંખ્યા) કાઉન્ટ() પદ્ધતિનો ઉપયોગ કરીને મેળવી શકાય છે. .

વધુમાં, પાયથોન સ્ટાન્ડર્ડ લાઇબ્રેરી કલેક્શનના કાઉન્ટર ક્લાસનો ઉપયોગ ઘટનાઓની સંખ્યાના ક્રમમાં તત્વો મેળવવા માટે કરી શકાય છે.

આ વિભાગમાં, અમે નીચેની ચર્ચા કરીશું

  • ઘટકોની કુલ સંખ્યાની ગણતરી કરો:len()
  • દરેક તત્વની સંખ્યા ગણો (દરેક તત્વની ઘટનાઓની સંખ્યા):count()
  • ઉપયોગ.collections.Counter
  • ઘટકો ઘટનાની આવર્તનના ક્રમમાં પુનઃપ્રાપ્ત કરવામાં આવે છે:most_common()
  • બિન-ઓવરલેપિંગ તત્વો (અનન્ય તત્વો) ની સંખ્યા (પ્રકાર) ગણો.
  • સ્થિતિને સંતોષતા તત્વોની સંખ્યા ગણો.

વધુમાં, નક્કર ઉદાહરણ તરીકે, નીચેનાને નમૂના કોડ સાથે સમજાવવામાં આવ્યું છે.

  • શબ્દમાળામાં એક શબ્દની ઘટનાઓની સંખ્યા ગણે છે.
  • શબ્દમાળામાં અક્ષરની ઘટનાઓની સંખ્યા ગણો.

નમૂના એક સૂચિ છે, પરંતુ સમાન પ્રક્રિયા ટ્યુપલ્સ સાથે કરી શકાય છે.

તત્વોની કુલ સંખ્યા ગણો: 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

જો તમે એક સાથે દરેક તત્વની ઘટનાઓની સંખ્યા મેળવવા માંગતા હો, તો નીચેનો સંગ્રહ. કાઉન્ટર ઉપયોગી છે.

સંગ્રહ.કાઉન્ટરનો ઉપયોગ કેવી રીતે કરવો

પાયથોન સ્ટાન્ડર્ડ લાઇબ્રેરી કલેક્શનમાં કાઉન્ટર ક્લાસ છે.

કાઉન્ટર() એ ડિક્શનરી ટાઇપ ડિક્ટનો સબક્લાસ છે, જેમાં કી તરીકે તત્વોના રૂપમાં ડેટા અને મૂલ્યો તરીકે ઘટનાઓ છે.

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() પદ્ધતિ

કાઉન્ટર પાસે 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)]

જો most_common() પદ્ધતિ માટે દલીલ 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() નો ઉપયોગ દ્વિ-પરિમાણીય સૂચિને સ્થાનાંતરિત કરવા માટે થાય છે (આ કિસ્સામાં, ટ્યુપલ્સની સૂચિ), અને પછી તેને અનપૅક કરો અને બહાર કાઢો.

બિન-ઓવરલેપિંગ તત્વો (અનન્ય તત્વો) ની સંખ્યા (પ્રકાર) ગણો.

સૂચિ અથવા ટ્યુપલમાં કેટલા બિન-ઓવરલેપિંગ તત્વો (અનન્ય તત્વો) છે (કેટલા પ્રકારો છે) છે તેની ગણતરી કરવા માટે, ઉપર વર્ણવ્યા પ્રમાણે કાઉન્ટર અથવા સેટ() નો ઉપયોગ કરો.

કાઉન્ટર ઑબ્જેક્ટમાં ઘટકોની સંખ્યા મૂળ સૂચિમાં બિન-ઓવરલેપિંગ ઘટકોની સંખ્યા જેટલી છે, જે len() વડે મેળવી શકાય છે.

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

જો તમે ખોટા મૂલ્યોની સંખ્યા (તત્વોની સંખ્યા જે શરતને સંતોષતા નથી) ગણવા માંગતા હોય, તો તેનો ઉપયોગ કરશો નહીં. નોંધ કરો કે > ના કરતા વધારે પ્રાધાન્ય ધરાવે છે (તેની પ્રથમ ગણતરી કરવામાં આવે છે), તેથી નીચેના ઉદાહરણમાં (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 પુસ્તકાલયનો ઉપયોગ કરી શકો છો.

શબ્દમાળામાં અક્ષરની ઘટનાઓની સંખ્યા ગણો.

શબ્દમાળાઓ પણ એક ક્રમ પ્રકાર હોવાથી, તેનો ઉપયોગ કાઉન્ટ() પદ્ધતિ સાથે કરી શકાય છે અથવા સંગ્રહના કન્સ્ટ્રક્ટરને દલીલ તરીકે પસાર કરી શકાય છે. કાઉન્ટર().

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