Поиск режима списка

126

Учитывая список элементов, напомним, что режим списка - это элемент, который встречается наиболее часто.

Я хотел бы знать, как создать функцию, которая может найти режим списка, но которая отображает сообщение, если в списке нет режима (например, все элементы в списке появляются только один раз). Я хочу сделать эту функцию без импорта каких-либо функций. Я пытаюсь создать свою функцию с нуля.

bluelantern
источник
Извините, но вы можете объяснить, что именно вы подразумеваете под «режимом списка»?
Викас
5
@Vikas: режим является наиболее часто встречающимся элементом (если есть). Некоторые определения расширяют его до среднего арифметического всех таких элементов, если их больше одного.
Джереми Роман
Здесь столько неправильных ответов! Например, assert(mode[1, 1, 1]) == Noneи assert(mode[1, 2, 3, 4]) == None. Чтобы число было a mode, оно должно встречаться чаще, чем хотя бы одно другое число в списке, и оно не должно быть единственным числом в списке.
lifebalance

Ответы:

156

Вы можете использовать maxфункцию и клавишу. Взгляните на функцию python max, используя «ключ» и лямбда-выражение .

max(set(lst), key=lst.count)
Давид Дао
источник
6
Это правильный ответ на OP, учитывая, что он не требует дополнительного импорта. Хорошая работа, Дэвид
Джейсон Пархэм
12
Мне кажется, что это бы наработало O(n**2). Является ли?
lirtosiast
7
Это квадратичное время выполнения
Падрайк Каннингем
20
Могли бы просто использовать max(lst, key=lst.count). (И я бы действительно не стал называть список list.)
Стефан Почманн
2
Может ли кто-нибудь объяснить, как это работает для бимодальных дистрибутивов? например, a = [22, 33, 11, 22, 11]; print(max(set(a), key=a.count))возвращается 11. Всегда ли будет возвращать минимальный режим? И если да, то почему?
battey
99

Вы можете использовать Counterпоставляемый в collectionsпакете с modeфункцией -esque

from collections import Counter
data = Counter(your_list_in_here)
data.most_common()   # Returns all unique items and their counts
data.most_common(1)  # Returns the highest occurring item

Примечание. Счетчик является новым в python 2.7 и недоступен в более ранних версиях.

Кристиан Уиттс
источник
19
В вопросе говорится, что пользователь хочет создать функцию с нуля, то есть без импорта.
dbliss
3
Ваша последняя строка возвращает список, содержащий кортеж, содержащий режим и его частоту. Чтобы получить просто режим использования Counter(your_list_in_here).most_common(1)[0][0]. Если существует более одного режима, возвращается произвольный.
Рори Долтон
1
Допустим, есть nсамые обычные modes. Если Counter (your_list_in_here) .most_common (1) [0] [0] предоставит вам первый режим, как вы получите другой, наиболее распространенный режим mode? Просто замените последнее 0на 1? Можно сделать функцию настройки modeпо своему вкусу ..
1
если существует более одного режима, как я могу вернуть наибольшее из этих чисел?
Акин Хван
59

Python 3.4 включает этот метод statistics.mode, поэтому он прост:

>>> from statistics import mode
>>> mode([1, 1, 2, 3, 3, 3, 3, 4])
 3

В списке могут быть элементы любого типа, а не только числовые:

>>> mode(["red", "blue", "blue", "red", "green", "red", "red"])
 'red'
jabaldonedo
источник
17
Выдает ошибку при использовании режима ([1, 1,1,1, 2, 3, 3, 3, 3, 4]), где 1 и 3 повторяются равное количество раз. В идеале должен возвращать наименьшее из числа, которое больше, но равное количество раз. StatisticsError: нет уникального режима; найдено 2 одинаково распространенных значения
aman_novice 01
4
Не использовал этот статистический пакет 3.4, но scipy.stats.mode вернет наименьшее значение, в данном случае 1. Я, однако, предпочел бы
выдавать
2
@aman_novice, проблема решена в Python 3.8. docs.python.org/3/library/statistics.html#statistics.mode
Майкл Д.
2
Также добавлен python 3.8 multimode, который возвращает несколько режимов, если их больше одного.
Стасон
30

Взяв лист из некоторого статистического программного обеспечения, а именно SciPy и MATLAB , они просто возвращают наименьшее наиболее распространенное значение, поэтому, если два значения встречаются одинаково часто, возвращается наименьшее из них. Надеюсь, вам поможет пример:

>>> from scipy.stats import mode

>>> mode([1, 2, 3, 4, 5])
(array([ 1.]), array([ 1.]))

