एक अनियंत्रित सूची में तत्वों की आवृत्ति की गणना कैसे करें?

Question

मुझे एक अनियंत्रित सूची में तत्वों की आवृत्ति खोजने की आवश्यकता है

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

output->

b = [4,4,2,1,2]

इसके अलावा, मैं एक से डुप्लिकेट को दूर करना चाहता हूँ

a = [1,2,3,4,5]

Comments

क्या उन्हें हमेशा उस उदाहरण की तरह आदेश दिया जाता है?

— फरनिहा

@Peter। हां, आपने पोस्ट करने के उद्देश्यों के लिए सूची को क्रमबद्ध किया है। क्या सूची को हमेशा क्रमबद्ध किया जाएगा?

— एस.लॉट

नहीं, सूची को हमेशा क्रमबद्ध नहीं किया जाएगा। यह होमवर्क नहीं है।

— ब्रूस

मैं एक नेटवर्क के डिग्री वितरण के ग्राफ को साजिश करने की कोशिश कर रहा हूं।

— ब्रूस

@Peter: कृपया उपयोगी जानकारी के साथ अपने प्रश्न को अपडेट करें। कृपया अपने प्रश्न में टिप्पणी न जोड़ें - आप इस प्रश्न के स्वामी हैं, आप इसे पूर्ण और स्पष्ट होने के लिए ठीक कर सकते हैं।

— एस.लॉट

Answer 1

नोट: उपयोग करने से पहले आपको सूची को सॉर्ट करना चाहिए groupby।

यदि सूची एक आदेशित सूची है तो आप पैकेज groupbyसे उपयोग कर सकते हैं itertools।

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
from itertools import groupby
[len(list(group)) for key, group in groupby(a)]

आउटपुट:

[4, 4, 2, 1, 2]

Comments

अच्छा है, का उपयोग कर groupby। मुझे आश्चर्य है कि इसकी दक्षता बनाम तानाशाही दृष्टिकोण के बारे में, हालांकि

— एली बेंडरस्की

जब यह मूल्य देखता है तो अजगर समूह में नए समूह बनाता है। इस मामले में 1,1,1,2,1,1,1] [3,1,3] वापस आएगा। यदि आप उम्मीद करते हैं [6,1] तो ग्रुपबी का उपयोग करने से पहले डेटा को सॉर्ट करना सुनिश्चित करें।

— इवान

@CristianCiupitu: sum(1 for _ in group)।

— मार्टिज़न पीटरर्स

यह कोई हल नहीं है। आउटपुट यह नहीं बताता कि क्या गिना गया था।

— १३:५

[(key, len(list(group))) for key, group in groupby(a)]या {key: len(list(group)) for key, group in groupby(a)}@buhtz

— एरिक पौली

Answer 2

पायथन 2.7 (या नए) में, आप उपयोग कर सकते हैं collections.Counter:

import collections
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
counter=collections.Counter(a)
print(counter)
# Counter({1: 4, 2: 4, 3: 2, 5: 2, 4: 1})
print(counter.values())
# [4, 4, 2, 1, 2]
print(counter.keys())
# [1, 2, 3, 4, 5]
print(counter.most_common(3))
# [(1, 4), (2, 4), (3, 2)]

यदि आप पाइथन 2.6 या अधिक पुराने का उपयोग कर रहे हैं, तो आप इसे यहाँ डाउनलोड कर सकते हैं ।

Comments

@unutbu: क्या होगा अगर मेरे पास तीन सूचियां हैं, ए, बी, सी जिसके लिए ए और बी एक ही है, लेकिन सी बदलता रहता है? C का मान कैसे गिनें जिसके लिए a और c समान हैं?

— thePredator

@ श्रीवत्सन: मुझे स्थिति समझ नहीं आ रही है। कृपया एक नया प्रश्न पोस्ट करें जहां आप विस्तृत कर सकते हैं।

— अनुतु

क्या काउंटर ऑब्जेक्ट से {1: 4, 2: 4, 3: 2, 5: 2, 4: 1} शब्दकोश निकालने का कोई तरीका है?

— पवन

@ पावन: collections.Counterका एक उपवर्ग है dict। आप इसे उसी तरह से उपयोग कर सकते हैं जिस तरह से आप सामान्य तानाशाही करेंगे। यदि आप वास्तव में एक तानाशाही चाहते हैं, तो आप इसे एक तानाशाह के रूप में बदल सकते हैं dict(counter)।

— 22:15

