Localizando o modo de uma lista

Dada uma lista de itens, lembre-se de que o modo da lista é o item que ocorre com mais frequência.

Gostaria de saber como criar uma função que pode encontrar o modo de uma lista, mas que exibe uma mensagem se a lista não tiver um modo (por exemplo, todos os itens da lista aparecem apenas uma vez). Eu quero fazer essa função sem importar nenhuma função. Estou tentando fazer minha própria função do zero.

Você pode usar a maxfunção e uma tecla. Veja a função python max usando a expressão 'key' e lambda .

max(set(lst), key=lst.count)

Você pode usar o Counterfornecido na collectionsembalagem que possui uma modefunção -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

Nota: O contador é novo no python 2.7 e não está disponível nas versões anteriores.

O Python 3.4 inclui o método statistics.mode, por isso é direto:

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

Você pode ter qualquer tipo de elemento na lista, não apenas numérico:

>>> mode(["red", "blue", "blue", "red", "green", "red", "red"])
 'red'

Tomando uma folha de alguns softwares de estatística, como SciPy e MATLAB , eles retornam o menor valor mais comum; portanto, se dois valores ocorrem com a mesma frequência, o menor deles é retornado. Espero que um exemplo ajude:

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

Existe alguma razão para você não seguir esta convenção?

Existem muitas maneiras simples de encontrar o modo de uma lista no Python, como:

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

Ou você pode encontrar o máximo pela contagem

max(array, key = array.count)

O problema com esses dois métodos é que eles não funcionam com vários modos. O primeiro retorna um erro, enquanto o segundo retorna o primeiro modo.

Para encontrar os modos de um conjunto, você pode usar esta função:

def mode(array):
    most = max(list(map(array.count, array)))
    return list(set(filter(lambda x: array.count(x) == most, array)))

Estendendo a resposta da Comunidade que não funcionará quando a lista estiver vazia, aqui está o código de funcionamento para o modo:

def mode(arr):
        if arr==[]:
            return None
        else:
            return max(set(arr), key=arr.count)

Caso você esteja interessado nos modos menor, maior ou todos:

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

Eu escrevi esta função útil para encontrar o modo.

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

Curto, mas de alguma forma feio:

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

Usando um dicionário, um pouco menos feio:

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

Um pouco mais, mas pode ter vários modos e obter string com a maioria das contagens ou combinação de tipos de dados.

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 

Para um número para ser um mode, deve ocorrer com mais número de vezes que pelo menos um outro número na lista, e deve não ser o único número na lista. Então, refatorei a resposta de @ mathwizurd (para usar o differencemétodo) da seguinte maneira:

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

Esses testes são aprovados com êxito:

mode([]) == None 
mode([1]) == None
mode([1, 1]) == None 
mode([1, 1, 2, 2]) == None 

Por que não apenas

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

Isso não possui algumas verificações de erro que deveria ter, mas encontrará o modo sem importar nenhuma função e imprimirá uma mensagem se todos os valores aparecerem apenas uma vez. Ele também detectará vários itens que compartilham a mesma contagem máxima, embora não esteja claro se você deseja isso.

Essa função retorna o modo ou modos de uma função, não importa quantos, assim como a frequência do modo ou modos no conjunto de dados. Se não houver modo (ou seja, todos os itens ocorrem apenas uma vez), a função retornará uma sequência de erros. Isso é semelhante à função de A_nagpal acima, mas é, na minha humilde opinião, mais completo, e acho que é mais fácil entender para qualquer iniciante em Python (como o seu verdadeiramente) lendo esta pergunta.

 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

Isso retornará todos os modos:

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

Código simples que localiza o modo da lista sem nenhuma importação:

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)

No caso de vários modos, ele deve retornar o nó mínimo.

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

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

Aqui está uma função simples que obtém o primeiro modo que ocorre em uma lista. Faz um dicionário com os elementos da lista como chaves e número de ocorrências e depois lê os valores de ditado para obter o modo.

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

Se você deseja uma abordagem clara, útil para a sala de aula e usando apenas listas e dicionários por compreensão, você pode:

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}

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

Aqui está como você pode encontrar média, mediana e modo de uma lista:

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

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

Para quem procura o modo mínimo, por exemplo: caso de distribuição bimodal, usando numpy.

import numpy as np
mode = np.argmax(np.bincount(your_list))

O modo de um conjunto de dados é / são os membros que ocorrem com mais freqüência no conjunto. Se houver dois membros que aparecem com mais frequência com o mesmo número de vezes, os dados terão dois modos. Isso é chamado bimodal .

A função a seguir modes()pode funcionar para encontrar o (s) modo (s) em uma determinada lista de dados:

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

Resultado:

# 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']

Se não queremos importar numpyou pandaschamar qualquer função desses pacotes, para obter essa mesma saída, a modes()função pode ser escrita como:

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