Question

在 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用户在那里，我基本上都在寻找table()功能）

Answer 1

从Numpy 1.9开始，最简单快捷的方法是简单地使用numpy.unique，它现在有一个return_counts关键字参数：

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

给出了：

 [[ 1  5]
  [ 2  3]
  [ 5  1]
  [25  1]]

与scipy.stats.itemfreq进行快速比较：

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

Answer 2

看看np.bincount：

http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html

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]

然后：

zip(ii,y[ii]) 
# [(1, 5), (2, 3), (5, 1), (25, 1)]

或：

np.vstack((ii,y[ii])).T
# array([[ 1,  5],
         [ 2,  3],
         [ 5,  1],
         [25,  1]])

或者您想要合并计数和唯一值。

Answer 3

更新：原始答案中提到的方法已弃用，我们应该使用新方法：

>>> 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]])

原始答案：

您可以使用scipy.stats.itemfreq

>>> 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.]])

Answer 4

我也对此感兴趣，所以我做了一点性能比较（使用perfplot，我的宠物项目）。结果：

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

是迄今为止最快的。（注意日志缩放。）

生成情节的代码：

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), np.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)],
    logx=True,
    logy=True,
    xlabel='len(a)'
    )

Answer 5

使用pandas模块：

>>> import pandas as pd
>>> import numpy as np
>>> x = np.array([1,1,1,2,2,2,5,25,1,1])
>>> pd.value_counts(pd.Series(x))
1     5
2     3
25    1
5     1

dtype：int64

Answer 6

这是迄今为止最通用，最高效的解决方案;惊讶它还没有发布。

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))

与当前接受的答案不同，它适用于任何可排序的数据类型（不仅仅是正整数），并且具有最佳性能;唯一重要的开支是np.unique完成的排序。

Answer 7

numpy.bincount可能是最好的选择。如果你的数组包含除了小密集整数之外的任何东西，那么包装它可能是有用的：

def count_unique(keys):
    uniq_keys = np.unique(keys)
    bins = uniq_keys.searchsorted(keys)
    return uniq_keys, np.bincount(bins)

例如：

>>> 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]))

Answer 8

尽管已经回答过，但我建议采用另一种方法来使用numpy.histogram。这样的函数给定一个序列，它返回其元素的频率分组在箱子中。

请注意：它在此示例中有效，因为数字是整数。如果它们是真实数字，那么这个解决方案就不适用。

>>> 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.]))

Answer 9

老问题，但我想提供我自己的解决方案，结果是最快的，使用普通的 list 代替np.array作为输入（或转移）首先列出），基于我的台架测试。

检查如果您遇到它。

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

例如，

>>>timeit count([1,1,1,2,2,2,5,25,1,1]) would return:

100000个循环，最佳3：每循环2.26μs

>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]))

100000个循环，最佳3：每循环8.8μs

>>>timeit count(np.array([1,1,1,2,2,2,5,25,1,1]).tolist())

100000个循环，最佳3：每循环5.85μs

虽然接受的答案会更慢，但scipy.stats.itemfreq解决方案更糟糕。

更深入的测试没有证实制定的期望。

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

参考。以下评论缓存和其他影响小数据集大量重复测试结果的内存副作用。

Answer 10

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()))

这会给你： {1：5,2：3,5：1,25：1}

Answer 11

计算唯一的非整数 - 类似于Eelco Hoogendoorn的答案但速度相当快（我的机器上的因子为5），我使用weave.inline来组合{{1带有一点c代码;

numpy.unique

个人资料信息

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++){
      count++;
      if(data(i) > 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

Eelco的纯> %timeit count_unique(data) > 10000 loops, best of 3: 55.1 µs per loop版本：

numpy

注意

这里有冗余（> %timeit unique_count(data) > 1000 loops, best of 3: 284 µs per loop也执行排序），这意味着可以通过将unique功能放在c代码循环中来进一步优化代码。

Answer 12

这样的事情应该这样做：

#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

此外，Efficiently counting unique elements 上的这篇帖子似乎与您的问题非常相似，除非我遗漏了一些内容。

Answer 13

from collections import Counter
x = array( [1,1,1,2,2,2,5,25,1,1] )
mode = counter.most_common(1)[0][0]

Answer 14

将pandas导入为pd

将numpy导入为np

pd.Series（name_of_array）.value_counts（）

Answer 15

多维频率计数，即计数数组。

>>> 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,

Answer 16

大多数简单的问题都会变得复杂，因为R中的简单功能（例如order（））同时给出统计结果，并且在各种python库中都缺少降序排列。但是，如果我们想到在熊猫中很容易找到python中所有这样的统计顺序和参数，那么与在100个不同的地方查找相比，我们可以更快地得出结果。同样，R和熊猫的发展是并存的，因为它们是出于相同的目的而创建的。为了解决这个问题，我使用以下代码将我带到任何地方：

{{1}}

Answer 17

从馆藏进口柜台计数器（x）

numpy：数组中唯一值的最有效频率计数

17 个答案: