दिलचस्प पोस्ट
हाइबरनेट स्तंभ नाम मुद्दों मूल कोड पर बाइट कोड के फायदे क्या हैं? मार्गों में चलते हुए # अंगुल्याज़ में यूआरएल से # निकालना डिफ़ॉल्ट रूप से सीएमडी.एक्सएक्स में यूनिकोड वर्णसेट कैसे बनाएं? क्रोन डिस्पैचर केक पीएचपी 2.0 यदि आप एक चर जावास्क्रिप्ट में एक सरणी है, तो आप कैसे जांच करते हैं? कस्टम सूचीदृश्य एडाप्टर getView विधि को कई बार कहा जाता है, और कोई सुसंगत क्रम में नहीं क्यों "typedef struct foo foo;" हानिकारक माना जाता है? क्या कोई वस्तु प्रारंभकर्ता का उपयोग करने का कोई लाभ है? लगातार पूर्णांक संख्याओं के सरणी में एक डुप्लिकेट तत्व कैसे प्राप्त करें? भूमिका आधारित अभिगम नियंत्रण जीआईटी रिपॉजिटरी परिवर्तित करने के लिए उथले? सीएसएस का उपयोग कर विभिन्न डिवाइस प्लेटफार्मों का पता लगाएं IIS अनुरोध समयबाह्य लंबे asp.net ऑपरेशन पर एक नकली / स्टब पायथन मॉड्यूल जैसे urllib कैसे हो सकता है

सूची वस्तु की घटनाओं की गणना कैसे करें?

एक आइटम को देखते हुए, मैं पायथन में एक सूची में इसकी घटनाओं को कैसे गिन सकता हूँ?

Solutions Collecting From Web of "सूची वस्तु की घटनाओं की गणना कैसे करें?"

यदि आप केवल एक आइटम की गिनती चाहते हैं, तो count विधि का उपयोग करें:

 >>> [1, 2, 3, 4, 1, 4, 1].count(1) 3 

इसका उपयोग करें यदि आप एकाधिक आइटम गिनना चाहते हैं लूप में count कॉल करने के लिए प्रत्येक count कॉल की सूची में एक अलग पास की आवश्यकता होती है, जो प्रदर्शन के लिए भयावह हो सकता है। यदि आप सभी वस्तुओं, या यहां तक ​​कि केवल कई आइटमों को भी गिनना चाहते हैं, Counter उपयोग करें, जैसा कि अन्य उत्तरों में बताया गया है।

यदि आप Python 2.7 या 3 का उपयोग कर रहे हैं और आप प्रत्येक तत्व के लिए आवृत्तियों की संख्या चाहते हैं:

 >>> from collections import Counter >>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red'] >>> Counter(z) Counter({'blue': 3, 'red': 2, 'yellow': 1}) 

एक सूची में एक आइटम की घटनाओं की गिनती

सिर्फ एक सूची आइटम की घटनाओं की गिनती के लिए आप count() उपयोग कर सकते हैं

 >>> l = ["a","b","b"] >>> l.count("a") 1 >>> l.count("b") 2 

सूची में सभी वस्तुओं की घटनाओं की गिनती भी एक सूची "मिलान" या एक मिलान काउंटर बनाने के रूप में जाना जाता है।

गणना के साथ सभी आइटमों की गिनती ()

l में वस्तुओं की घटनाओं की गिनती करने के लिए बस एक सूची समझ और count() विधि का उपयोग कर सकते हैं

 [[x,l.count(x)] for x in set(l)] 

(या इसी तरह एक शब्दकोश dict((x,l.count(x)) for x in set(l)) )

उदाहरण:

 >>> l = ["a","b","b"] >>> [[x,l.count(x)] for x in set(l)] [['a', 1], ['b', 2]] >>> dict((x,l.count(x)) for x in set(l)) {'a': 1, 'b': 2} 

काउंटर के साथ सभी आइटमों की गिनती

वैकल्पिक रूप से, collections लाइब्रेरी से तेज Counter क्लास होता है

 Counter(l) 

उदाहरण:

 >>> l = ["a","b","b"] >>> from collections import Counter >>> Counter(l) Counter({'b': 2, 'a': 1}) 

काउंटर कितना तेज़ है?

मैंने जाँच की कि तालमेल सूची के लिए Counter कितना तेज है। मैंने n कुछ मानकों के साथ दोनों विधियों की कोशिश की और ऐसा प्रतीत होता है कि Counter लगभग 2 के निरंतर कारक से तेज है।