3.6 में भी काम करता है, इसलिए 2.7 से अधिक कुछ भी मान लें

— kpierce8

Answer 3

पायथन 2.7+ डिक्शनरी कांसेप्ट का परिचय देता है। सूची से शब्दकोश का निर्माण आपको गिनती के साथ-साथ डुप्लिकेट से छुटकारा दिलाएगा।

>>> a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>> d = {x:a.count(x) for x in a}
>>> d
{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}
>>> a, b = d.keys(), d.values()
>>> a
[1, 2, 3, 4, 5]
>>> b
[4, 4, 2, 1, 2]

Comments

यह वास्तव में अच्छी तरह से स्ट्रिंग की सूचियों के साथ काम करता है जैसा कि मूल प्रश्न पूछे जाने वाले पूर्णांक के विपरीत है।

— Glen Selle

यह तेजी से एक सेट का उपयोग कर रहा है:{x:a.count(x) for x in set(a)}

— स्टेंकी

यह बेहद अक्षम है । प्रत्येक तत्व के लिए a.count()एक पूर्ण पार करता है a, जिससे यह O (N ^ 2) द्विघात दृष्टिकोण बन जाता है। collections.Counter()है और अधिक कुशल क्योंकि यह रेखीय समय (ओ (एन)) में गिना जाता है। संख्याओं में, इसका अर्थ है कि यह दृष्टिकोण 1000 की लंबाई की सूची के लिए 1 मिलियन चरणों का निष्पादन करेगा, बनाम केवल 1000 चरणों के साथ Counter(), 10 ^ 12 चरणों में जहां केवल 10 ^ 6 की आवश्यकता होती है काउंटर द्वारा एक सूची में एक लाख वस्तुओं के लिए, आदि

— Martijn Pieters

@stenci: यकीन है, लेकिन a.count()पूरी तरह से उपयोग करने का डर वहाँ एक सेट का उपयोग करने की दक्षता को बौना करता है।

— मार्टिन पीटर्स

— @MartijnPieters

Answer 4

दिखावे की संख्या की गणना करने के लिए:

from collections import defaultdict

appearances = defaultdict(int)

for curr in a:
    appearances[curr] += 1

डुप्लिकेट को निकालने के लिए:

a = set(a) 

Comments

संग्रह के लिए +1 .faultdict। इसके अलावा, अजगर 3.x में, संग्रह देखें। मुठभेड़। यह collection.defaultdict (int) के समान है।

— हुग्डब्रोर्न

@hughdbrown, वास्तव में या केवल नहीं Counterसहित कई संख्यात्मक प्रकारों का उपयोग कर सकता है । floatDecimalint

— बजे क्रिस्टियन सियुपिटु

Answer 5

पायथन 2.7+ में, आप आइटमों को गिनने के लिए संग्रहों का उपयोग कर सकते हैं

>>> a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>>
>>> from collections import Counter
>>> c=Counter(a)
>>>
>>> c.values()
[4, 4, 2, 1, 2]
>>>
>>> c.keys()
[1, 2, 3, 4, 5]

Comments

डिफ़ॉल्ट डिफॉल्ट की तुलना में काउंटर बहुत धीमा है, और डिफॉल्ट तानाशाह एक तानाशाह के मैनुअल उपयोग की तुलना में बहुत धीमा है।

— जोनाथन रे

@JonathanRay, अब और नहीं, stackoverflow.com/a/27802189/1382487 ।

— wsaleem

Answer 6

तत्वों की आवृत्ति की गणना संभवतः एक शब्दकोश के साथ की जाती है:

b = {}
for item in a:
    b[item] = b.get(item, 0) + 1

डुप्लिकेट को निकालने के लिए, एक सेट का उपयोग करें:

a = list(set(a))

Comments

@ शेखर: मेरा इससे थोड़ा ही बेहतर होगा। जब एक छोटे से बदलाव के साथ इसमें सुधार किया जा सकता है, तो शायद ही कोई अलग जवाब देने के लायक हो। SO का बिंदु सबसे अच्छे उत्तरों को प्राप्त करना है। मैं बस इसे संपादित कर सकता था, लेकिन मैं मूल लेखक को अपने सुधार करने का मौका देना पसंद करता हूं।

— एस.लॉट

@ S.Lott आयात किए बिना कोड बहुत क्लीनर है defaultdict।

— bstrauch24

क्यों नहीं पूर्वसंक्रमण b b = {k:0 for k in a}:?

