Trouver le mode d'une liste

vous pouvez utiliser la fonction max et une clé. Jetez un oeil à la fonction Python max en utilisant 'key' et l'expression lambda .

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

vous pouvez utiliser le Counter fourni dans le collections paquet qui a une mode - fonction 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

Note: Counter est nouveau en python 2.7 et n'est pas disponible dans les versions précédentes.

Python 3.4 comprend la méthode statistics.mode , il est donc simple:

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

vous pouvez avoir n'importe quel type d'éléments dans la liste, pas seulement numérique:

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

en prenant une feuille de certains logiciels de statistiques, à savoir SciPy et MATLAB , ceux-ci juste retourner la plus petite valeur commune, donc si deux valeurs se produisent également souvent, le plus petit d'entre eux sont retournés. J'espère qu'un exemple aidera:

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

y a-t-il une raison pour laquelle vous ne pouvez pas suivre cette convention?

il existe de nombreuses façons simples de trouver le mode d'une liste en Python telles que:

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

ou, vous pourriez trouver le max par son compte

max(array, key = array.count)

le problème avec ces deux méthodes est qu'elles ne fonctionnent pas avec plusieurs modes. La première renvoie une erreur, tandis que la seconde renvoie le premier mode.

pour trouver les modes d'un ensemble, vous pouvez utiliser cette fonction:

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

j'ai écrit cette fonction pratique pour trouver le mode.

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

Court, mais de toute façon moche:

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

utilisant un dictionnaire, légèrement moins laid:

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

un peu plus longtemps, mais peut avoir plusieurs modes et peut obtenir la chaîne avec la plupart des comptes ou mélange de types de données.

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 

dans le cas où vous êtes intéressé par le plus petit, le plus grand ou tous les modes:

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

pourquoi pas

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

ceci n'a pas quelques vérifications d'erreurs qu'il devrait avoir, mais il trouvera le mode sans importer Aucune Fonction et affichera un message si toutes les valeurs apparaissent une seule fois. Il détectera également plusieurs articles partageant le même nombre maximum, bien qu'il n'était pas clair si vous vouliez cela.

cette fonction renvoie le ou les modes d'une fonction quel que soit le nombre, ainsi que la fréquence du ou des modes de l'ensemble de données. Si il n'y a pas de mode (ie. tous les éléments se produisent qu'une seule fois), la fonction renvoie une chaîne d'erreur. Ceci est similaire à la fonction D'A_nagpal ci-dessus, mais est, à mon humble avis, plus complet, et je pense que c'est plus facile à comprendre pour n'importe quel novice de Python (tel que le vôtre vraiment) lisant cette question à comprendre.

 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

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

Voici une fonction simple qui obtient le premier mode qui apparaît dans une liste. Il fait un dictionnaire avec les éléments de liste comme clés et le nombre d'occurrences et lit ensuite les valeurs de dict pour obtenir le mode.

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

cela retournera tous les modes:

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

pour qu'un numéro soit un mode , il doit se produire plus de fois que au moins un autre numéro dans la liste, et il doit et non être le seul numéro dans la liste. Ainsi, j'ai remanié la réponse de @mathwizurd (pour utiliser la méthode difference ) comme suit:

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

ces essais sont réussis:

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

si vous voulez une approche claire, utile pour la classe et n'utilisant que des listes et des dictionnaires par compréhension, vous pouvez faire:

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)