यहाँ स्क्रिप्ट है जिसका मैंने प्रयोग किया है:

 from __future__ import print_function import timeit t1=timeit.Timer('Counter(l)', \ 'import random;import string;from collections import Counter;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]' ) t2=timeit.Timer('[[x,l.count(x)] for x in set(l)]', 'import random;import string;n=1000;l=[random.choice(string.ascii_letters) for x in range(n)]' ) print("Counter(): ", t1.repeat(repeat=3,number=10000)) print("count(): ", t2.repeat(repeat=3,number=10000) 

और आउटपुट:

 Counter(): [0.46062711701961234, 0.4022796869976446, 0.3974247490405105] count(): [7.779430688009597, 7.962715800967999, 8.420845870045014] 

एक शब्दकोश में, प्रत्येक आइटम की घटनाओं की संख्या प्राप्त करने का एक अन्य तरीका:

 dict((i, a.count(i)) for i in a) 

list.count(x) एक सूची में x की संख्या की संख्या देता है

देखें: http://docs.python.org/tutorial/datastructures.html#more-on-lists

यदि आप एक बार सभी मानों को गिनना चाहते हैं तो आप इसे बहुत तेज़ी से अंडाकार arrays और bincount का उपयोग कर निम्नानुसार कर सकते हैं

 import numpy as np a = np.array([1, 2, 3, 4, 1, 4, 1]) np.bincount(a) 

जो देता है

 >>> array([0, 3, 1, 1, 2]) 

एक आइटम को देखते हुए, मैं पायथन में एक सूची में इसकी घटनाओं को कैसे गिन सकता हूँ?

यहां एक उदाहरण सूची है:

 >>> l = list('aaaaabbbbcccdde') >>> l ['a', 'a', 'a', 'a', 'a', 'b', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'e'] 

list.count

सूची list.count विधि है

 >>> l.count('b') 4 

यह किसी भी सूची के लिए ठीक काम करता है ट्यूपल्स के पास भी इस विधि है:

 >>> t = tuple('aabbbffffff') >>> t ('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f') >>> t.count('f') 6 

collections.Counter

और फिर संग्रह है। आप किसी भी बार-बार एक काउंटर में डंप कर सकते हैं, न कि केवल एक सूची, और काउंटर तत्वों की गिनती के डेटा संरचना को बनाए रखेगा।

उपयोग:

 >>> from collections import Counter >>> c = Counter(l) >>> c['b'] 4 

काउंटर पायथन शब्दकोशों पर आधारित हैं, उनकी चाबियाँ तत्व हैं, इसलिए चाबियाँ हंस करने योग्य होने चाहिए। वे मूल रूप से सेट की तरह होते हैं जो अनावश्यक तत्वों को उन में शामिल करते हैं।

collections.Counter आगे उपयोग

आप अपने काउंटर से इटेरैबल्स के साथ जोड़ या घटा सकते हैं:

 >>> c.update(list('bbb')) >>> c['b'] 7 >>> c.subtract(list('bbb')) >>> c['b'] 4 

और आप काउंटर के साथ मल्टी-सेट ऑपरेशंस भी कर सकते हैं:

 >>> c2 = Counter(list('aabbxyz')) >>> c - c2 # set difference Counter({'a': 3, 'c': 3, 'b': 2, 'd': 2, 'e': 1}) >>> c + c2 # addition of all elements Counter({'a': 7, 'b': 6, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1}) >>> c | c2 # set union Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1, 'y': 1, 'x': 1, 'z': 1}) >>> c & c2 # set intersection Counter({'a': 2, 'b': 2}) 

क्यों नहीं पांडा?

एक अन्य जवाब से पता चलता है:

पंडों का उपयोग क्यों नहीं करते?

पांडा एक सामान्य पुस्तकालय है, लेकिन यह मानक पुस्तकालय में नहीं है। इसे निर्भरता के रूप में जोड़ना गैर-तुच्छ है।

इसमें सूची के उद्देश्य के साथ-साथ मानक लाइब्रेरी में उपयोग-मामले के लिए अंतर्निहित समाधान भी हैं।

यदि आपकी परियोजना को पहले से पंडों की आवश्यकता नहीं है, तो यह केवल इस कार्यक्षमता के लिए एक आवश्यकता बनाने के लिए बेवकूफी होगी।

मुझे आज यह समस्या थी और इससे पहले कि मैंने सोचा था कि मैं सोचना चाहता हूँ इस:

 dict((i,a.count(i)) for i in a) 

वास्तव में, बड़ी सूचियों के लिए वास्तव में धीमा है मेरा समाधान

 def occurDict(items): d = {} for i in items: if i in d: d[i] = d[i]+1 else: d[i] = 1 return d 

वास्तव में पायस्टर 2.7 के लिए कम से कम काउंटर समाधान की तुलना में थोड़ा तेज है

पंडों का उपयोग क्यों नहीं करते?

 import pandas as pd l = ['a', 'b', 'c', 'd', 'a', 'd', 'a'] # converting the list to a Series and counting the values my_count = pd.Series(l).value_counts() my_count 

आउटपुट:

 a 3 d 2 b 1 c 1 dtype: int64 

यदि आप किसी विशेष तत्व की गिनती की तलाश कर रहे हैं, तो कहे, कोशिश करें:

 my_count['a'] 

आउटपुट:

 3 
 # Python >= 2.6 (defaultdict) && < 2.7 (Counter, OrderedDict) from collections import defaultdict def count_unsorted_list_items(items): """ :param items: iterable of hashable items to count :type items: iterable :returns: dict of counts like Py2.7 Counter :rtype: dict """ counts = defaultdict(int) for item in items: counts[item] += 1 return dict(counts) # Python >= 2.2 (generators) def count_sorted_list_items(items): """ :param items: sorted iterable of items to count :type items: sorted iterable :returns: generator of (item, count) tuples :rtype: generator """ if not items: return elif len(items) == 1: yield (items[0], 1) return prev_item = items[0] count = 1 for item in items[1:]: if prev_item == item: count += 1 else: yield (prev_item, count) count = 1 prev_item = item yield (item, count) return import unittest class TestListCounters(unittest.TestCase): def test_count_unsorted_list_items(self): D = ( ([], []), ([2], [(2,1)]), ([2,2], [(2,2)]), ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]), ) for inp, exp_outp in D: counts = count_unsorted_list_items(inp) print inp, exp_outp, counts self.assertEqual(counts, dict( exp_outp )) inp, exp_outp = UNSORTED_WIN = ([2,2,4,2], [(2,3), (4,1)]) self.assertEqual(dict( exp_outp ), count_unsorted_list_items(inp) ) def test_count_sorted_list_items(self): D = ( ([], []), ([2], [(2,1)]), ([2,2], [(2,2)]), ([2,2,2,2,3,3,5,5], [(2,4), (3,2), (5,2)]), ) for inp, exp_outp in D: counts = list( count_sorted_list_items(inp) ) print inp, exp_outp, counts self.assertEqual(counts, exp_outp) inp, exp_outp = UNSORTED_FAIL = ([2,2,4,2], [(2,3), (4,1)]) self.assertEqual(exp_outp, list( count_sorted_list_items(inp) )) # ... [(2,2), (4,1), (2,1)] 

मैंने पेपरप्लोट (मेरी छोटी परियोजना) के साथ सभी सुझाए गए समाधान (और कुछ नए) की तुलना की है

एक आइटम की गणना

बड़े पर्याप्त सरणियों के लिए, यह पता चला है कि

 numpy.sum(numpy.array(a) == 1) 

अन्य समाधानों की तुलना में थोड़ा तेज है

यहां छवि विवरण दर्ज करें

सभी वस्तुओं की गिनती

जैसा कि पहले स्थापित ,

 numpy.bincount(a) 

आप क्या चाहते हैं

यहां छवि विवरण दर्ज करें


भूखंडों को पुन: उत्पन्न करने के लिए कोड:

 from collections import Counter from collections import defaultdict import numpy import operator import pandas import perfplot def counter(a): return Counter(a) def count(a): return dict((i, a.count(i)) for i in set(a)) def bincount(a): return numpy.bincount(a) def pandas_value_counts(a): return pandas.Series(a).value_counts() def occur_dict(a): d = {} for i in a: if i in d: d[i] = d[i]+1 else: d[i] = 1 return d def count_unsorted_list_items(items): counts = defaultdict(int) for item in items: counts[item] += 1 return dict(counts) def operator_countof(a): return dict((i, operator.countOf(a, i)) for i in set(a)) perfplot.show( setup=lambda n: list(numpy.random.randint(0, 100, n)), n_range=[2**k for k in range(20)], kernels=[ counter, count, bincount, pandas_value_counts, occur_dict, count_unsorted_list_items, operator_countof ], equality_check=None, logx=True, logy=True, ) 

2।

 from collections import Counter from collections import defaultdict import numpy import operator import pandas import perfplot def counter(a): return Counter(a) def count(a): return dict((i, a.count(i)) for i in set(a)) def bincount(a): return numpy.bincount(a) def pandas_value_counts(a): return pandas.Series(a).value_counts() def occur_dict(a): d = {} for i in a: if i in d: d[i] = d[i]+1 else: d[i] = 1 return d def count_unsorted_list_items(items): counts = defaultdict(int) for item in items: counts[item] += 1 return dict(counts) def operator_countof(a): return dict((i, operator.countOf(a, i)) for i in set(a)) perfplot.show( setup=lambda n: list(numpy.random.randint(0, 100, n)), n_range=[2**k for k in range(20)], kernels=[ counter, count, bincount, pandas_value_counts, occur_dict, count_unsorted_list_items, operator_countof ], equality_check=None, logx=True, logy=True, ) 

सामान्य प्रकार वाले विविध तत्वों की संख्या की गणना करने के लिए:

 li = ['A0','c5','A8','A2','A5','c2','A3','A9'] print sum(1 for el in li if el[0]=='A' and el[1] in '01234') 

देता है

3 , 6 नहीं

 from collections import Counter country=['Uruguay', 'Mexico', 'Uruguay', 'France', 'Mexico'] count_country = Counter(country) output_list= [] for i in count_country: output_list.append([i,count_country[i]]) print output_list 

आउटपुट सूची:

 [['Mexico', 2], ['France', 1], ['Uruguay', 2]] 

आप किसी अंतर्निर्मित मॉड्यूल operator countOf पद्धति का उपयोग भी कर सकते हैं।

 >>> import operator >>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1) 3 
 sum([1 for elem in <yourlist> if elem==<your_value>]) 

यह आपके_मूल्य की घटनाओं की मात्रा वापस करेगा