— डायलनयुंग

Answer 7

यहां एक और रसीला विकल्प है itertools.groupbyजिसका उपयोग अनऑर्डर किए गए इनपुट के लिए भी किया जाता है:

from itertools import groupby

items = [5, 1, 1, 2, 2, 1, 1, 2, 2, 3, 4, 3, 5]

results = {value: len(list(freq)) for value, freq in groupby(sorted(items))}

परिणाम

{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}

Answer 8

तुम यह केर सकते हो:

import numpy as np
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
np.unique(a, return_counts=True)

आउटपुट:

(array([1, 2, 3, 4, 5]), array([4, 4, 2, 1, 2], dtype=int64))

पहला सरणी मान है, और दूसरा सरणी इन मानों के साथ तत्वों की संख्या है।

इसलिए यदि आप संख्याओं को प्राप्त करना चाहते हैं तो आपको इसका उपयोग करना चाहिए:

np.unique(a, return_counts=True)[1]

Answer 9

from collections import Counter
a=["E","D","C","G","B","A","B","F","D","D","C","A","G","A","C","B","F","C","B"]

counter=Counter(a)

kk=[list(counter.keys()),list(counter.values())]

pd.DataFrame(np.array(kk).T, columns=['Letter','Count'])

Comments

हालांकि यह कोड स्निपेट समाधान हो सकता है, जिसमें स्पष्टीकरण भी शामिल है, जो आपके पोस्ट की गुणवत्ता को बेहतर बनाने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और उन लोगों को आपके कोड सुझाव के कारणों का पता नहीं चल सकता है

— राहुल गुप्ता

हां राहुल गुप्ता

— अनिर्बान लाहिड़ी

Answer 10

seta = set(a)
b = [a.count(el) for el in seta]
a = list(seta) #Only if you really want it.

Comments

countइस परिदृश्य में सूचियों का उपयोग हास्यास्पद रूप से महंगा और अनकहा है।

— इदं के

@IdanK क्यों गिना जाता है महंगा?

— कृतिका राजेन

@KritikaRajain सूची में प्रत्येक अद्वितीय तत्व के लिए आप एक सूची बनाने के लिए पूरी सूची पर पुनरावृति करते हैं (सूची में अद्वितीय तत्वों की संख्या में द्विघात)। इसके बजाय, आप एक बार सूची पर पुनरावृति कर सकते हैं और प्रत्येक अद्वितीय तत्व (सूची के आकार में रैखिक) की संख्या को गिन सकते हैं। यदि आपकी सूची में केवल एक अद्वितीय तत्व है, तो परिणाम समान होगा। इसके अलावा, इस दृष्टिकोण के लिए एक अतिरिक्त मध्यवर्ती सेट की आवश्यकता होती है।

— डायलनयुंग

Answer 11

मैं बस निम्नलिखित तरीके से scipy.stats.itemfreq का उपयोग करूंगा:

from scipy.stats import itemfreq

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

freq = itemfreq(a)

a = freq[:,0]
b = freq[:,1]

आप यहां दस्तावेज देख सकते हैं: http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html

Answer 12

अपने पहले प्रश्न के लिए, सूची को पुनरावृत्त करें और तत्वों के अस्तित्व पर नज़र रखने के लिए एक शब्दकोश का उपयोग करें।

अपने दूसरे प्रश्न के लिए, बस सेट ऑपरेटर का उपयोग करें।

Comments

क्या आप पहले उत्तर पर विस्तार से बता सकते हैं

— ब्रूस

Answer 13

यह उत्तर अधिक स्पष्ट है

a = [1,1,1,1,2,2,2,2,3,3,3,4,4]

d = {}
for item in a:
    if item in d:
        d[item] = d.get(item)+1
    else:
        d[item] = 1

for k,v in d.items():
    print(str(k)+':'+str(v))

# output
#1:4
#2:4
#3:3
#4:2

#remove dups
d = set(a)
print(d)
#{1, 2, 3, 4}

Answer 14

def frequencyDistribution(data):
    return {i: data.count(i) for i in data}   

print frequencyDistribution([1,2,3,4])

...

 {1: 1, 2: 1, 3: 1, 4: 1}   # originalNumber: count

Answer 15

मुझे काफी देर हो गई है, लेकिन यह भी काम करेगा, और दूसरों की मदद करेगा:

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
freq_list = []
a_l = list(set(a))

for x in a_l:
    freq_list.append(a.count(x))


