blocks|key|321004|text|对于您的第一个问题，迭代列表并使用字典来跟踪元素的存在。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321005|对于第二个问题，只需使用set运算符。|321006|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

For your first question, iterate the list and use a dictionary to keep track of an elements existsence. 

For your second question, just use the set operator.

blocks|key|3278389|text|要计算出现次数，请执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3278390|from+collections+import+defaultdict

appearances+=+defaultdict(int)

for+curr+in+a:
++++appearances[curr]+%2B=+1|code-block|syntax|javascript|3278391|要删除重复项，请执行以下操作：|3278392|a+=+set(a)+|3278393|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To count the number of appearances:

<pre><code>from collections import defaultdict

appearances = defaultdict(int)

for curr in a:
 appearances[curr] += 1
</code></pre>

To remove duplicates:

<pre><code>a = set(a) 
</code></pre>

blocks|key|321026|text|计算元素的频率可能最好使用字典来完成：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321027|b+=+{}
for+item+in+a:
++++b[item]+=+b.get(item,+0)+%2B+1|code-block|syntax|javascript|321028|要删除重复项，请使用以下集合：|321029|a+=+list(set(a))|321030|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Counting the frequency of elements is probably best done with a dictionary:

<pre><code>b = {}
for item in a:
 b[item] = b.get(item, 0) + 1
</code></pre>

To remove the duplicates, use a set:

<pre><code>a = list(set(a))
</code></pre>

blocks|key|3278419|text|seta+=+set(a)
b+=+[a.count(el)+for+el+in+seta]
a+=+list(seta)+#Only+if+you+really+want+it.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3278420|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|3065421|text|注意:在使用+groupby**.**之前，应对列表进行排序|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|3065422|如果列表是有序列表，则可以使用itertools包中的groupby。|3065423|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)]|code-block|syntax|javascript|3065424|输出：|3065425|[4,+4,+2,+1,+2]|3065426|更新:请注意，排序需要O(n+log(n))时间。|3065427|entityMap^0|0|6|7|9|7|7|0|F|9|R|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|12|8|@$9|13|A|14|B|D]|$9|15|A|16|B|D]]|E|@]|F|$]]|$1|I|3|J|5|K|7|17|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|18|8|@]|E|@]|F|$]]|$1|P|3|Q|5|K|7|19|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|1A|8|@]|E|@]|F|$]]|$1|T|3|-4|5|6|7|1B|8|@]|E|@]|F|$]]]|U|$]]

Note: You should sort the list before using <code>groupby</code>.
You can use <code>groupby</code> from <code>itertools</code> package if the list is an ordered list.
<pre class="lang-py prettyprint-override"><code>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)]
</code></pre>
Output:
<pre><code>[4, 4, 2, 1, 2]
</code></pre>
update: Note that sorting takes O(n log(n)) time.

blocks|key|318143|text|在Python+2.7%2B中，您可以使用collections.Counter对项目进行计数|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|318144|>>>+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]|code-block|syntax|javascript|318145|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/3.1/whatsnew/2.7.html#new-improved-and-deprecated-modules^0|J|J|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In Python 2.7+, you could use <a href="http://docs.python.org/3.1/whatsnew/2.7.html#new-improved-and-deprecated-modules" rel="noreferrer">collections.Counter</a> to count items

<pre><code>&gt;&gt;&gt; a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
&gt;&gt;&gt;
&gt;&gt;&gt; from collections import Counter
&gt;&gt;&gt; c=Counter(a)
&gt;&gt;&gt;
&gt;&gt;&gt; c.values()
[4, 4, 2, 1, 2]
&gt;&gt;&gt;
&gt;&gt;&gt; c.keys()
[1, 2, 3, 4, 5]
</code></pre>

blocks|key|319196|text|在Python2.7(或更高版本)中，可以使用collections.Counter|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|319197|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)]

print(dict(counter))
#+{1:+4,+2:+4,+3:+2,+5:+2,+4:+1}|code-block|syntax|javascript|319198|如果你使用的是Python2.6或更早的版本，你可以下载here。|319199|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/library/collections.html#collections.Counter|1|http://code.activestate.com/recipes/576611/^0|N|J|N|J|0|0|0|S|4|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|M|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

In Python 2.7 (or newer), you can use <a href="https://docs.python.org/library/collections.html#collections.Counter" rel="noreferrer"><code>collections.Counter</code></a>:
<pre><code>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)]

