blocks|key|227342|text|像这样的事情应该可以做到：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227343|#create+100+random+numbers
arr+=+numpy.random.random_integers(0,50,100)

#create+a+dictionary+of+the+unique+values
d+=+dict([(i,0)+for+i+in+numpy.unique(arr)])
for+number+in+arr:
++++d[j]%2B=1+++#increment+when+that+value+is+found|code-block|syntax|javascript|227344|此外，Efficiently+counting+unique+elements+上之前的这篇文章似乎与你的问题非常相似，除非我遗漏了什么。|offset|length|227345|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/4037262/efficient-way-to-count-unique-elements-in-array-in-numpy-scipy-in-python^0|0|0|3|11|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]]]]

some thing like this should do it:

<pre><code>#create 100 random numbers
arr = numpy.random.random_integers(0,50,100)

#create a dictionary of the unique values
d = dict([(i,0) for i in numpy.unique(arr)])
for number in arr:
 d[j]+=1 #increment when that value is found
</code></pre>

Also, this previous post on <a href="https://stackoverflow.com/questions/4037262/efficient-way-to-count-unique-elements-in-array-in-numpy-scipy-in-python">Efficiently counting unique elements </a> seems pretty similar to your question, unless I'm missing something.

blocks|key|3095586|text|看一看np.bincount|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3095587|http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html|3095588|import+numpy+as+np
x+=+np.array([1,1,1,2,2,2,5,25,1,1])
y+=+np.bincount(x)
ii+=+np.nonzero(y)[0]|code-block|syntax|javascript|3095589|然后：|3095590|zip(ii,y[ii])+
#+[(1,+5),+(2,+3),+(5,+1),+(25,+1)]|3095591|或者：|3095592|np.vstack((ii,y[ii])).T
#+array([[+1,++5],
+++++++++[+2,++3],
+++++++++[+5,++1],
+++++++++[25,++1]])|3095593|或者您想要组合计数和唯一值的方式。|3095594|entityMap|0|LINK|mutability|MUTABLE|url^0|3|B|0|0|1Z|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1F|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|G]]]]

Take a look at <code>np.bincount</code>:

<a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html" rel="noreferrer">http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html</a>

<pre><code>import numpy as np
x = np.array([1,1,1,2,2,2,5,25,1,1])
y = np.bincount(x)
ii = np.nonzero(y)[0]
</code></pre>

And then:

<pre><code>zip(ii,y[ii]) 
# [(1, 5), (2, 3), (5, 1), (25, 1)]
</code></pre>

or:

<pre><code>np.vstack((ii,y[ii])).T
# array([[ 1, 5],
 [ 2, 3],
 [ 5, 1],
 [25, 1]])
</code></pre>

or however you want to combine the counts and the unique values.

blocks|key|2881618|text|numpy.bincount可能是最好的选择。如果您的数组包含除小而密集的整数以外的任何内容，那么包装它可能会很有用，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2881619|def+count_unique(keys):
++++uniq_keys+=+np.unique(keys)
++++bins+=+uniq_keys.searchsorted(keys)
++++return+uniq_keys,+np.bincount(bins)|code-block|syntax|javascript|2881620|例如：|2881621|>>>+x+=+array([1,1,1,2,2,2,5,25,1,1])
>>>+count_unique(x)
(array([+1,++2,++5,+25]),+array([5,+3,+1,+1]))|2881622|entityMap^0|0|E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

<code>numpy.bincount</code> is the probably the best choice. If your array contains anything besides small dense integers it might be useful to wrap it something like this:

<pre><code>def count_unique(keys):
 uniq_keys = np.unique(keys)
 bins = uniq_keys.searchsorted(keys)
 return uniq_keys, np.bincount(bins)
</code></pre>

For example:

<pre><code>&gt;&gt;&gt; x = array([1,1,1,2,2,2,5,25,1,1])
&gt;&gt;&gt; count_unique(x)
(array([ 1, 2, 5, 25]), array([5, 3, 1, 1]))
</code></pre>