print 'Freq',freq_list
print 'number',a_l

यह उत्पादन करेगा ..

Freq  [4, 4, 2, 1, 2]
number[1, 2, 3, 4, 5]

Answer 16

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

# 1. Get counts and store in another list
output = []
for i in set(a):
    output.append(a.count(i))
print(output)

# 2. Remove duplicates using set constructor
a = list(set(a))
print(a)

1. सेट संग्रह डुप्लिकेट की अनुमति नहीं देता है, सेट () कंस्ट्रक्टर को एक सूची पास करने से पूरी तरह से अद्वितीय वस्तुओं का पुनरावृत्ति होगा। गणना () फ़ंक्शन एक पूर्णांक गणना देता है जब कोई ऑब्जेक्ट जो सूची में है पारित हो जाता है। इसके साथ अद्वितीय वस्तुओं को गिना जाता है और प्रत्येक सूची मान को खाली सूची आउटपुट में जोड़कर संग्रहीत किया जाता है
2. सूची () कंस्ट्रक्टर का उपयोग सेट (ए) को सूची में बदलने के लिए किया जाता है और उसी चर द्वारा संदर्भित किया जाता है

उत्पादन

D:\MLrec\venv\Scripts\python.exe D:/MLrec/listgroup.py
[4, 4, 2, 1, 2]
[1, 2, 3, 4, 5]

Answer 17

शब्दकोश का उपयोग करते हुए सरल समाधान।

def frequency(l):
     d = {}
     for i in l:
        if i in d.keys():
           d[i] += 1
        else:
           d[i] = 1

     for k, v in d.iteritems():
        if v ==max (d.values()):
           return k,d.keys()

print(frequency([10,10,10,10,20,20,20,20,40,40,50,50,30]))

Comments

max(d.values())अंतिम लूप में नहीं बदलेगा। इसे लूप में गणना न करें, लूप से पहले की गणना करें ।

— डायलनयुंग

Answer 18

#!usr/bin/python
def frq(words):
    freq = {}
    for w in words:
            if w in freq:
                    freq[w] = freq.get(w)+1
            else:
                    freq[w] =1
    return freq

fp = open("poem","r")
list = fp.read()
fp.close()
input = list.split()
print input
d = frq(input)
print "frequency of input\n: "
print d
fp1 = open("output.txt","w+")
for k,v in d.items():
fp1.write(str(k)+':'+str(v)+"\n")
fp1.close()

Answer 19

num=[3,2,3,5,5,3,7,6,4,6,7,2]
print ('\nelements are:\t',num)
count_dict={}
for elements in num:
    count_dict[elements]=num.count(elements)
print ('\nfrequency:\t',count_dict)

Comments

कृपया कोड-केवल उत्तर पोस्ट न करें, लेकिन अपना कोड स्पष्ट करें, खासकर जब किसी प्रश्न का पहले से ही मान्य उत्तर हो।

— एरिक

Answer 20

from collections import OrderedDict
a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
def get_count(lists):
    dictionary = OrderedDict()
    for val in lists:
        dictionary.setdefault(val,[]).append(1)
    return [sum(val) for val in dictionary.values()]
print(get_count(a))
>>>[4, 4, 2, 1, 2]

डुप्लिकेट हटाने और ऑर्डर बनाए रखने के लिए:

list(dict.fromkeys(get_count(a)))
>>>[4, 2, 1]

Answer 21

मैं एक फ्रीक उत्पन्न करने के लिए काउंटर का उपयोग कर रहा हूँ। कोड की 1 पंक्ति में पाठ फ़ाइल शब्दों से तानाशाही

def _fileIndex(fh):
''' create a dict using Counter of a
flat list of words (re.findall(re.compile(r"[a-zA-Z]+"), lines)) in (lines in file->for lines in fh)
'''
return Counter(
    [wrd.lower() for wrdList in
     [words for words in
      [re.findall(re.compile(r'[a-zA-Z]+'), lines) for lines in fh]]
     for wrd in wrdList])

Answer 22

ऐसा करने का एक और दृष्टिकोण, भारी लेकिन शक्तिशाली पुस्तकालय का उपयोग करके यद्यपि - एनएलटीके।

import nltk

fdist = nltk.FreqDist(a)
fdist.values()
fdist.most_common()

Answer 23

फिर भी संग्रह का उपयोग किए बिना दूसरे एल्गोरिथ्म के साथ एक और समाधान:

def countFreq(A):
   n=len(A)
   count=[0]*n                     # Create a new list initialized with '0'
   for i in range(n):
      count[A[i]]+= 1              # increase occurrence for value A[i]
   return [x for x in count if x]  # return non-zero count

Answer 24

आप अजगर में प्रदान किए गए इन-बिल्ट फ़ंक्शन का उपयोग कर सकते हैं

l.count(l[i])


  d=[]
  for i in range(len(l)):
        if l[i] not in d:
             d.append(l[i])
             print(l.count(l[i])

उपरोक्त कोड स्वचालित रूप से एक सूची में डुप्लिकेट को हटा देता है और मूल सूची और डुप्लिकेट के बिना सूची में प्रत्येक तत्व की आवृत्ति को प्रिंट करता है।

एक शॉट के लिए दो पक्षी! एक्सडी

Answer 25

यदि आप किसी भी पुस्तकालय का उपयोग नहीं करना चाहते हैं और इसे सरल और संक्षिप्त रखना चाहते हैं, तो इस दृष्टिकोण की कोशिश की जा सकती है!

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
marked = []
b = [(a.count(i), marked.append(i))[0] for i in a if i not in marked]
print(b)

ओ / p

[4, 4, 2, 1, 2]

Answer 26

रिकॉर्ड के लिए, एक कार्यात्मक उत्तर:

>>> L = [1,1,1,1,2,2,2,2,3,3,4,5,5]
>>> import functools
>>> >>> functools.reduce(lambda acc, e: [v+(i==e) for i, v in enumerate(acc,1)] if e<=len(acc) else acc+[0 for _ in range(e-len(acc)-1)]+[1], L, [])
[4, 4, 2, 1, 2]

यदि आप शून्य को भी गिनें तो यह क्लीनर है:

>>> functools.reduce(lambda acc, e: [v+(i==e) for i, v in enumerate(acc)] if e<len(acc) else acc+[0 for _ in range(e-len(acc))]+[1], L, [])
[0, 4, 4, 2, 1, 2]

एक स्पष्टीकरण:

• हम एक खाली accसूची से शुरू करते हैं ;
• अगर अगले तत्व eकी Lके आकार की तुलना में कम है acc, हम सिर्फ इस तत्व को अद्यतन: v+(i==e)साधन v+1अगर सूचकांक iकी accमौजूदा तत्व है e, अन्यथा पिछले मानv ;
• अगर अगले तत्व eकी Lअधिक से अधिक है या के आकार के बराबर होती है acc, हम विस्तार करने के लिए है accनई होस्ट करने के लिए 1।

तत्वों को छांटना नहीं है ( itertools.groupby)। यदि आपके पास ऋणात्मक संख्या है, तो आपको अजीब परिणाम मिलेंगे।

Answer 27

ऐसा करने का एक और तरीका मिला, सेट का उपयोग करना।

#ar is the list of elements
#convert ar to set to get unique elements
sock_set = set(ar)

#create dictionary of frequency of socks
sock_dict = {}

for sock in sock_set:
    sock_dict[sock] = ar.count(sock)

Answer 28

सूची में अद्वितीय तत्वों को खोजने के लिए

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
a = list(set(a))

शब्दकोश का उपयोग करके एक क्रमबद्ध सरणी में अद्वितीय तत्वों की गिनती को खोजने के लिए

def CountFrequency(my_list): 
# Creating an empty dictionary  
freq = {} 
for item in my_list: 
    if (item in freq): 
        freq[item] += 1
    else: 
        freq[item] = 1

for key, value in freq.items(): 
    print ("% d : % d"%(key, value))

# Driver function 
if __name__ == "__main__":  
my_list =[1, 1, 1, 5, 5, 3, 1, 3, 3, 1, 4, 4, 4, 2, 2, 2, 2] 

CountFrequency(my_list)

संदर्भ GeeksforGeeks

Answer 29

एक और तरीका एक शब्दकोश और सूची का उपयोग करना है। इसे करने के लिए एक भोली तरीके से नीचे सूची।

dicio = dict()

a = [1,1,1,1,2,2,2,2,3,3,4,5,5]

b = list()

c = list()

for i in a:

   if i in dicio: continue 

   else:

      dicio[i] = a.count(i)

      b.append(a.count(i))

      c.append(i)

print (b)

print (c)

Answer 30

a=[1,2,3,4,5,1,2,3]
b=[0,0,0,0,0,0,0]
for i in range(0,len(a)):
    b[a[i]]+=1