print(dict(counter))
# {1: 4, 2: 4, 3: 2, 5: 2, 4: 1}
</code></pre>
If you are using Python 2.6 or older, you can download it <a href="http://code.activestate.com/recipes/576611/" rel="noreferrer">here</a>.

blocks|key|319201|text|Python+2.7%2B引入了字典理解。从列表中构建字典将为您提供计数并消除重复项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319202|>>>+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]|code-block|syntax|javascript|319203|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Python 2.7+ introduces Dictionary Comprehension. Building the dictionary from the list will get you the count as well as get rid of duplicates.

<pre><code>&gt;&gt;&gt; a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
&gt;&gt;&gt; d = {x:a.count(x) for x in a}
&gt;&gt;&gt; d
{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}
&gt;&gt;&gt; a, b = d.keys(), d.values()
&gt;&gt;&gt; a
[1, 2, 3, 4, 5]
&gt;&gt;&gt; b
[4, 4, 2, 1, 2]
</code></pre>

blocks|key|3278576|text|这个答案更明确。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3278577|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)%2B1
++++else:
++++++++d[item]+=+1

for+k,v+in+d.items():
++++print(str(k)%2B':'%2Bstr(v))

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

#remove+dups
d+=+set(a)
print(d)
#{1,+2,+3,+4}|code-block|syntax|javascript|3278578|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This answer is more explicit

<pre><code>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}
</code></pre>

blocks|key|3065550|text|#!usr/bin/python
def+frq(words):
++++freq+=+{}
++++for+w+in+words:
++++++++++++if+w+in+freq:
++++++++++++++++++++freq[w]+=+freq.get(w)%2B1
++++++++++++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%2B")
for+k,v+in+d.items():
fp1.write(str(k)%2B':'%2Bstr(v)%2B"\n")
fp1.close()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3065551|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#!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()
</code></pre>

blocks|key|316162|text|还有另一种不使用集合的算法的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316163|def+countFreq(A):
+++n=len(A)
+++count=[0]*n+++++++++++++++++++++#+Create+a+new+list+initialized+with+'0'
+++for+i+in+range(n):
++++++count[A[i]]%2B=+1++++++++++++++#+increase+occurrence+for+value+A[i]
+++return+[x+for+x+in+count+if+x]++#+return+non-zero+count|code-block|syntax|javascript|316164|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yet another solution with another algorithm without using collections:

<pre><code>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
</code></pre>

blocks|key|3278614|text|我将简单地以以下方式使用scipy.stats.itemfreq：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3278615|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]|code-block|syntax|javascript|3278616|您可以在此处查看文档：http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html|offset|length|3278617|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html^0|0|0|B|2C|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I would simply use scipy.stats.itemfreq in the following manner:

<pre><code>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]
</code></pre>

you may check the documentation here: <a href="http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html" rel="noreferrer">http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.stats.itemfreq.html</a>

blocks|key|319249|text|def+frequencyDistribution(data):
++++return+{i:+data.count(i)+for+i+in+data}+++

print+frequencyDistribution([1,2,3,4])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|319250|..。|unstyled|319251|+{1:+1,+2:+1,+3:+1,+4:+1}+++#+originalNumber:+count|319252|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>def frequencyDistribution(data):
 return {i: data.count(i) for i in data} 

print frequencyDistribution([1,2,3,4])
</code></pre>

...

<pre><code> {1: 1, 2: 1, 3: 1, 4: 1} # originalNumber: count
</code></pre>

blocks|key|3065580|text|str1='the+cat+sat+on+the+hat+hat'
list1=str1.split();
list2=str1.split();

count=0;
m=[];

for+i+in+range(len(list1)):
++++t=list1.pop(0);
++++print+t
++++for+j+in+range(len(list2)):
++++++++if(t==list2[j]):
++++++++++++count=count%2B1;
++++++++++++print+count
++++m.append(count)
++++print+m
++++count=0;
#print+m|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3065581|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>str1='the cat sat on the hat hat'
list1=str1.split();
list2=str1.split();

count=0;
m=[];

for i in range(len(list1)):
 t=list1.pop(0);
 print t
 for j in range(len(list2)):
 if(t==list2[j]):
 count=count+1;
 print count
 m.append(count)
 print m
 count=0;
#print m
</code></pre>

blocks|key|3278627|text|另一种方法是使用字典和list.count，下面是一种天真的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3278628|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)|code-block|syntax|javascript|3278629|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One more way is to use a dictionary and the list.count, below a naive way to do it.

<pre><code>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)
</code></pre>