blocks|key|229065|text|尽管这个问题已经得到了回答，但我还是建议使用numpy.histogram的另一种方法。这样的函数给定一个序列，它返回分组在中的元素的频率。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|229066|尽管，但要注意：它在本例中是有效的，因为数字是整数。如果它们是实数，那么这个解决方案就不能很好地应用。|229067|>>>+from+numpy+import+histogram
>>>+y+=+histogram+(x,+bins=x.max()-1)
>>>+y
(array([5,+3,+0,+0,+1,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,+0,
+++++++1]),
+array([++1.,+++2.,+++3.,+++4.,+++5.,+++6.,+++7.,+++8.,+++9.,++10.,++11.,
++++++++12.,++13.,++14.,++15.,++16.,++17.,++18.,++19.,++20.,++21.,++22.,
++++++++23.,++24.,++25.]))|code-block|syntax|javascript|229068|entityMap^0|M|F|1U|4|0|0|2|7|18|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|U|8|@$9|V|A|W|B|D]|$9|X|A|Y|B|D]]|E|@]|F|$]]|$1|I|3|J|5|K|7|Z|8|@]|E|@]|F|$L|M]]|$1|N|3|-4|5|6|7|10|8|@]|E|@]|F|$]]]|O|$]]

Even though it has already been answered, I suggest a different approach that makes use of <code>numpy.histogram</code>. Such function given a sequence it returns the frequency of its elements grouped in bins.

Beware though: it works in this example because numbers are integers. If they where real numbers, then this solution would not apply as nicely.

<pre><code>&gt;&gt;&gt; from numpy import histogram
&gt;&gt;&gt; y = histogram (x, bins=x.max()-1)
&gt;&gt;&gt; y
(array([5, 3, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 1]),
 array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.,
 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,
 23., 24., 25.]))
</code></pre>

blocks|key|229091|text|更新:原始答案中提到的方法已被弃用，我们应该使用新方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|229092|>>>+import+numpy+as+np
>>>+x+=+[1,1,1,2,2,2,5,25,1,1]
>>>+np.array(np.unique(x,+return_counts=True)).T
++++array([[+1,++5],
+++++++++++[+2,++3],
+++++++++++[+5,++1],
+++++++++++[25,++1]])|code-block|syntax|javascript|229093|229094|原始答案：|229095|您可以使用scipy.stats.itemfreq|offset|length|229096|>>>+from+scipy.stats+import+itemfreq
>>>+x+=+[1,1,1,2,2,2,5,25,1,1]
>>>+itemfreq(x)
/usr/local/bin/python:1:+DeprecationWarning:+`itemfreq`+is+deprecated!+`itemfreq`+is+deprecated+and+will+be+removed+in+a+future+version.+Use+instead+`np.unique(...,+return_counts=True)`
array([[++1.,+++5.],
+++++++[++2.,+++3.],
+++++++[++5.,+++1.],
+++++++[+25.,+++1.]])|229097|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.itemfreq.html^0|0|0|0|0|5|K|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@$L|12|M|13|1|14]]|A|$]]|$1|N|3|O|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|Q|$R|$5|S|T|U|A|$V|W]]]]

Update: The method mentioned in the original answer is deprecated, we should use the new way instead:

<pre><code>&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; x = [1,1,1,2,2,2,5,25,1,1]
&gt;&gt;&gt; np.array(np.unique(x, return_counts=True)).T
 array([[ 1, 5],
 [ 2, 3],
 [ 5, 1],
 [25, 1]])
</code></pre>

<hr>

Original answer:

you can use <a href="http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.itemfreq.html" rel="noreferrer">scipy.stats.itemfreq</a>