>>> mode([1, 2, 2, 3, 3, 4, 5])
(array([ 2.]), array([ 2.]))

>>> mode([1, 2, 2, -3, -3, 4, 5])
(array([-3.]), array([ 2.]))

Есть ли причина, по которой вы не можете следовать этому соглашению?

Крис
источник
4
Почему возвращается только самый маленький режим, когда их несколько?
zyxue
@zyxue простое статистическое соглашение
chrisfs
2
@chrisfs и чтобы он возвращал самый большой режим, если их несколько?
Акин Хван
25

Есть много простых способов найти режим списка в Python, например:

import statistics
statistics.mode([1,2,3,3])
>>> 3

Или вы можете найти максимум по его количеству

max(array, key = array.count)

Проблема с этими двумя методами в том, что они не работают с несколькими режимами. Первый возвращает ошибку, а второй возвращает первый режим.

Чтобы найти режимы набора, вы можете использовать эту функцию:

def mode(array):
    most = max(list(map(array.count, array)))
    return list(set(filter(lambda x: array.count(x) == most, array)))
mathwizurd
источник
3
При использовании режима выдает ошибку, когда два элемента встречаются одинаковое количество времени.
Абхишек Мишра
Извините, я увидел этот комментарий очень поздно. Statistics.mode (array) вернет ошибку с несколькими режимами, но ни один из других методов не вернет.
mathwizurd
7

Расширение ответа сообщества, которое не будет работать, когда список пуст, вот рабочий код для режима:

def mode(arr):
        if arr==[]:
            return None
        else:
            return max(set(arr), key=arr.count)
Карди Текномо
источник
3

Если вас интересует самый маленький, самый большой или все режимы:

def get_small_mode(numbers, out_mode):
    counts = {k:numbers.count(k) for k in set(numbers)}
    modes = sorted(dict(filter(lambda x: x[1] == max(counts.values()), counts.items())).keys())
    if out_mode=='smallest':
        return modes[0]
    elif out_mode=='largest':
        return modes[-1]
    else:
        return modes
tashuhka
источник
2

Я написал эту удобную функцию для поиска режима.

def mode(nums):
    corresponding={}
    occurances=[]
    for i in nums:
            count = nums.count(i)
            corresponding.update({i:count})

    for i in corresponding:
            freq=corresponding[i]
            occurances.append(freq)

    maxFreq=max(occurances)

    keys=corresponding.keys()
    values=corresponding.values()

    index_v = values.index(maxFreq)
    global mode
    mode = keys[index_v]
    return mode
user2975335
источник
2
Этот метод не сработает, если у двух элементов одинаковые номера. случаев.
Акшайнагпал
2

Коротко, но как-то некрасиво:

def mode(arr) :
    m = max([arr.count(a) for a in arr])
    return [x for x in arr if arr.count(x) == m][0] if m>1 else None

Используя словарь, чуть менее некрасиво:

def mode(arr) :
    f = {}
    for a in arr : f[a] = f.get(a,0)+1
    m = max(f.values())
    t = [(x,f[x]) for x in f if f[x]==m]
    return m > 1 t[0][0] else None
деревенщина
источник
2

Немного длиннее, но может иметь несколько режимов и может получать строку с большинством подсчетов или сочетанием типов данных.

def getmode(inplist):
    '''with list of items as input, returns mode
    '''
    dictofcounts = {}
    listofcounts = []
    for i in inplist:
        countofi = inplist.count(i) # count items for each item in list
        listofcounts.append(countofi) # add counts to list
        dictofcounts[i]=countofi # add counts and item in dict to get later
    maxcount = max(listofcounts) # get max count of items
    if maxcount ==1:
        print "There is no mode for this dataset, values occur only once"
    else:
        modelist = [] # if more than one mode, add to list to print out
        for key, item in dictofcounts.iteritems():
            if item ==maxcount: # get item from original list with most counts
                modelist.append(str(key))
        print "The mode(s) are:",' and '.join(modelist)
        return modelist 
timpjohns
источник
2

Чтобы число было a mode, оно должно встречаться больше раз, чем хотя бы одно другое число в списке, и оно не должно быть единственным числом в списке. Итак, я реорганизовал ответ @mathwizurd (чтобы использовать differenceметод) следующим образом:

def mode(array):
    '''
    returns a set containing valid modes
    returns a message if no valid mode exists
      - when all numbers occur the same number of times
      - when only one number occurs in the list 
      - when no number occurs in the list 
    '''
    most = max(map(array.count, array)) if array else None
    mset = set(filter(lambda x: array.count(x) == most, array))
    return mset if set(array) - mset else "list does not have a mode!" 

Эти тесты проходят успешно:

mode([]) == None 
mode([1]) == None
mode([1, 1]) == None 
mode([1, 1, 2, 2]) == None 
жизненный баланс
источник
1

Почему не просто

def print_mode (thelist):
  counts = {}
  for item in thelist:
    counts [item] = counts.get (item, 0) + 1
  maxcount = 0
  maxitem = None
  for k, v in counts.items ():
    if v > maxcount:
      maxitem = k
      maxcount = v
  if maxcount == 1:
    print "All values only appear once"
  elif counts.values().count (maxcount) > 1:
    print "List has multiple modes"
  else:
    print "Mode of list:", maxitem

У него нет нескольких проверок ошибок, которые он должен иметь, но он найдет режим без импорта каких-либо функций и напечатает сообщение, если все значения появятся только один раз. Он также обнаружит несколько элементов с одинаковым максимальным количеством, хотя было неясно, нужно ли вам это.

lxop
источник
Итак, что я пытаюсь сделать, так это обнаружить несколько элементов, отображающих одинаковое количество, а затем отобразить все элементы с одинаковым количеством
bluelantern
Вы действительно пробовали это сами? Расширение из моего кода здесь, чтобы он печатал все элементы с одинаковым количеством, довольно просто.
lxop
1

Эта функция возвращает режим или режимы функции независимо от их количества, а также частоту режима или режимов в наборе данных. Если режима нет (т. Е. Все элементы встречаются только один раз), функция возвращает строку ошибки. Это похоже на функцию A_nagpal, описанную выше, но, по моему скромному мнению, она более полная, и я думаю, что ее легче понять любым новичкам в Python (например, вашим искренним), читающим этот вопрос, чтобы понять.

 def l_mode(list_in):
    count_dict = {}
    for e in (list_in):   
        count = list_in.count(e)
        if e not in count_dict.keys():
            count_dict[e] = count
    max_count = 0 
    for key in count_dict: 
        if count_dict[key] >= max_count:
            max_count = count_dict[key]
    corr_keys = [] 
    for corr_key, count_value in count_dict.items():
        if count_dict[corr_key] == max_count:
            corr_keys.append(corr_key)
    if max_count == 1 and len(count_dict) != 1: 
        return 'There is no mode for this data set. All values occur only once.'
    else: 
        corr_keys = sorted(corr_keys)
        return corr_keys, max_count
user4406935
источник
Я говорю это только потому, что вы сказали «функция возвращает строку с ошибкой». Считываемая строка return 'There is no mode for this data set. All values occur only once.'может быть преобразована в сообщение об ошибке с tracebackусловием «if: следующая строка с отступом» поднять значение ValueError («Для этого набора данных нет режима. Все значения встречаются только один раз»). Вот список различных типов ошибки вы можете поднять.
1

Это вернет все режимы:

def mode(numbers)
    largestCount = 0
    modes = []
    for x in numbers:
        if x in modes:
            continue
        count = numbers.count(x)
        if count > largestCount:
            del modes[:]
            modes.append(x)
            largestCount = count
        elif count == largestCount:
            modes.append(x)
    return modes
Тим Ортон
источник
1

Простой код, который находит режим списка без импорта:

nums = #your_list_goes_here
nums.sort()
counts = dict()
for i in nums:
    counts[i] = counts.get(i, 0) + 1
mode = max(counts, key=counts.get)

В случае нескольких режимов он должен возвращать минимальный узел.

baby_yoda
источник
0
def mode(inp_list):
    sort_list = sorted(inp_list)
    dict1 = {}
    for i in sort_list:        
            count = sort_list.count(i)
            if i not in dict1.keys():
                dict1[i] = count

    maximum = 0 #no. of occurences
    max_key = -1 #element having the most occurences

    for key in dict1:
        if(dict1[key]>maximum):
            maximum = dict1[key]
            max_key = key 
        elif(dict1[key]==maximum):
            if(key<max_key):
                maximum = dict1[key]
                max_key = key

    return max_key
akshaynagpal
источник
0
def mode(data):
    lst =[]
    hgh=0
    for i in range(len(data)):
        lst.append(data.count(data[i]))
    m= max(lst)
    ml = [x for x in data if data.count(x)==m ] #to find most frequent values
    mode = []
    for x in ml: #to remove duplicates of mode
        if x not in mode:
        mode.append(x)
    return mode
print mode([1,2,2,2,2,7,7,5,5,5,5])
Венката Прасант Т
источник
0

Вот простая функция, которая получает первый режим, который встречается в списке. Он создает словарь с элементами списка в качестве ключей и количества вхождений, а затем считывает значения dict, чтобы получить режим.