blocks|key|321161|text|您可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321162|import+numpy+as+np
a+=+[1,1,1,1,2,2,2,2,3,3,4,5,5]
np.unique(a,+return_counts=True)|code-block|syntax|javascript|321163|输出：|321164|(array([1,+2,+3,+4,+5]),+array([4,+4,+2,+1,+2],+dtype=int64))|321165|第一个数组是值，第二个数组是具有这些值的元素的数量。|321166|所以，如果你只想得到包含数字的数组，你应该使用下面的代码：|321167|np.unique(a,+return_counts=True)[1]|321168|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can do this:

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

Output:

<pre><code>(array([1, 2, 3, 4, 5]), array([4, 4, 2, 1, 2], dtype=int64))
</code></pre>

The first array is values, and the second array is the number of elements with these values.

So If you want to get just array with the numbers you should use this:

<pre><code>np.unique(a, return_counts=True)[1]
</code></pre>

blocks|key|319257|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|319258|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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)
</code></pre>

blocks|key|316226|text|可以使用python中提供的内置函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316227|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])|code-block|syntax|javascript|316228|上面的代码自动删除列表中的重复项，并打印原始列表和没有重复项的列表中每个元素的频率。|316229|一枪两鸟！X+D|316230|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You can use the in-built function provided in python

<pre><code>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])
</code></pre>

The above code automatically removes duplicates in a list and also prints the frequency of each element in original list and the list without duplicates.

Two birds for one shot ! X D

blocks|key|3065640|text|如果您不想使用任何库并保持它的简单和简短，可以尝试这种方法！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3065641|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)|code-block|syntax|javascript|3065642|o/p|3065643|[4,+4,+2,+1,+2]|3065644|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This approach can be tried if you don't want to use any library and keep it simple and short!

<pre><code>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)
</code></pre>

o/p

<pre><code>[4, 4, 2, 1, 2]
</code></pre>

blocks|key|3278690|text|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'])|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3278691|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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'])
</code></pre>

blocks|key|3278693|text|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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3278694|要删除重复项并维护顺序，请执行以下操作：|unstyled|3278695|list(dict.fromkeys(get_count(a)))
>>>[4,+2,+1]|3278696|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>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))
&gt;&gt;&gt;[4, 4, 2, 1, 2]
</code></pre>

To remove duplicates and Maintain order:

<pre><code>list(dict.fromkeys(get_count(a)))
&gt;&gt;&gt;[4, 2, 1]
</code></pre>