<pre><code>&gt;&gt;&gt; from scipy.stats import itemfreq
&gt;&gt;&gt; x = [1,1,1,2,2,2,5,25,1,1]
&gt;&gt;&gt; itemfreq(x)
/usr/local/bin/python:1: DeprecationWarning: `itemfreq` is deprecated! `itemfreq` is deprecated and will be removed in a future version. Use instead `np.unique(..., return_counts=True)`
array([[ 1., 5.],
 [ 2., 3.],
 [ 5., 1.],
 [ 25., 1.]])
</code></pre>

blocks|key|3095709|text|这是到目前为止最通用和性能最好的解决方案；令人惊讶的是它还没有发布。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3095710|import+numpy+as+np

def+unique_count(a):
++++unique,+inverse+=+np.unique(a,+return_inverse=True)
++++count+=+np.zeros(len(unique),+np.int)
++++np.add.at(count,+inverse,+1)
++++return+np.vstack((+unique,+count)).T

print+unique_count(np.random.randint(-10,10,100))|code-block|syntax|javascript|3095711|与当前接受的答案不同，它适用于任何可排序的数据类型(不仅仅是正整数)，并且具有最佳性能；唯一显著的开销是由np.unique完成的排序。|3095712|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is by far the most general and performant solution; surprised it hasn't been posted yet.

<pre><code>import numpy as np

def unique_count(a):
 unique, inverse = np.unique(a, return_inverse=True)
 count = np.zeros(len(unique), np.int)
 np.add.at(count, inverse, 1)
 return np.vstack(( unique, count)).T

print unique_count(np.random.randint(-10,10,100))
</code></pre>

Unlike the currently accepted answer, it works on any datatype that is sortable (not just positive ints), and it has optimal performance; the only significant expense is in the sorting done by np.unique.

blocks|key|229128|text|为了计算唯一的非整数-类似于Eelco+Hoogendoorn的答案，但速度相当快(在我的机器上是5的因子)，我使用weave.inline将numpy.unique与一些C代码组合在一起；|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|229129|import+numpy+as+np
from+scipy+import+weave

def+count_unique(datain):
++"""
++Similar+to+numpy.unique+function+for+returning+unique+members+of
++data,+but+also+returns+their+counts
++"""
++data+=+np.sort(datain)
++uniq+=+np.unique(data)
++nums+=+np.zeros(uniq.shape,+dtype='int')

++code="""
++int+i,count,j;
++j=0;
++count=0;
++for(i=1;+i<Ndata[0];+i%2B%2B){
++++++count%2B%2B;
++++++if(data(i)+>+data(i-1)){
++++++++++nums(j)+=+count;
++++++++++count+=+0;
++++++++++j%2B%2B;
++++++}
++}
++//+Handle+last+value
++nums(j)+=+count%2B1;
++"""
++weave.inline(code,
++++++['data',+'nums'],
++++++extra_compile_args=['-O2'],
++++++type_converters=weave.converters.blitz)
++return+uniq,+nums|code-block|syntax|javascript|229130|配置文件信息|229131|>+%25timeit+count_unique(data)
>+10000+loops,+best+of+3:+55.1+µs+per+loop|229132|Eelco的纯numpy版本：|229133|>+%25timeit+unique_count(data)
>+1000+loops,+best+of+3:+284+µs+per+loop|229134|便笺|229135|这里有冗余(unique还执行排序)，这意味着可以通过将unique功能放在c代码循环中来进一步优化代码。|229136|entityMap^0|4|6|1M|C|1Z|C|0|0|0|6|0|0|7|5|0|0|0|2|0|6|6|S|6|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|D]|$9|14|A|15|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|16|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|17|8|@$9|18|A|19|B|C]]|E|@]|F|$]]|$1|N|3|O|5|I|7|1A|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|1B|8|@$9|1C|A|1D|B|D]]|E|@]|F|$]]|$1|R|3|S|5|I|7|1E|8|@]|E|@]|F|$J|K]]|$1|T|3|U|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|E|@]|F|$]]|$1|V|3|W|5|6|7|1I|8|@$9|1J|A|1K|B|D]|$9|1L|A|1M|B|D]]|E|@]|F|$]]|$1|X|3|-4|5|6|7|1N|8|@]|E|@]|F|$]]]|Y|$]]

