webentwicklung-frage-antwort-db.com.de

Den Modus einer Liste finden

Denken Sie daran, dass der Modus der Liste das Element ist, das am häufigsten vorkommt.

Ich möchte wissen, wie eine Funktion erstellt wird, die den Modus einer Liste finden kann, aber eine Meldung anzeigt, wenn die Liste keinen Modus hat (z. B. erscheinen alle Elemente in der Liste nur einmal). Ich möchte diese Funktion erstellen, ohne Funktionen zu importieren. Ich versuche, meine eigene Funktion von Grund auf zu erstellen.

88
bluelantern

Sie können die Funktion max und eine Taste verwenden. Schauen Sie sich die Funktion python max mit 'key' und dem Lambda-Ausdruck an .

max(set(list), key=list.count)
113
David Dao

Sie können das Paket Counter verwenden, das im Paket collections enthalten ist und über eine mode_esque-Funktion verfügt

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

Hinweis: Counter ist neu in Python 2.7 und in früheren Versionen nicht verfügbar.

86
Christian Witts

Python 3.4 enthält die Methode statistics.mode , daher ist es unkompliziert:

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

Sie können beliebige Arten von Elementen in der Liste haben, nicht nur numerische Elemente:

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

Es gibt viele einfache Möglichkeiten, den Modus einer Liste in Python zu finden, z.

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

Oder Sie finden das Maximum anhand der Anzahl

max(array, key = array.count)

Das Problem bei diesen beiden Methoden ist, dass sie nicht mit mehreren Modi arbeiten. Der erste gibt einen Fehler zurück, während der zweite den ersten Modus zurückgibt. 

Um die Modi eines Sets zu finden, können Sie diese Funktion verwenden:

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

Ein Blatt aus einer Statistiksoftware, nämlich SciPy und MATLAB , gibt nur den kleinsten häufigsten Wert zurück. Wenn also zwei Werte gleich häufig auftreten, werden die kleinsten Werte zurückgegeben. Hoffentlich hilft ein Beispiel:

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

Gibt es einen Grund, warum Sie dieser Konvention nicht folgen können?

21
Chris

Wenn Sie sich für den kleinsten, größten oder für alle Modi interessieren:

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

Ein wenig länger, kann aber mehrere Modi haben und kann mit den meisten Zählungen oder einer Mischung von Datentypen eine Zeichenfolge erhalten. 

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

Erweiterung der Community-Antwort, die nicht funktioniert, wenn die Liste leer ist. Hier ist der Arbeitscode für den Modus:

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

Ich habe diese praktische Funktion geschrieben, um den Modus zu finden. 

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

Kurz, aber irgendwie hässlich:

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

Mit einem Wörterbuch etwas weniger hässlich:

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
Carl

Warum nicht gerade?

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

Es gibt nicht einige Fehlerprüfungen, die es haben sollte, aber es wird den Modus finden, ohne dass Funktionen importiert werden. Wenn alle Werte nur einmal vorkommen, wird eine Meldung ausgegeben. Es werden auch mehrere Elemente mit der gleichen maximalen Anzahl erkannt, obwohl nicht klar ist, ob Sie dies wünschen. 

1
lxop

Diese Funktion gibt den Modus oder die Modi einer Funktion unabhängig von der Anzahl sowie die Häufigkeit des Modus oder der Modi im Datensatz zurück. Wenn es keinen Modus gibt (dh alle Elemente nur einmal vorkommen), gibt die Funktion eine Fehlerzeichenfolge zurück. Dies ist der oben beschriebenen Funktion von A_nagpal ähnlich, ist jedoch meiner bescheidenen Meinung nach vollständiger, und ich denke, es ist für jeden Python-Neuling (wie wirklich Ihr), der diese Frage liest, einfacher zu verstehen.

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

So können Sie Mittelwert, Median und Modus einer Liste ermitteln:

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

Dadurch werden alle Modi zurückgegeben:

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
0
Tim Orton

Hier ist eine einfache Funktion, die den ersten Modus abruft, der in einer Liste vorkommt. Es erstellt ein Wörterbuch mit den Listenelementen als Schlüssel und Anzahl der Vorkommen und liest dann die Diktierwerte, um den Modus zu erhalten.

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(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
0
akshaynagpal
#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
Rinki Nag

Wenn Sie einen klaren Ansatz wünschen, der für das Klassenzimmer nützlich ist und nur Listen und Wörterbücher nach Verständnis verwendet, können Sie Folgendes tun:

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}

Damit eine Zahl eine mode ist, muss sie öfter als mindestens eine andere Zahl in der Liste vorkommen, und es darf nicht die einzige Zahl in der Liste sein. Also habe ich die Antwort von @ mathwizurd (zur Verwendung der difference -Methode) wie folgt umgestaltet: 

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

Diese Tests bestehen erfolgreich: 

mode([]) == None 
mode([1]) == None
mode([1, 1]) == None 
mode([1, 1, 2, 2]) == None 
0
lifebalance
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
sim
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