สมมติว่าฉันมีรายการต่อไปนี้ใน python:

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

วิธีค้นหาหมายเลขที่พบบ่อยที่สุดในรายการนี้อย่างเป็นระเบียบ?

หากรายการของคุณมี ints ที่ไม่เป็นลบทั้งหมดคุณควรดูที่ numpy.bincounts:

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

จากนั้นอาจใช้ np.argmax:

a = np.array([1,2,3,1,2,1,1,1,3,2,2,1])
counts = np.bincount(a)
print(np.argmax(counts))

สำหรับรายการที่ซับซ้อนมากขึ้น (ซึ่งอาจมีตัวเลขติดลบหรือค่าที่ไม่ใช่จำนวนเต็ม) คุณสามารถใช้np.histogramในลักษณะเดียวกันได้ หรือหากคุณต้องการทำงานใน python โดยไม่ต้องใช้ numpy collections.Counterเป็นวิธีที่ดีในการจัดการข้อมูลประเภทนี้

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

คุณอาจใช้

(values,counts) = np.unique(a,return_counts=True)
ind=np.argmax(counts)
print values[ind]  # prints the most frequent element

หากองค์ประกอบบางส่วนเกิดบ่อยเท่ากับอีกองค์ประกอบหนึ่งรหัสนี้จะส่งคืนเฉพาะองค์ประกอบแรก

หากคุณยินดีที่จะใช้SciPy :

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

การแสดง (โดยใช้ iPython) สำหรับโซลูชันบางอย่างพบได้ที่นี่:

>>> # small array
>>> a = [12,3,65,33,12,3,123,888000]
>>> 
>>> import collections
>>> collections.Counter(a).most_common()[0][0]
3
>>> %timeit collections.Counter(a).most_common()[0][0]
100000 loops, best of 3: 11.3 µs per loop
>>> 
>>> import numpy
>>> numpy.bincount(a).argmax()
3
>>> %timeit numpy.bincount(a).argmax()
100 loops, best of 3: 2.84 ms per loop
>>> 
>>> import scipy.stats
>>> scipy.stats.mode(a)[0][0]
3.0
>>> %timeit scipy.stats.mode(a)[0][0]
10000 loops, best of 3: 172 µs per loop
>>> 
>>> from collections import defaultdict
>>> def jjc(l):
...     d = defaultdict(int)
...     for i in a:
...         d[i] += 1
...     return sorted(d.iteritems(), key=lambda x: x[1], reverse=True)[0]
... 
>>> jjc(a)[0]
3
>>> %timeit jjc(a)[0]
100000 loops, best of 3: 5.58 µs per loop
>>> 
>>> max(map(lambda val: (a.count(val), val), set(a)))[1]
12
>>> %timeit max(map(lambda val: (a.count(val), val), set(a)))[1]
100000 loops, best of 3: 4.11 µs per loop
>>> 

ดีที่สุดคือ 'max' กับ 'set' สำหรับอาร์เรย์ขนาดเล็กเช่นปัญหา

จากข้อมูลของ @David Sanders หากคุณเพิ่มขนาดอาร์เรย์เป็น 100,000 องค์ประกอบอัลกอริทึม "max w / set" จะเป็นวิธีที่แย่ที่สุดในขณะที่วิธี "numpy bincount" เป็นวิธีที่ดีที่สุด

นอกจากนี้หากคุณต้องการรับค่าบ่อยที่สุด (บวกหรือลบ) โดยไม่ต้องโหลดโมดูลใด ๆ คุณสามารถใช้รหัสต่อไปนี้:

lVals = [1,2,3,1,2,1,1,1,3,2,2,1]
print max(map(lambda val: (lVals.count(val), val), set(lVals)))

แม้ว่าคำตอบส่วนใหญ่ข้างต้นจะมีประโยชน์ในกรณีที่คุณ: 1) ต้องการคำตอบเพื่อรองรับค่าที่ไม่ใช่จำนวนเต็มบวก (เช่นลอยหรือจำนวนเต็มลบ ;-)) และ 2) ไม่ได้อยู่ใน Python 2.7 (คอลเลกชันใด ต้องการ) และ 3) ไม่ต้องการเพิ่มการอ้างอิงของ scipy (หรือแม้กระทั่ง numpy) ให้กับโค้ดของคุณจากนั้นโซลูชัน python 2.6 ล้วน ๆ ที่เป็น O (nlogn) (กล่าวคือมีประสิทธิภาพ) เป็นเพียงแค่นี้:

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]

ฉันชอบวิธีแก้ปัญหาโดย JoshAdel

แต่มีเพียงหนึ่งที่จับ

np.bincount()โซลูชั่นที่ใช้งานได้เฉพาะกับตัวเลข

หากคุณมีสตริงcollections.Counterโซลูชันจะเหมาะกับคุณ

การขยายวิธีนี้ใช้กับการค้นหาโหมดของข้อมูลที่คุณอาจต้องการดัชนีของอาร์เรย์จริงเพื่อดูว่าค่าอยู่ห่างจากจุดศูนย์กลางของการกระจายเท่าใด

(_, idx, counts) = np.unique(a, return_index=True, return_counts=True)
index = idx[np.argmax(counts)]
mode = a[index]

อย่าลืมทิ้งโหมดเมื่อ len (np.argmax (counts))> 1

ใน Python 3 สิ่งต่อไปนี้ควรใช้งานได้:

max(set(a), key=lambda x: a.count(x))

เริ่มต้นในPython 3.4ไลบรารีมาตรฐานมีstatistics.modeฟังก์ชันในการส่งคืนจุดข้อมูลที่พบบ่อยที่สุดเพียงจุดเดียว

from statistics import mode

mode([1, 2, 3, 1, 2, 1, 1, 1, 3, 2, 2, 1])
# 1

หากมีหลายโหมดที่มีความถี่เดียวกันให้statistics.modeส่งกลับโหมดแรกที่พบ

เริ่มต้นในPython 3.8การstatistics.multimodeฟังก์ชั่นส่งกลับรายการของค่าเกิดขึ้นบ่อยที่สุดในการสั่งซื้อที่พวกเขาถูกพบครั้งแรก:

from statistics import multimode

multimode([1, 2, 3, 1, 2])
# [1, 2]

นี่คือวิธีแก้ปัญหาทั่วไปที่อาจนำไปใช้กับแกนโดยไม่คำนึงถึงค่าโดยใช้ตัวเลขล้วนๆ ฉันยังพบว่าสิ่งนี้เร็วกว่า scipy.stats.mode มากหากมีค่าที่ไม่ซ้ำกันจำนวนมาก

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] += 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]

ฉันเพิ่งทำโปรเจ็กต์และใช้คอลเลกชั่นเคาน์เตอร์ (ซึ่งทรมานฉัน)

เคาน์เตอร์ในคอลเลกชันมีประสิทธิภาพที่แย่มากในความคิดของฉัน มันเป็นเพียงคลาสการตัดคำสั่ง ()

ที่แย่ไปกว่านั้นคือหากคุณใช้ cProfile เพื่อกำหนดโปรไฟล์วิธีการของมันคุณจะเห็นสิ่งที่ "__missing__" และ "__instancecheck__" จำนวนมากเสียเวลาไปเปล่า ๆ

ระวังการใช้ most_common () เพราะทุกครั้งมันจะเรียกใช้การเรียงลำดับซึ่งทำให้ช้ามาก และถ้าคุณใช้ most_common (x) มันจะเรียกใช้การเรียงลำดับฮีปซึ่งช้าเช่นกัน

Btw, bincount ของ numpy ก็มีปัญหาเช่นกัน: ถ้าคุณใช้ np.bincount ([1,2,4000000]) คุณจะได้อาร์เรย์ที่มีองค์ประกอบ 4000000