To count unique non-integers - similar to Eelco Hoogendoorn's answer but considerably faster (factor of 5 on my machine), I used <code>weave.inline</code> to combine <code>numpy.unique</code> with a bit of c-code; 

<pre><code>import numpy as np
from scipy import weave

def count_unique(datain):
 """
 Similar to numpy.unique function for returning unique members of
 data, but also returns their counts
 """
 data = np.sort(datain)
 uniq = np.unique(data)
 nums = np.zeros(uniq.shape, dtype='int')

 code="""
 int i,count,j;
 j=0;
 count=0;
 for(i=1; i&lt;Ndata[0]; i++){
 count++;
 if(data(i) &gt; data(i-1)){
 nums(j) = count;
 count = 0;
 j++;
 }
 }
 // Handle last value
 nums(j) = count+1;
 """
 weave.inline(code,
 ['data', 'nums'],
 extra_compile_args=['-O2'],
 type_converters=weave.converters.blitz)
 return uniq, nums
</code></pre>

Profile info

<pre><code>&gt; %timeit count_unique(data)
&gt; 10000 loops, best of 3: 55.1 µs per loop
</code></pre>

Eelco's pure <code>numpy</code> version: 

<pre><code>&gt; %timeit unique_count(data)
&gt; 1000 loops, best of 3: 284 µs per loop
</code></pre>

Note

There's redundancy here (<code>unique</code> performs a sort also), meaning that the code could probably be further optimized by putting the <code>unique</code> functionality inside the c-code loop.

blocks|key|3095743|text|使用pandas模块：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3095744|>>>+import+pandas+as+pd
>>>+import+numpy+as+np
>>>+x+=+np.array([1,1,1,2,2,2,5,25,1,1])
>>>+pd.value_counts(x)
1+++++5
2+++++3
25++++1
5+++++1
dtype:+int64|code-block|syntax|javascript|3095745|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|$]]

Using pandas module:

<pre><code>&gt;&gt;&gt; import pandas as pd
&gt;&gt;&gt; import numpy as np
&gt;&gt;&gt; x = np.array([1,1,1,2,2,2,5,25,1,1])
&gt;&gt;&gt; pd.value_counts(x)
1 5
2 3
25 1
5 1
dtype: int64
</code></pre>

blocks|key|226949|text|老问题，但我想提供我自己的解决方案，事实证明是最快的，使用普通的list而不是np.array作为输入(或首先转移到列表)，基于我的平台测试。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|226950|如果你也遇到了，请查看。|226951|def+count(a):
++++results+=+{}
++++for+x+in+a:
++++++++if+x+not+in+results:
++++++++++++results[x]+=+1
++++++++else:
++++++++++++results[x]+%2B=+1
++++return+results|code-block|syntax|javascript|226952|例如,|226953|>>>timeit+count([1,1,1,2,2,2,5,25,1,1])+would+return:|226954|100000个循环，最好的3个:每个循环2.26µs|226955|>>>timeit+count(np.array([1,1,1,2,2,2,5,25,1,1]))|226956|100000个循环，最好3个:每个循环8.8µs|226957|>>>timeit+count(np.array([1,1,1,2,2,2,5,25,1,1]).tolist())|226958|100000个循环，最好的3个:每个循环5.85µs|226959|而公认的答案会更慢，而scipy.stats.itemfreq解决方案更糟糕。|226960|226961|更深入的测试并没有确认的预期。|226962|from+zmq+import+Stopwatch
aZmqSTOPWATCH+=+Stopwatch()

aDataSETasARRAY+=+(+100+*+abs(+np.random.randn(+150000+)+)+).astype(+np.int+)
aDataSETasLIST++=+aDataSETasARRAY.tolist()

import+numba
@numba.jit
def+numba_bincount(+anObject+):
++++np.bincount(++++anObject+)
++++return