blocks|key|321201|text|我正在使用计数器来生成一个频率。在一行代码中从文本文件单词中提取字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321202|def+_fileIndex(fh):
'''+create+a+dict+using+Counter+of+a
flat+list+of+words+(re.findall(re.compile(r"[a-zA-Z]%2B"),+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]%2B'),+lines)+for+lines+in+fh]]
+++++for+wrd+in+wrdList])|code-block|syntax|javascript|321203|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i'm using Counter to generate a freq. dict from text file words in 1 line of code

<pre><code>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-&gt;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])
</code></pre>

blocks|key|3278721|text|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]]%2B=1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3278722|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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
</code></pre>

blocks|key|321205|text|我来晚了，但这也会起作用，并对其他人有所帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321206|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|code-block|syntax|javascript|321207|会产生这样的结果..|321208|Freq++[4,+4,+2,+1,+2]
number[1,+2,+3,+4,+5]|321209|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I am quite late, but this will also work, and will help others: 

<pre><code>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
</code></pre>

will produce this..

<pre><code>Freq [4, 4, 2, 1, 2]
number[1, 2, 3, 4, 5]
</code></pre>

blocks|key|318299|text|对于记录，我给出一个功能性的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|318300|>>>+L+=+[1,1,1,1,2,2,2,2,3,3,4,5,5]
>>>+import+functools
>>>+>>>+functools.reduce(lambda+acc,+e:+[v%2B(i==e)+for+i,+v+in+enumerate(acc,1)]+if+e<=len(acc)+else+acc%2B[0+for+_+in+range(e-len(acc)-1)]%2B[1],+L,+[])
[4,+4,+2,+1,+2]|code-block|syntax|javascript|318301|如果你也数零，那就更干净了：|318302|>>>+functools.reduce(lambda+acc,+e:+[v%2B(i==e)+for+i,+v+in+enumerate(acc)]+if+e<len(acc)+else+acc%2B[0+for+_+in+range(e-len(acc))]%2B[1],+L,+[])
[0,+4,+4,+2,+1,+2]|318303|一个解释：|318304|318305|我们从一个空的acc列表开始；|unordered-list-item|offset|length|style|CODE|318306|如果e的下一个元素L小于acc的大小，我们只更新此元素：v%2B(i==e)表示D11如果acc的索引D12是当前元素e，否则L的下一个元素e的前一个值大于或等于acc的大小，我们必须展开acc才能承载新的1.|318307|318308|元素不必排序(itertools.groupby)。如果你有负数，你会得到奇怪的结果。|318309|entityMap^0|0|0|0|0|0|0|7|3|0|2|1|9|1|C|3|S|8|17|3|1L|1|1P|1|1W|1|27|3|2K|3|2T|1|0|0|7|H|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|17|8|@$Q|18|R|19|S|T]]|9|@]|A|$]]|$1|U|3|V|5|P|7|1A|8|@$Q|1B|R|1C|S|T]|$Q|1D|R|1E|S|T]|$Q|1F|R|1G|S|T]|$Q|1H|R|1I|S|T]|$Q|1J|R|1K|S|T]|$Q|1L|R|1M|S|T]|$Q|1N|R|1O|S|T]|$Q|1P|R|1Q|S|T]|$Q|1R|R|1S|S|T]|$Q|1T|R|1U|S|T]|$Q|1V|R|1W|S|T]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Y|8|@$Q|1Z|R|20|S|T]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|10|$]]

For the record, a functional answer:

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

It's cleaner if you count zeroes too:

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

An explanation:

<ul>
<li>we start with an empty <code>acc</code> list;</li>
<li>if the next element <code>e</code> of <code>L</code> is lower than the size of <code>acc</code>, we just update this element: <code>v+(i==e)</code> means <code>v+1</code> if the index <code>i</code> of <code>acc</code> is the current element <code>e</code>, otherwise the previous value <code>v</code>;</li>
<li>if the next element <code>e</code> of <code>L</code> is greater or equals to the size of <code>acc</code>, we have to expand <code>acc</code> to host the new <code>1</code>.</li>
</ul>

The elements do not have to be sorted (<code>itertools.groupby</code>). You'll get weird results if you have negative numbers.

blocks|key|316262|text|下面是另一个使用itertools.groupby的成功替代方案，它也适用于无序输入：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|316263|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))}|code-block|syntax|javascript|316264|结果|BOLD|316265|{1:+4,+2:+4,+3:+2,+4:+1,+5:+2}|316266|entityMap^0|8|H|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|V|8|@$9|W|A|X|B|M]]|D|@]|E|$]]|$1|N|3|O|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

Here's another succint alternative using <code>itertools.groupby</code> which also works for unordered input:

<pre><code>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))}
</code></pre>

results

<pre><code>{1: 4, 2: 4, 3: 2, 4: 1, 5: 2}
</code></pre>

blocks|key|3278813|text|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)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3278814|set集合不允许重复，将列表传递给|unstyled|3278815|()构造函数将给出完全唯一的对象的可迭代。count()函数在传递列表中的对象时返回整数计数。这样，就会对唯一的对象进行计数，并通过将每个计数值追加到空列表中来存储这些值。输出列表使用|ordered-list-item|3278816|()构造函数将集合(A)转换为列表，并由同一变量|3278817|引用|3278818|输出|3278819|D:\MLrec\venv\Scripts\python.exe+D:/MLrec/listgroup.py
[4,+4,+2,+1,+2]
[1,+2,+3,+4,+5]|3278820|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|F|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|Y|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|R|3|-4|5|F|7|10|8|@]|9|@]|A|$]]]|S|$]]

<pre><code>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)
</code></pre>

<ol>
<li>Set collection does not allow duplicates, passing a list to the set() constructor will give an iterable of totally unique objects. count() function returns an integer count when an object that is in a list is passed. With that the unique objects are counted and each count value is stored by appending to an empty list output</li>
<li>list() constructor is used to convert the set(a) into list and referred by the same variable a </li>
</ol>

Output

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

blocks|key|3278831|text|使用字典的简单解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3278832|def+frequency(l):
+++++d+=+{}
+++++for+i+in+l:
++++++++if+i+in+d.keys():
+++++++++++d[i]+%2B=+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]))|code-block|syntax|javascript|3278833|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Simple solution using a dictionary.

<pre><code>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]))
</code></pre>

blocks|key|318341|text|这是另一种方法，尽管使用了一个更重但功能更强大的库-+NLTK。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|318342|import+nltk

fdist+=+nltk.FreqDist(a)
fdist.values()
fdist.most_common()|code-block|syntax|javascript|318343|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another approach of doing this, albeit by using a heavier but powerful library - NLTK.

<pre><code>import nltk

fdist = nltk.FreqDist(a)
fdist.values()
fdist.most_common()
</code></pre>

blocks|key|319357|text|我找到了另一种方法，使用集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|319358|#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)|code-block|syntax|javascript|319359|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Found another way of doing this, using sets.

<pre><code>#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)
</code></pre>

blocks|key|316294|text|要在列表中查找唯一元素：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316295|a+=+[1,1,1,1,2,2,2,2,3,3,4,5,5]
a+=+list(set(a))|code-block|syntax|javascript|316296|要使用字典查找排序数组中唯一元素的计数：|316297|def+CountFrequency(my_list):+
#+Creating+an+empty+dictionary++
freq+=+{}+
for+item+in+my_list:+
++++if+(item+in+freq):+
++++++++freq[item]+%2B=+1
++++else:+
++++++++freq[item]+=+1

for+key,+value+in+freq.items():+
++++print+("%25+d+:+%25+d"%25(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)|316298|参考资料：|316299|GeeksforGeeks|offset|length|316300|entityMap|0|LINK|mutability|MUTABLE|url|https://www.geeksforgeeks.org/counting-the-frequencies-in-a-list-using-dictionary-in-python/^0|0|0|0|0|0|0|D|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@$O|14|P|15|1|16]]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

To find unique elements in the list:
<pre><code>a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
a = list(set(a))
</code></pre>
To find the count of unique elements in a sorted array using dictionary:
<pre><code>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 (&quot;% d : % d&quot;%(key, value))

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

CountFrequency(my_list)
</code></pre>
Reference:
<a href="https://www.geeksforgeeks.org/counting-the-frequencies-in-a-list-using-dictionary-in-python/" rel="nofollow noreferrer">GeeksforGeeks</a>

blocks|key|316302|text|对于无序列表，您应该使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|316303|[a.count(el)+for+el+in+set(a)]|code-block|syntax|javascript|316304|输出为|316305|[4,+4,+2,+1,+2]|316306|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For an unordered list you should use:
<pre><code>[a.count(el) for el in set(a)]
</code></pre>
The output is
<pre><code>[4, 4, 2, 1, 2]
</code></pre>

blocks|key|318372|text|Data。假设我们有一个列表：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|318373|fruits+=+['banana',+'banana',+'apple',+'banana']|code-block|syntax|javascript|318374|解决方案。然后，我们可以通过这样做来找出列表中每个水果的数量：|318375|import+numpy+as+np++++
(unique,+counts)+=+np.unique(fruits,+return_counts=True)
{x:y+for+x,y+in+zip(unique,+counts)}|318376|输出|318377|{'banana':+3,+'apple':+1}|318378|entityMap^0|0|4|0|0|0|4|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

Data. Let's say we have a list:
<pre><code>fruits = ['banana', 'banana', 'apple', 'banana']
</code></pre>
Solution. Then we can find out how many of each fruit we have in the list by doing this:
<pre><code>import numpy as np 
(unique, counts) = np.unique(fruits, return_counts=True)
{x:y for x,y in zip(unique, counts)}
</code></pre>
Output:
<pre><code>{'banana': 3, 'apple': 1}
</code></pre>

blocks|key|319386|text|a+=+[1,1,1,1,2,2,2,2,3,3,4,5,5]
d+=+{}
[d.setdefault(el,+[]).append(1)+for+el+in+a]
counts+=+{k:+len(v)+for+k,+v+in+d.items()}
counts
#+{1:+4,+2:+4,+3:+2,+4:+1,+5:+2}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|319387|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
d = {}
[d.setdefault(el, []).append(1) for el in a]
counts = {k: len(v) for k, v in d.items()}
counts
# {1: 4, 2: 4, 3: 2, 4: 1, 5: 2}
</code></pre>

I need to find the frequency of elements in an unordered list

<pre><code>a = [1,1,1,1,2,2,2,2,3,3,4,5,5]
</code></pre>

output->

<pre><code>b = [4,4,2,1,2]
</code></pre>

Also I want to remove the duplicates from a

<pre><code>a = [1,2,3,4,5]
</code></pre>

How to count the frequency of the elements in an unordered list?

Python

我需要找到无序列表中元素的频率a = [1,1,1,1,2,2,2,2,3,3,4,5,5]输出->b = [4,4,2,1,2]此外，我还想从一个a = [1,2,3,4,5]

问如何统计无序列表中元素的出现频率？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何统计无序列表中元素的出现频率？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何统计无序列表中元素的出现频率？
EN