मैं किसी सूची आइटम की घटनाओं को कैसे गिन सकता हूं?
जवाबों:
यदि आप केवल एक आइटम की गिनती चाहते हैं, तो countविधि का उपयोग करें :
>>> [1, 2, 3, 4, 1, 4, 1].count(1)
3यदि आप एक से अधिक आइटम गिनना चाहते हैं, तो इसका उपयोग न करें। कॉलिंग countएक पाश में हर के लिए सूची पर एक अलग पास की आवश्यकता countकॉल, जो प्रदर्शन के लिए घातक हो सकता है। यदि आप Counterअन्य उत्तर में बताए गए सभी आइटम, या यहां तक कि सिर्फ कई आइटम, उपयोग करना चाहते हैं ।
का प्रयोग करें Counterअगर आप अजगर 2.7 या 3.x का उपयोग कर रहे हैं और आप प्रत्येक तत्व के लिए घटनाओं की संख्या हैं:
>>> from collections import Counter
>>> z = ['blue', 'red', 'blue', 'yellow', 'blue', 'red']
>>> Counter(z)
Counter({'blue': 3, 'red': 2, 'yellow': 1})isinstance। इसलिए यदि आप उस डेटा के बारे में निश्चित हैं, जिसके साथ आप काम कर रहे हैं, तो टाइप और उदाहरण के बिना कस्टम फ़ंक्शन लिखना बेहतर हो सकता है।
isinstanceकहता है? लाखों स्ट्रिंग्स के साथ भी, कॉलिंग में Counterकेवल एक isinstanceकॉल शामिल है , यह जांचने के लिए कि क्या उसका तर्क एक मैपिंग है। आप सबसे अधिक गलत अनुमान लगा रहे हैं कि आपका सारा समय क्या खा रहा है।
Counterकई पुनरावृत्तियों को गिनने के बजाय अनुकूलन का प्रयास बड़े पुनरावृत्तियों को गिनने में चला गया है। एक लाख-स्ट्रिंग की गणना करने योग्य है जो Counterएक मैनुअल कार्यान्वयन के साथ तेजी से आगे बढ़ेगा । यदि आप updateकई पुनरावृत्तियों के साथ कॉल करना चाहते हैं , तो हो सकता है कि आप चीजों को एक साथ पुनरावृत्ति में शामिल करके गति बढ़ा सकें itertools.chain।
एक सूची में एक आइटम की घटनाओं की गिनती
केवल एक सूची आइटम की घटनाओं को गिनने के लिए जिसका आप उपयोग कर सकते हैं 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}काउंटर के साथ सभी वस्तुओं की गिनती ()
वैकल्पिक रूप Counterसे, collectionsलाइब्रेरी से तेज़ क्लास है
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]Counterबड़ी सूची के लिए तेजी से रास्ता है । सूची समझने की विधि O (n ^ 2) है, CounterO (n) होनी चाहिए।
isinstance। इसलिए यदि आप उस डेटा के बारे में निश्चित हैं, जिसके साथ आप काम कर रहे हैं, तो टाइप और उदाहरण के बिना कस्टम फ़ंक्शन लिखना बेहतर हो सकता है।
एक शब्दकोश में प्रत्येक आइटम की घटनाओं की संख्या प्राप्त करने का दूसरा तरीका:
dict((i, a.count(i)) for i in a)n * (number of different items)सेट बनाने में लगने वाले समय की गिनती नहीं करते हुए यह ऑपरेशन करेगा । का उपयोग करना collections.Counterवास्तव में बहुत बेहतर है।
i, तो कोड निम्न त्रुटि नहीं करेगा, क्योंकि यह एक शब्दकोश में एक ही मूल्य के कई कुंजी दर्ज करने का प्रयास करेगा। dict((i, a.count(i)) for i in a)
list.count(x)xकिसी सूची में बार-बार प्रकट होने वाला रिटर्न देता है
देखें: http://docs.python.org/tutorial/datastructures.html#more-on-lists
एक आइटम को देखते हुए, मैं पायथन में एक सूची में इसकी घटनाओं को कैसे गिन सकता हूं?
यहाँ एक उदाहरण सूची है:
>>> 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यह किसी भी सूची के लिए ठीक काम करता है। Tuples में भी यह विधि है:
>>> t = tuple('aabbbffffff')
>>> t
('a', 'a', 'b', 'b', 'b', 'f', 'f', 'f', 'f', 'f', 'f')
>>> t.count('f')
6collections.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})पांडा क्यों नहीं?
एक अन्य उत्तर बताता है:
पांडा का उपयोग क्यों नहीं करते?
पंडों एक सामान्य पुस्तकालय है, लेकिन यह मानक पुस्तकालय में नहीं है। इसे आवश्यकता के रूप में जोड़ना गैर-तुच्छ है।
इस उपयोग के मामले के लिए सूची ऑब्जेक्ट में और साथ ही मानक पुस्तकालय में अंतर्निहित समाधान हैं।
यदि आपकी परियोजना को पहले से ही पांडा की आवश्यकता नहीं है, तो यह केवल इस कार्यक्षमता के लिए एक आवश्यकता बनाने के लिए मूर्खतापूर्ण होगा।
मैं perfplot के साथ सभी सुझाए गए समाधानों (और कुछ नए) की तुलना कर चुका हूं (मेरी एक छोटी परियोजना) से की है।
एक की गिनती आइटम की
बड़े पर्याप्त सरणियों के लिए, यह पता चला है कि
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,
)यदि आप उपयोग कर सकते हैं pandas, तो value_countsबचाव के लिए है।
>>> import pandas as pd
>>> a = [1, 2, 3, 4, 1, 4, 1]
>>> pd.Series(a).value_counts()
1 3
4 2
3 1
2 1
dtype: int64यह स्वचालित रूप से आवृत्ति के आधार पर परिणाम को क्रमबद्ध करता है।
यदि आप परिणाम सूची में होना चाहते हैं, तो नीचे के रूप में करें
>>> pd.Series(a).value_counts().reset_index().values.tolist()
[[1, 3], [4, 2], [3, 1], [2, 1]]पंडों का उपयोग क्यों नहीं?
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मुझे आज यह समस्या हुई थी और मैंने एसओ को जांचने से पहले अपना खुद का समाधान निकाला। इस:
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 के लिए।
# 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)]नीचे तीन समाधान दिए गए हैं:
फास्टेस्ट लूप के लिए उपयोग कर रहा है और इसे डिक्ट में स्टोर कर रहा है।
import time
from collections import Counter
def countElement(a):
g = {}
for i in a:
if i in g:
g[i] +=1
else:
g[i] =1
return g
z = [1,1,1,1,2,2,2,2,3,3,4,5,5,234,23,3,12,3,123,12,31,23,13,2,4,23,42,42,34,234,23,42,34,23,423,42,34,23,423,4,234,23,42,34,23,4,23,423,4,23,4]
#Solution 1 - Faster
st = time.monotonic()
for i in range(1000000):
b = countElement(z)
et = time.monotonic()
print(b)
print('Simple for loop and storing it in dict - Duration: {}'.format(et - st))
#Solution 2 - Fast
st = time.monotonic()
for i in range(1000000):
a = Counter(z)
et = time.monotonic()
print (a)
print('Using collections.Counter - Duration: {}'.format(et - st))
#Solution 3 - Slow
st = time.monotonic()
for i in range(1000000):
g = dict([(i, z.count(i)) for i in set(z)])
et = time.monotonic()
print(g)
print('Using list comprehension - Duration: {}'.format(et - st))परिणाम
#Solution 1 - Faster
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 234: 3, 23: 10, 12: 2, 123: 1, 31: 1, 13: 1, 42: 5, 34: 4, 423: 3}
Simple for loop and storing it in dict - Duration: 12.032000000000153#Solution 2 - Fast
Counter({23: 10, 4: 6, 2: 5, 42: 5, 1: 4, 3: 4, 34: 4, 234: 3, 423: 3, 5: 2, 12: 2, 123: 1, 31: 1, 13: 1})
Using collections.Counter - Duration: 15.889999999999418#Solution 3 - Slow
{1: 4, 2: 5, 3: 4, 4: 6, 5: 2, 34: 4, 423: 3, 234: 3, 42: 5, 12: 2, 13: 1, 23: 10, 123: 1, 31: 1}
Using list comprehension - Duration: 33.0के साथ सभी तत्वों की गणना itertools.groupby()
सूची में सभी तत्वों की गिनती प्राप्त करने के लिए एंटोइर का योगदान itertools.groupby() ।
"डुप्लिकेट" मायने रखता है
from itertools import groupby
L = ['a', 'a', 'a', 't', 'q', 'a', 'd', 'a', 'd', 'c'] # Input list
counts = [(i, len(list(c))) for i,c in groupby(L)] # Create value-count pairs as list of tuples
print(counts)रिटर्न
[('a', 3), ('t', 1), ('q', 1), ('a', 1), ('d', 1), ('a', 1), ('d', 1), ('c', 1)]ध्यान दें कि इसने पहले तीन aको पहले समूह के रूप में कैसे संयोजित किया , जबकि अन्य समूह aसूची में नीचे मौजूद हैं। ऐसा इसलिए होता है क्योंकि इनपुट सूची Lको क्रमबद्ध नहीं किया गया था। यह कभी-कभी एक लाभ हो सकता है यदि समूहों को वास्तव में अलग होना चाहिए।
अनोखी गिनती के साथ
यदि अद्वितीय समूह गणना वांछित है, तो इनपुट सूची को क्रमबद्ध करें:
counts = [(i, len(list(c))) for i,c in groupby(sorted(L))]
print(counts)रिटर्न
[('a', 5), ('c', 1), ('d', 2), ('q', 1), ('t', 1)]नोट: अद्वितीय गणना बनाने के लिए, कई अन्य उत्तर groupbyसमाधान की तुलना में आसान और अधिक पठनीय कोड प्रदान करते हैं। लेकिन यह डुप्लिकेट काउंट उदाहरण के समानांतर खींचने के लिए यहां दिखाया गया है।
यह करने के लिए उपयोग numpy के सुझाव दिया गया था bincount , हालांकि इसके साथ 1 दिन सरणियों के लिए ही काम करता है गैर नकारात्मक पूर्णांक । इसके अलावा, परिणामी सरणी भ्रामक हो सकती है (इसमें पूर्णांक से लेकर मूल सूची की अधिकतम सीमा तक की घटनाएं शामिल हैं, और 0 से लापता पूर्णांक सेट करता है)।
सुपीरियर के साथ इसे करने का एक बेहतर तरीका यह है कि ट्रू को सेट किए गए विशेषता के साथ अद्वितीय फ़ंक्शन का उपयोग करें return_counts। यह अद्वितीय मानों की एक सरणी और प्रत्येक अद्वितीय मान की घटनाओं की एक सरणी के साथ एक टपल देता है।
# a = [1, 1, 0, 2, 1, 0, 3, 3]
a_uniq, counts = np.unique(a, return_counts=True) # array([0, 1, 2, 3]), array([2, 3, 1, 2]और फिर हम उन्हें जोड़ सकते हैं
dict(zip(a_uniq, counts)) # {0: 2, 1: 3, 2: 1, 3: 2}यह अन्य डेटा प्रकारों और "2d सूचियों" के साथ भी काम करता है, जैसे
>>> a = [['a', 'b', 'b', 'b'], ['a', 'c', 'c', 'a']]
>>> dict(zip(*np.unique(a, return_counts=True)))
{'a': 3, 'b': 3, 'c': 2}हालाँकि यह बहुत पुराना प्रश्न है, लेकिन जैसा कि मुझे एक लाइनर नहीं मिला, मैंने एक बनाया।
# original numbers in list
l = [1, 2, 2, 3, 3, 3, 4]
# empty dictionary to hold pair of number and its count
d = {}
# loop through all elements and store count
[ d.update( {i:d.get(i, 0)+1} ) for i in l ]
print(d)आप countOfएक अंतर्निहित मॉड्यूल की विधि का उपयोग भी कर सकते हैं operator।
>>> import operator
>>> operator.countOf([1, 2, 3, 4, 1, 4, 1], 1)
3countOfलागू किया जाता है? यह अधिक स्पष्ट list.count(सी कार्यान्वयन से लाभ) की तुलना कैसे करता है ? क्या कोई फायदे हैं?
सबसे कुशल नहीं हो सकता है, डुप्लिकेट को निकालने के लिए एक अतिरिक्त पास की आवश्यकता होती है।
कार्यात्मक कार्यान्वयन:
arr = np.array(['a','a','b','b','b','c'])
print(set(map(lambda x : (x , list(arr).count(x)) , arr)))रिटर्न:
{('c', 1), ('b', 3), ('a', 2)}या के रूप में वापसी dict:
print(dict(map(lambda x : (x , list(arr).count(x)) , arr)))रिटर्न:
{'b': 3, 'c': 1, 'a': 2}sum([1 for elem in <yourlist> if elem==<your_value>])यह आपके_लॉग के होने की मात्रा लौटा देगा
def countfrequncyinarray(arr1):
r=len(arr1)
return {i:arr1.count(i) for i in range(1,r+1)}
arr1=[4,4,4,4]
a=countfrequncyinarray(arr1)
print(a)l2=[1,"feto",["feto",1,["feto"]],['feto',[1,2,3,['feto']]]]
count=0
def Test(l):
global count
if len(l)==0:
return count
count=l.count("feto")
for i in l:
if type(i) is list:
count+=Test(i)
return count
print(Test(l2))यह पुनरावर्ती गणना करेगा या सूची में आइटम की खोज करेगा भले ही वह सूचियों की सूची में हो
mylist = [1,7,7,7,3,9,9,9,7,9,10,0] print sorted(set([i for i in mylist if mylist.count(i)>2]))