aZmqSTOPWATCH.start();np.bincount(++++aDataSETasARRAY+);aZmqSTOPWATCH.stop()
14328L

aZmqSTOPWATCH.start();numba_bincount(+aDataSETasARRAY+);aZmqSTOPWATCH.stop()
592L

aZmqSTOPWATCH.start();count(++++++++++aDataSETasLIST++);aZmqSTOPWATCH.stop()
148609L|226963|参考下面是关于缓存和其他内存副作用的评论，这些副作用会影响小型数据集的大量重复测试结果。|226964|entityMap^0|W|4|W|4|13|8|0|0|B|0|0|0|0|0|0|0|0|0|B|K|0|0|4|7|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|D]|$9|1H|A|1I|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1M|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1N|8|@]|E|@]|F|$]]|$1|P|3|Q|5|K|7|1O|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|1P|8|@]|E|@]|F|$]]|$1|T|3|U|5|K|7|1Q|8|@]|E|@]|F|$L|M]]|$1|V|3|W|5|6|7|1R|8|@]|E|@]|F|$]]|$1|X|3|Y|5|K|7|1S|8|@]|E|@]|F|$L|M]]|$1|Z|3|10|5|6|7|1T|8|@]|E|@]|F|$]]|$1|11|3|12|5|6|7|1U|8|@$9|1V|A|1W|B|D]]|E|@]|F|$]]|$1|13|3|-4|5|6|7|1X|8|@]|E|@]|F|$]]|$1|14|3|15|5|6|7|1Y|8|@$9|1Z|A|20|B|C]]|E|@]|F|$]]|$1|16|3|17|5|K|7|21|8|@]|E|@]|F|$L|M]]|$1|18|3|19|5|6|7|22|8|@]|E|@]|F|$]]|$1|1A|3|-4|5|6|7|23|8|@]|E|@]|F|$]]]|1B|$]]

Old question, but I'd like to provide my own solution which turn out to be the fastest, use normal <code>list</code> instead of <code>np.array</code> as input (or transfer to list firstly), based on my bench test.

Check it out if you encounter it as well.

<pre><code>def count(a):
 results = {}
 for x in a:
 if x not in results:
 results[x] = 1
 else:
 results[x] += 1
 return results
</code></pre>

For example, 

<pre><code>&gt;&gt;&gt;timeit count([1,1,1,2,2,2,5,25,1,1]) would return:
</code></pre>

100000 loops, best of 3: 2.26 µs per loop

<pre><code>&gt;&gt;&gt;timeit count(np.array([1,1,1,2,2,2,5,25,1,1]))
</code></pre>

100000 loops, best of 3: 8.8 µs per loop

<pre><code>&gt;&gt;&gt;timeit count(np.array([1,1,1,2,2,2,5,25,1,1]).tolist())
</code></pre>

100000 loops, best of 3: 5.85 µs per loop

While the accepted answer would be slower, and the <code>scipy.stats.itemfreq</code> solution is even worse.

<hr>

A more indepth testing did not confirm the formulated expectation.

<pre><code>from zmq import Stopwatch
aZmqSTOPWATCH = Stopwatch()

aDataSETasARRAY = ( 100 * abs( np.random.randn( 150000 ) ) ).astype( np.int )
aDataSETasLIST = aDataSETasARRAY.tolist()

import numba
@numba.jit
def numba_bincount( anObject ):
 np.bincount( anObject )
 return

aZmqSTOPWATCH.start();np.bincount( aDataSETasARRAY );aZmqSTOPWATCH.stop()
14328L

aZmqSTOPWATCH.start();numba_bincount( aDataSETasARRAY );aZmqSTOPWATCH.stop()
592L

aZmqSTOPWATCH.start();count( aDataSETasLIST );aZmqSTOPWATCH.stop()
148609L
</code></pre>

Ref. comments below on cache and other in-RAM side-effects that influence a small dataset massively repetitive testing results.

