blocks|key|875970|text|如果你的列表包含所有非负整数，你应该看看numpy.bincounts：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|875971|http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html|offset|length|875972|然后可能使用np.argmax：|875973|a+=+np.array([1,2,3,1,2,1,1,1,3,2,2,1])
counts+=+np.bincount(a)
print(np.argmax(counts))|code-block|syntax|javascript|875974|对于更复杂的列表(可能包含负数或非整数值)，可以以类似的方式使用np.histogram。或者，如果您只想在python中工作而不使用numpy，那么collections.Counter是处理这类数据的好方法。|style|CODE|875975|from+collections+import+Counter
a+=+[1,2,3,1,2,1,1,1,3,2,2,1]
b+=+Counter(a)
print(b.most_common(1))|875976|entityMap|0|LINK|mutability|MUTABLE|url|1|https://numpy.org/doc/stable/reference/generated/numpy.histogram.html^0|0|0|1Z|0|0|0|0|W|C|23|J|W|C|1|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|18|8|@$D|19|E|1A|O|P]|$D|1B|E|1C|O|P]]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|Q|3|R|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|C]]|Z|$5|V|W|X|A|$Y|10]]]]

If your list contains all non-negative ints, you should take a look at numpy.bincounts:
<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>
and then probably use np.argmax:
<pre><code>a = np.array([1,2,3,1,2,1,1,1,3,2,2,1])
counts = np.bincount(a)
print(np.argmax(counts))
</code></pre>
For a more complicated list (that perhaps contains negative numbers or non-integer values), you can use <a href="https://numpy.org/doc/stable/reference/generated/numpy.histogram.html" rel="noreferrer"><code>np.histogram</code></a> in a similar way. Alternatively, if you just want to work in python without using numpy, <code>collections.Counter</code> is a good way of handling this sort of data.
<pre><code>from collections import Counter
a = [1,2,3,1,2,1,1,1,3,2,2,1]
b = Counter(a)
print(b.most_common(1))
</code></pre>

blocks|key|658778|text|如果您愿意使用SciPy|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|658779|>>>+from+scipy.stats+import+mode
>>>+mode([1,2,3,1,2,1,1,1,3,2,2,1])
(array([+1.]),+array([+6.]))
>>>+most_frequent+=+mode([1,2,3,1,2,1,1,1,3,2,2,1])[0][0]
>>>+most_frequent
1.0|code-block|syntax|javascript|658780|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mode.html^0|7|5|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]]]]

If you're willing to use <a href="http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mode.html" rel="noreferrer">SciPy</a>:

<pre><code>&gt;&gt;&gt; from scipy.stats import mode
&gt;&gt;&gt; mode([1,2,3,1,2,1,1,1,3,2,2,1])
(array([ 1.]), array([ 6.]))
&gt;&gt;&gt; most_frequent = mode([1,2,3,1,2,1,1,1,3,2,2,1])[0][0]
&gt;&gt;&gt; most_frequent
1.0
</code></pre>

blocks|key|876048|text|此外，如果您希望在不加载任何模块的情况下获得最频繁的值(正或负)，则可以使用以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876049|lVals+=+[1,2,3,1,2,1,1,1,3,2,2,1]
print+max(map(lambda+val:+(lVals.count(val),+val),+set(lVals)))|code-block|syntax|javascript|876050|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|$]]

Also if you want to get most frequent value(positive or negative) without loading any modules you can use the following code:

<pre><code>lVals = [1,2,3,1,2,1,1,1,3,2,2,1]
print max(map(lambda val: (lVals.count(val), val), set(lVals)))
</code></pre>

blocks|key|658864|text|我最近在做一个项目并使用collections.Counter(这让我很痛苦)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658865|在我看来，集合中的计数器性能非常非常差。它只是一个类包装dict()。|658866|更糟糕的是，如果你使用cProfile来分析它的方法，你应该看到很多'__missing__‘和'__instancecheck__’的东西浪费了整个时间。|658867|要小心使用它的most_common()，因为每次它都会调用一个排序，这会使它变得非常慢。如果您使用most_common(x)，它将调用堆排序，这也很慢。|658868|顺便说一句，numpy的bincount也有一个问题:如果你使用np.bincount(1,2,+4000000+)，你将得到一个包含4000000个元素的数组。|658869|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I'm recently doing a project and using collections.Counter.(Which tortured me).

The Counter in collections have a very very bad performance in my opinion. It's just a class wrapping dict().

What's worse, If you use cProfile to profile its method, you should see a lot of '__missing__' and '__instancecheck__' stuff wasting the whole time.

Be careful using its most_common(), because everytime it would invoke a sort which makes it extremely slow. and if you use most_common(x), it will invoke a heap sort, which is also slow.

Btw, numpy's bincount also have a problem: if you use np.bincount([1,2,4000000]), you will get an array with 4000000 elements.

blocks|key|658982|text|虽然上面的大多数答案都很有用，但如果你:+1)需要它支持非正整数值(例如浮点数或负整数;-))，2)不在Python2.7上(这是collections.Counter要求的)，3)不喜欢在你的代码中添加scipy+(甚至numpy)的依赖，那么一个纯Python2.6的解决方案O(nlogn)+(即，高效)就是这样的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658983|from+collections+import+defaultdict

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

d+=+defaultdict(int)
for+i+in+a:
++d[i]+%2B=+1
most_frequent+=+sorted(d.iteritems(),+key=lambda+x:+x[1],+reverse=True)[0]|code-block|syntax|javascript|658984|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|$]]

While most of the answers above are useful, in case you:
1) need it to support non-positive-integer values (e.g. floats or negative integers ;-)), and
2) aren't on Python 2.7 (which collections.Counter requires), and
3) prefer not to add the dependency of scipy (or even numpy) to your code, then a purely python 2.6 solution that is O(nlogn) (i.e., efficient) is just this:

<pre><code>from collections import defaultdict

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

d = defaultdict(int)
for i in a:
 d[i] += 1
most_frequent = sorted(d.iteritems(), key=lambda x: x[1], reverse=True)[0]
</code></pre>

blocks|key|659056|text|您可以使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659057|values,+counts+=+np.unique(a,+return_counts=True)

ind+=+np.argmax(counts)
print(values[ind])++#+prints+the+most+frequent+element

ind+=+np.argpartition(-counts,+kth=10)[:10]
print(values[ind])++#+prints+the+10+most+frequent+elements|code-block|syntax|javascript|659058|如果某个元素与另一个元素一样频繁，则此代码将只返回第一个元素。|659059|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|$]]

You may use
<pre><code>values, counts = np.unique(a, return_counts=True)

ind = np.argmax(counts)
print(values[ind]) # prints the most frequent element

ind = np.argpartition(-counts, kth=10)[:10]
print(values[ind]) # prints the 10 most frequent elements
</code></pre>
If some element is as frequent as another one, this code will return only the first element.

blocks|key|876295|text|我喜欢JoshAdel的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876296|但只有一个问题。|876297|np.bincount()解决方案仅适用于数字。|offset|length|style|CODE|876298|如果您有字符串，collections.Counter解决方案将为您工作。|876299|entityMap^0|0|0|0|D|0|8|J|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

I like the solution by JoshAdel.

But there is just one catch. 

The <code>np.bincount()</code> solution only works on numbers.

If you have strings, <code>collections.Counter</code> solution will work for you.

blocks|key|659143|text|这是一个通用的解决方案，可以沿着轴应用，而不考虑值，使用纯numpy。我还发现，如果有很多唯一值，这比scipy.stats.mode快得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659144|import+numpy

def+mode(ndarray,+axis=0):
++++#+Check+inputs
++++ndarray+=+numpy.asarray(ndarray)
++++ndim+=+ndarray.ndim
++++if+ndarray.size+==+1:
++++++++return+(ndarray[0],+1)
++++elif+ndarray.size+==+0:
++++++++raise+Exception('Cannot+compute+mode+on+empty+array')
++++try:
++++++++axis+=+range(ndarray.ndim)[axis]
++++except:
++++++++raise+Exception('Axis+"{}"+incompatible+with+the+{}-dimension+array'.format(axis,+ndim))

++++#+If+array+is+1-D+and+numpy+version+is+>+1.9+numpy.unique+will+suffice
++++if+all([ndim+==+1,
++++++++++++int(numpy.__version__.split('.')[0])+>=+1,
++++++++++++int(numpy.__version__.split('.')[1])+>=+9]):
++++++++modals,+counts+=+numpy.unique(ndarray,+return_counts=True)
++++++++index+=+numpy.argmax(counts)
++++++++return+modals[index],+counts[index]

++++#+Sort+array
++++sort+=+numpy.sort(ndarray,+axis=axis)
++++#+Create+array+to+transpose+along+the+axis+and+get+padding+shape
++++transpose+=+numpy.roll(numpy.arange(ndim)[::-1],+axis)
++++shape+=+list(sort.shape)
++++shape[axis]+=+1
++++#+Create+a+boolean+array+along+strides+of+unique+values
++++strides+=+numpy.concatenate([numpy.zeros(shape=shape,+dtype='bool'),
+++++++++++++++++++++++++++++++++numpy.diff(sort,+axis=axis)+==+0,
+++++++++++++++++++++++++++++++++numpy.zeros(shape=shape,+dtype='bool')],
++++++++++++++++++++++++++++++++axis=axis).transpose(transpose).ravel()
++++#+Count+the+stride+lengths
++++counts+=+numpy.cumsum(strides)
++++counts[~strides]+=+numpy.concatenate([[0],+numpy.diff(counts[~strides])])
++++counts[strides]+=+0
++++#+Get+shape+of+padded+counts+and+slice+to+return+to+the+original+shape
++++shape+=+numpy.array(sort.shape)
++++shape[axis]+%2B=+1
++++shape+=+shape[transpose]
++++slices+=+[slice(None)]+*+ndim
++++slices[axis]+=+slice(1,+None)
++++#+Reshape+and+compute+final+counts
++++counts+=+counts.reshape(shape).transpose(transpose)[slices]+%2B+1

++++#+Find+maximum+counts+and+return+modals/counts
++++slices+=+[slice(None,+i)+for+i+in+sort.shape]
++++del+slices[axis]
++++index+=+numpy.ogrid[slices]
++++index.insert(axis,+numpy.argmax(counts,+axis=axis))
++++return+sort[index],+counts[index]|code-block|syntax|javascript|659145|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|$]]

Here is a general solution that may be applied along an axis, regardless of values, using purely numpy. I've also found that this is much faster than scipy.stats.mode if there are a lot of unique values.

<pre><code>import numpy

def mode(ndarray, axis=0):
 # Check inputs
 ndarray = numpy.asarray(ndarray)
 ndim = ndarray.ndim
 if ndarray.size == 1:
 return (ndarray[0], 1)
 elif ndarray.size == 0:
 raise Exception('Cannot compute mode on empty array')
 try:
 axis = range(ndarray.ndim)[axis]
 except:
 raise Exception('Axis "{}" incompatible with the {}-dimension array'.format(axis, ndim))

 # If array is 1-D and numpy version is &gt; 1.9 numpy.unique will suffice
 if all([ndim == 1,
 int(numpy.__version__.split('.')[0]) &gt;= 1,
 int(numpy.__version__.split('.')[1]) &gt;= 9]):
 modals, counts = numpy.unique(ndarray, return_counts=True)
 index = numpy.argmax(counts)
 return modals[index], counts[index]

 # Sort array
 sort = numpy.sort(ndarray, axis=axis)
 # Create array to transpose along the axis and get padding shape
 transpose = numpy.roll(numpy.arange(ndim)[::-1], axis)
 shape = list(sort.shape)
 shape[axis] = 1
 # Create a boolean array along strides of unique values
 strides = numpy.concatenate([numpy.zeros(shape=shape, dtype='bool'),
 numpy.diff(sort, axis=axis) == 0,
 numpy.zeros(shape=shape, dtype='bool')],
 axis=axis).transpose(transpose).ravel()
 # Count the stride lengths
 counts = numpy.cumsum(strides)
 counts[~strides] = numpy.concatenate([[0], numpy.diff(counts[~strides])])
 counts[strides] = 0
 # Get shape of padded counts and slice to return to the original shape
 shape = numpy.array(sort.shape)
 shape[axis] += 1
 shape = shape[transpose]
 slices = [slice(None)] * ndim
 slices[axis] = slice(1, None)
 # Reshape and compute final counts
 counts = counts.reshape(shape).transpose(transpose)[slices] + 1

 # Find maximum counts and return modals/counts
 slices = [slice(None, i) for i in sort.shape]
 del slices[axis]
 index = numpy.ogrid[slices]
 index.insert(axis, numpy.argmax(counts, axis=axis))
 return sort[index], counts[index]
</code></pre>

blocks|key|876411|text|在this+method上扩展，应用于查找数据的模式，您可能需要实际数组的索引来查看该值离分布中心有多远。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|876412|(_,+idx,+counts)+=+np.unique(a,+return_index=True,+return_counts=True)
index+=+idx[np.argmax(counts)]
mode+=+a[index]|code-block|syntax|javascript|876413|记住当len(np.argmax(counts))+>1时丢弃该模式|876414|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/28736715/5775959^0|1|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Expanding on <a href="https://stackoverflow.com/a/28736715/5775959">this method</a>, applied to finding the mode of the data where you may need the index of the actual array to see how far away the value is from the center of the distribution. 

<pre><code>(_, idx, counts) = np.unique(a, return_index=True, return_counts=True)
index = idx[np.argmax(counts)]
mode = a[index]
</code></pre>

Remember to discard the mode when len(np.argmax(counts)) > 1

blocks|key|659299|text|在Python+3中，应该可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|659300|max(set(a),+key=lambda+x:+a.count(x))|code-block|syntax|javascript|659301|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|$]]

In Python 3 the following should work:

<pre><code>max(set(a), key=lambda x: a.count(x))
</code></pre>

blocks|key|876546|text|您可以使用以下方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|876547|x+=+np.array([[2,+5,+5,+2],+[2,+7,+8,+5],+[2,+5,+7,+9]])
u,+c+=+np.unique(x,+return_counts=True)
print(u[c+==+np.amax(c)])|code-block|syntax|javascript|876548|这将给出答案：array([2,+5])|offset|length|style|CODE|876549|entityMap^0|0|0|7|D|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use the following approach:
<pre><code>x = np.array([[2, 5, 5, 2], [2, 7, 8, 5], [2, 5, 7, 9]])
u, c = np.unique(x, return_counts=True)
print(u[c == np.amax(c)])
</code></pre>
This will give the answer: <code>array([2, 5])</code>

Suppose I have the following NumPy array:
<pre><code>a = np.array([1,2,3,1,2,1,1,1,3,2,2,1])
</code></pre>
How can I find the most frequent number in this array?

Find the most frequent number in a NumPy array

Python

假设我有以下NumPy数组：a = np.array([1,2,3,1,2,1,1,1,3,2,2,1])如何在这个数组中找到最频繁的数字？

问查找NumPy数组中最常用的数字
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找NumPy数组中最常用的数字EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查找NumPy数组中最常用的数字
EN