def findMode(readList):
    numCount={}
    highestNum=0
    for i in readList:
        if i in numCount.keys(): numCount[i] += 1
        else: numCount[i] = 1
    for i in numCount.keys():
        if numCount[i] > highestNum:
            highestNum=numCount[i]
            mode=i
    if highestNum != 1: print(mode)
    elif highestNum == 1: print("All elements of list appear once.")
СМС фон дер Танн
источник
0

Если вам нужен четкий подход, полезный для класса и использующий только списки и словари для понимания, вы можете:

def mode(my_list):
    # Form a new list with the unique elements
    unique_list = sorted(list(set(my_list)))
    # Create a comprehensive dictionary with the uniques and their count
    appearance = {a:my_list.count(a) for a in unique_list} 
    # Calculate max number of appearances
    max_app = max(appearance.values())
    # Return the elements of the dictionary that appear that # of times
    return {k: v for k, v in appearance.items() if v == max_app}
Мария Фрэнсис Гаска
источник
0
#function to find mode
def mode(data):  
    modecnt=0
#for count of number appearing
    for i in range(len(data)):
        icount=data.count(data[i])
#for storing count of each number in list will be stored
        if icount>modecnt:
#the loop activates if current count if greater than the previous count 
            mode=data[i]
#here the mode of number is stored 
            modecnt=icount
#count of the appearance of number is stored
    return mode
print mode(data1)

источник
Вы должны пояснить свой ответ комментариями или более подробной информацией
Майкл
0

Вот как вы можете найти среднее значение, медианное значение и режим списка:

import numpy as np
from scipy import stats

#to take input
size = int(input())
numbers = list(map(int, input().split()))

print(np.mean(numbers))
print(np.median(numbers))
print(int(stats.mode(numbers)[0]))
Панкай
источник
0
import numpy as np
def get_mode(xs):
    values, counts = np.unique(xs, return_counts=True)
    max_count_index = np.argmax(counts) #return the index with max value counts
    return values[max_count_index]
print(get_mode([1,7,2,5,3,3,8,3,2]))
сим
источник
0

Для тех, кто ищет минимальный режим, например: случай бимодального распределения с использованием numpy.

import numpy as np
mode = np.argmax(np.bincount(your_list))
V3K3R
источник
0

Режим набора данных - это элемент (ы), который (а) наиболее часто встречается в наборе. Если два члена появляются чаще всего с одинаковым количеством раз, то данные имеют два режима. Это называется бимодальным .

Если имеется более двух режимов, данные будут называться мультимодальными . Если все элементы в наборе данных появляются одинаковое количество раз, то набор данных вообще не имеет режима .

Следующая функция modes()может работать для поиска режима (ов) в заданном списке данных:

import numpy as np; import pandas as pd

def modes(arr):
    df = pd.DataFrame(arr, columns=['Values'])
    dat = pd.crosstab(df['Values'], columns=['Freq'])
    if len(np.unique((dat['Freq']))) > 1:
        mode = list(dat.index[np.array(dat['Freq'] == max(dat['Freq']))])
        return mode
    else:
        print("There is NO mode in the data set")

Вывод:

# For a list of numbers in x as
In [1]: x = [2, 3, 4, 5, 7, 9, 8, 12, 2, 1, 1, 1, 3, 3, 2, 6, 12, 3, 7, 8, 9, 7, 12, 10, 10, 11, 12, 2]
In [2]: modes(x)
Out[2]: [2, 3, 12]
# For a list of repeated numbers in y as
In [3]: y = [2, 2, 3, 3, 4, 4, 10, 10]
In [4]: modes(y)
There is NO mode in the data set
# For a list of stings/characters in z as
In [5]: z = ['a', 'b', 'b', 'b', 'e', 'e', 'e', 'd', 'g', 'g', 'c', 'g', 'g', 'a', 'a', 'c', 'a']
In [6]: modes(z)
Out[6]: ['a', 'g']

Если мы не хотим импортировать numpyили pandasвызывать какую-либо функцию из этих пакетов, то для получения такого же вывода modes()функцию можно записать как:

def modes(arr):
    cnt = []
    for i in arr:
        cnt.append(arr.count(i))
    uniq_cnt = []
    for i in cnt:
        if i not in uniq_cnt:
            uniq_cnt.append(i)
    if len(uniq_cnt) > 1:
        m = []
        for i in list(range(len(cnt))):
            if cnt[i] == max(uniq_cnt):
                m.append(arr[i])
        mode = []
        for i in m:
            if i not in mode:
                mode.append(i)
        return mode
    else:
        print("There is NO mode in the data set")
Shubh
источник