blocks|key|226996|text|从Numpy+1.9开始，最简单最快的方法是简单地使用numpy.unique，它现在有一个return_counts关键字参数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|226997|import+numpy+as+np

x+=+np.array([1,1,1,2,2,2,5,25,1,1])
unique,+counts+=+np.unique(x,+return_counts=True)

print+np.asarray((unique,+counts)).T|code-block|syntax|javascript|226998|这就给出了：|226999|+[[+1++5]
++[+2++3]
++[+5++1]
++[25++1]]|227000|与scipy.stats.itemfreq的快速比较|227001|In+[4]:+x+=+np.random.random_integers(0,100,1e6)

In+[5]:+%25timeit+unique,+counts+=+np.unique(x,+return_counts=True)
10+loops,+best+of+3:+31.5+ms+per+loop

In+[6]:+%25timeit+scipy.stats.itemfreq(x)
10+loops,+best+of+3:+170+ms+per+loop|227002|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html^0|R|C|1A|D|R|C|0|0|0|0|0|1|K|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]]|E|$]]|$1|F|3|G|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

As of Numpy 1.9, the easiest and fastest method is to simply use <a href="http://docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html"><code>numpy.unique</code></a>, which now has a <code>return_counts</code> keyword argument:

<pre><code>import numpy as np

x = np.array([1,1,1,2,2,2,5,25,1,1])
unique, counts = np.unique(x, return_counts=True)

print np.asarray((unique, counts)).T
</code></pre>

Which gives:

<pre><code> [[ 1 5]
 [ 2 3]
 [ 5 1]
 [25 1]]
</code></pre>

A quick comparison with <code>scipy.stats.itemfreq</code>:

<pre><code>In [4]: x = np.random.random_integers(0,100,1e6)

In [5]: %timeit unique, counts = np.unique(x, return_counts=True)
10 loops, best of 3: 31.5 ms per loop

In [6]: %timeit scipy.stats.itemfreq(x)
10 loops, best of 3: 170 ms per loop
</code></pre>

blocks|key|227020|text|我对此也很感兴趣，所以我做了一些性能比较(使用我喜欢的项目perfplot+)。结果：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|227021|y+=+np.bincount(a)
ii+=+np.nonzero(y)[0]
out+=+np.vstack((ii,+y[ii])).T|code-block|syntax|javascript|227022|是目前为止最快的。(请注意对数缩放。)|227023|​|227024|📷|atomic|227025|227026|227027|生成绘图的代码：|227028|import+numpy+as+np
import+pandas+as+pd
import+perfplot
from+scipy.stats+import+itemfreq


def+bincount(a):
++++y+=+np.bincount(a)
++++ii+=+np.nonzero(y)[0]
++++return+np.vstack((ii,+y[ii])).T


def+unique(a):
++++unique,+counts+=+np.unique(a,+return_counts=True)
++++return+np.asarray((unique,+counts)).T


def+unique_count(a):
++++unique,+inverse+=+np.unique(a,+return_inverse=True)
++++count+=+np.zeros(len(unique),+dtype=int)
++++np.add.at(count,+inverse,+1)
++++return+np.vstack((unique,+count)).T


def+pandas_value_counts(a):
++++out+=+pd.value_counts(pd.Series(a))
++++out.sort_index(inplace=True)
++++out+=+np.stack([out.keys().values,+out.values]).T
++++return+out


perfplot.show(
++++setup=lambda+n:+np.random.randint(0,+1000,+n),
++++kernels=[bincount,+unique,+itemfreq,+unique_count,+pandas_value_counts],
++++n_range=[2+**+k+for+k+in+range(26)],
++++xlabel="len(a)",
)|227029|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/nschloe/perfplot|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/89dfc7f02c348a53cd60407e430d0781.png|imageAlt^0|T|8|0|0|0|0|0|0|1|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|D|3|E|5|F|7|1D|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1E|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|N|5|O|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|P|3|L|5|6|7|1K|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|1M|8|@]|9|@]|C|$]]|$1|T|3|U|5|F|7|1N|8|@]|9|@]|C|$G|H]]|$1|V|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]|13|$5|14|Z|15|C|$16|17|18|-4]]]]

I was also interested in this, so I did a little performance comparison (using <a href="https://github.com/nschloe/perfplot" rel="noreferrer">perfplot</a>, a pet project of mine). Result:
<pre class="lang-py prettyprint-override"><code>y = np.bincount(a)
ii = np.nonzero(y)[0]
out = np.vstack((ii, y[ii])).T
</code></pre>
is by far the fastest. (Note the log-scaling.)
<a href="https://i.stack.imgur.com/G7qf1.png" rel="noreferrer"><img src="https://i.stack.imgur.com/G7qf1.png" alt="enter image description here" /></a>
<hr />
Code to generate the plot:
<pre class="lang-py prettyprint-override"><code>import numpy as np
import pandas as pd
import perfplot
from scipy.stats import itemfreq


def bincount(a):
 y = np.bincount(a)
 ii = np.nonzero(y)[0]
 return np.vstack((ii, y[ii])).T


def unique(a):
 unique, counts = np.unique(a, return_counts=True)
 return np.asarray((unique, counts)).T


def unique_count(a):
 unique, inverse = np.unique(a, return_inverse=True)
 count = np.zeros(len(unique), dtype=int)
 np.add.at(count, inverse, 1)
 return np.vstack((unique, count)).T


def pandas_value_counts(a):
 out = pd.value_counts(pd.Series(a))
 out.sort_index(inplace=True)
 out = np.stack([out.keys().values, out.values]).T
 return out


perfplot.show(
 setup=lambda n: np.random.randint(0, 1000, n),
 kernels=[bincount, unique, itemfreq, unique_count, pandas_value_counts],
 n_range=[2 ** k for k in range(26)],
 xlabel=&quot;len(a)&quot;,
)
</code></pre>

blocks|key|224075|text|import+pandas+as+pd
import+numpy+as+np
x+=+np.array(+[1,1,1,2,2,2,5,25,1,1]+)
print(dict(pd.Series(x).value_counts()))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|224076|这给你：{1:+5，2:+3，5:+1，25:+1}|unstyled|224077|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import pandas as pd
import numpy as np
x = np.array( [1,1,1,2,2,2,5,25,1,1] )
print(dict(pd.Series(x).value_counts()))
</code></pre>

This gives you:
{1: 5, 2: 3, 5: 1, 25: 1}

blocks|key|229312|text|import+pandas+as+pd
import+numpy+as+np

print(pd.Series(name_of_array).value_counts())|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|229313|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 class="lang-py prettyprint-override"><code>import pandas as pd
import numpy as np

print(pd.Series(name_of_array).value_counts())
</code></pre>

blocks|key|229315|text|多维频率计数，即数组计数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|229316|>>>+print(color_array++++)
++array([[255,+128,+128],
+++[255,+128,+128],
+++[255,+128,+128],
+++...,
+++[255,+128,+128],
+++[255,+128,+128],
+++[255,+128,+128]],+dtype=uint8)


>>>+np.unique(color_array,return_counts=True,axis=0)
++(array([[+60,+151,+161],
++++[+60,+155,+162],
++++[+60,+159,+163],
++++[+61,+143,+162],
++++[+61,+147,+162],
++++[+61,+162,+163],
++++[+62,+166,+164],
++++[+63,+137,+162],
++++[+63,+169,+164],
+++array([+++++1,++++++2,++++++2,++++++1,++++++4,++++++1,++++++1,++++++2,
+++++++++3,++++++1,++++++1,++++++1,++++++2,++++++5,++++++2,++++++2,
+++++++898,++++++1,++++++1,++|code-block|syntax|javascript|229317|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|$]]

multi-dimentional frequency count, i.e. counting arrays.

<pre><code>&gt;&gt;&gt; print(color_array )
 array([[255, 128, 128],
 [255, 128, 128],
 [255, 128, 128],
 ...,
 [255, 128, 128],
 [255, 128, 128],
 [255, 128, 128]], dtype=uint8)


&gt;&gt;&gt; np.unique(color_array,return_counts=True,axis=0)
 (array([[ 60, 151, 161],
 [ 60, 155, 162],
 [ 60, 159, 163],
 [ 61, 143, 162],
 [ 61, 147, 162],
 [ 61, 162, 163],
 [ 62, 166, 164],
 [ 63, 137, 162],
 [ 63, 169, 164],
 array([ 1, 2, 2, 1, 4, 1, 1, 2,
 3, 1, 1, 1, 2, 5, 2, 2,
 898, 1, 1, 
</code></pre>

blocks|key|229319|text|from+collections+import+Counter
x+=+array(+[1,1,1,2,2,2,5,25,1,1]+)
mode+=+counter.most_common(1)[0][0]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|229320|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 class="lang-py prettyprint-override"><code>from collections import Counter
x = array( [1,1,1,2,2,2,5,25,1,1] )
mode = counter.most_common(1)[0][0]
</code></pre>

blocks|key|3095957|text|大多数简单的问题之所以变得复杂，是因为各种python库中缺少像R中的order()这样的简单功能，它可以同时给出统计结果和降序结果。但是，如果我们设计出这样的想法，即python中的所有这些统计顺序和参数都很容易在熊猫身上找到，那么我们就可以比在100个不同的地方查找更快地得到结果。此外，R和熊猫的开发是齐头并进的，因为它们是为相同的目的而创建的。为了解决这个问题，我使用了下面的代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3095958|unique,+counts+=+np.unique(x,+return_counts=True)
d+=+{'unique':unique,+'counts':count}++#+pass+the+list+to+a+dictionary
df+=+pd.DataFrame(d)+#dictionary+object+can+be+easily+passed+to+make+a+dataframe
df.sort_values(by+=+'count',+ascending=False,+inplace+=+True)
df+=+df.reset_index(drop=True)+#optional+only+if+you+want+to+use+it+further|code-block|syntax|javascript|3095959|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|$]]

Most of simple problems get complicated because simple functionality like order() in R that gives a statistical result in both and descending order is missing in various python libraries. But if we devise our thinking that all such statistical ordering and parameters in python are easily found in pandas, we can can result sooner than looking in 100 different places. Also, development of R and pandas go hand-in-hand because they were created for same purpose. To solve this problem I use following code that gets me by anywhere:
<pre><code>unique, counts = np.unique(x, return_counts=True)
d = {'unique':unique, 'counts':count} # pass the list to a dictionary
df = pd.DataFrame(d) #dictionary object can be easily passed to make a dataframe
df.sort_values(by = 'count', ascending=False, inplace = True)
df = df.reset_index(drop=True) #optional only if you want to use it further
</code></pre>

In <code>numpy</code> / <code>scipy</code>, is there an efficient way to get frequency counts for unique values in an array?

Something along these lines:

<pre><code>x = array( [1,1,1,2,2,2,5,25,1,1] )
y = freq_count( x )
print y

&gt;&gt; [[1, 5], [2,3], [5,1], [25,1]]
</code></pre>

( For you, R users out there, I'm basically looking for the <code>table()</code> function )

numpy: most efficient frequency counts for unique values in an array

在numpy / scipy，中，有没有一种高效的方法来获取数组中唯一值的频率计数？大致是这样的：x = array( [1,1,1,2,2,2,5,25,1,1] )y = freq_count( x )print y>> [[1, 5], [2,3], [5,1], [25,1]](对于R用户来说，我基本上是在寻找...

问numpy:数组中唯一值的最有效频率计数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问numpy:数组中唯一值的最有效频率计数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问numpy:数组中唯一值的最有效频率计数
EN