De modus van een lijst zoeken

Gegeven een lijst met items, bedenk dan dat de modusvan de lijst het item is dat het vaakst voorkomt.

Ik zou graag willen weten hoe ik een functie kan maken die de modus van een lijst kan vinden, maar die een bericht weergeeft als de lijst geen modus heeft (bijv. alle items in de lijst verschijnen maar één keer). Ik wil deze functie maken zonder functies te importeren. Ik probeer mijn eigen functie helemaal opnieuw te maken.


Antwoord 1, autoriteit 100%

U kunt de functie maxen een sleutel gebruiken. Bekijk de python max-functie met ‘key’ en lambda-expressie.

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

Antwoord 2, autoriteit 59%

U kunt de Countergebruiken die in de collectionspakket met een mode-achtige functie

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

Opmerking: Teller is nieuw in python 2.7 en is niet beschikbaar in eerdere versies.


Antwoord 3, autoriteit 37%

Python 3.4 bevat de methode statistics.mode, dus het is duidelijk:

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

Je kunt elk type elementen in de lijst hebben, niet alleen numerieke:

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

Antwoord 4, autoriteit 17%

Een blik werpen op een aantal statistische software, namelijk SciPy en MATLAB, deze geven alleen de kleinste terug gemeenschappelijke waarde, dus als twee waarden even vaak voorkomen, wordt de kleinste hiervan geretourneerd. Hopelijk helpt een voorbeeld:

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

Is er een reden waarom u deze conventie niet kunt volgen?


Antwoord 5, autoriteit 16%

Er zijn veel eenvoudige manieren om de modus van een lijst in Python te vinden, zoals:

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

Of je zou het maximum kunnen vinden door zijn telling

max(array, key = array.count)

Het probleem met die twee methoden is dat ze niet werken met meerdere modi. De eerste retourneert een fout, terwijl de tweede de eerste modus retourneert.

Om de modi van een set te vinden, kun je deze functie gebruiken:

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

Antwoord 6, autoriteit 4%

Uitbreiding van het Community-antwoord dat niet werkt als de lijst leeg is, hier is de werkcode voor modus:

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

Antwoord 7, autoriteit 2%

In het geval u geïnteresseerd bent in de kleinste, grootste of alle modi:

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

Antwoord 8

Ik heb deze handige functie geschreven om de modus te vinden.

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

Antwoord 9

Kort, maar op de een of andere manier lelijk:

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

Een woordenboek gebruiken, iets minder lelijk:

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

Antwoord 10

Een beetje langer, maar kan meerdere modi hebben en kan een tekenreeks krijgen met de meeste tellingen of een combinatie van gegevenstypen.

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 

Antwoord 11

Voor een modemoet een getal vaker voorkomen dan ten minste één ander getalin de lijst, en niethet enige nummer in de lijst zijn. Dus heb ik het antwoord van @mathwizurd aangepast (om de differencemethode) als volgt:

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

Deze tests zijn geslaagd:

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

Antwoord 12

Waarom niet gewoon

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

Dit heeft niet een paar foutcontroles die het zou moeten hebben, maar het zal de modus vinden zonder functies te importeren en een bericht afdrukken als alle waarden slechts één keer verschijnen. Het zal ook meerdere items detecteren die hetzelfde maximale aantal delen, hoewel het niet duidelijk was of je dat wilde.


Antwoord 13

Deze functie retourneert de modus of modi van een functie, ongeacht hoeveel, evenals de frequentie van de modus of modi in de dataset. Als er geen modus is (dwz alle items komen slechts één keer voor), retourneert de functie een foutreeks. Dit is vergelijkbaar met de functie van A_nagpal hierboven, maar is naar mijn bescheiden mening completer en ik denk dat het gemakkelijker te begrijpen is voor alle Python-beginners (zoals ondergetekende) die deze vraag lezen om te begrijpen.

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

Antwoord 14

Hiermee worden alle modi geretourneerd:

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

Antwoord 15

Voor degenen die op zoek zijn naar de minimale modus, bijvoorbeeld: geval van bimodale distributie, met numpy.

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

Antwoord 16

Eenvoudige code die de modus van de lijst vindt zonder enige invoer:

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)

In het geval van meerdere modi, zou het de minimale node moeten retourneren.


Antwoord 17

Modus van een dataset is/zijn de leden die het vaakst voorkomen in de set. Als er twee leden zijn die het vaakst met hetzelfde aantal keren voorkomen, hebben de gegevens twee modi. Dit wordt bimodaal genoemd.

Als er meer dan 2 modi zijn, worden de gegevens multimodaal genoemd. Als alle leden in de dataset hetzelfde aantal keren voorkomen, heeft de dataset helemaal geen modus.

De volgende functiemodi() kunnen werken om modus(sen) in een gegeven lijst met gegevens:

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

Uitvoer:

# 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)
Out[4]: There is NO mode in the data set
# For a list of strings/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']

Als we numpyof pandasniet willen importeren om een functie uit deze pakketten aan te roepen, dan om dezelfde uitvoer te krijgen, modes()functie kan worden geschreven als:

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

Antwoord 18

Oké!Dus de community heeft al veel antwoorden en sommige hebben een andere functie gebruikt en dat wil je niet.
laten we onze zeer eenvoudige en gemakkelijk te begrijpenfunctie maken.

import numpy as np
#Declare Function Name
def calculate_mode(lst):

De volgende stap is het vinden van Unieke elementenin de lijst en hun respectievelijke frequentie.

unique_elements,freq = np.unique(lst, return_counts=True)

Download modus

max_freq = np.max(freq)   #maximum frequency
mode_index = np.where(freq==max_freq)  #max freq index
mode = unique_elements[mode_index]   #get mode by index
return mode

Voorbeeld

lst =np.array([1,1,2,3,4,4,4,5,6])
print(calculate_mode(lst))
>>> Output [4]

Antwoord 19

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

Antwoord 20

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

Antwoord 21

Hier is een eenvoudige functie die de eerste modus krijgt die in een lijst voorkomt. Het maakt een woordenboek met de lijstelementen als sleutels en aantal keren dat het voorkomt en leest vervolgens de dict-waarden om de modus te krijgen.

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

Antwoord 22

Als je een duidelijke aanpak wilt, handig voor in de klas en alleen gebruik maakt van lijsten en woordenboeken op basis van begrip, dan kun je het volgende doen:

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}

Antwoord 23

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

Antwoord 24

Zo kunt u het gemiddelde, de mediaan en de modus van een lijst vinden:

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

Antwoord 25

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

Antwoord 26

Probeer misschien het volgende. Het is O(n) en geeft een lijst met floats (of ints) terug. Het wordt grondig, automatisch getest. Het gebruikt collections.defaultdict, maar ik denk dat je er niet tegen bent om dat te gebruiken. Het is ook te vinden op https://stromberg.dnsalias.org/~strombrg/stddev. html

def compute_mode(list_: typing.List[float]) -> typing.List[float]:
    """                       
    Compute the mode of list_.
    Note that the return value is a list, because sometimes there is a tie for "most common value".
    See https://stackoverflow.com/questions/10797819/finding-the-mode-of-a-list
    """                                                                                                        
    if not list_:
        raise ValueError('Empty list')
    if len(list_) == 1:           
        raise ValueError('Single-element list')
    value_to_count_dict: typing.DefaultDict[float, int] = collections.defaultdict(int)
    for element in list_:
        value_to_count_dict[element] += 1
    count_to_values_dict = collections.defaultdict(list)
    for value, count in value_to_count_dict.items():   
        count_to_values_dict[count].append(value)                           
    counts = list(count_to_values_dict)
    if len(counts) == 1:                                                                            
        raise ValueError('All elements in list are the same')          
    maximum_occurrence_count = max(counts)
    if maximum_occurrence_count == 1:
        raise ValueError('No element occurs more than once')
    minimum_occurrence_count = min(counts)
    if maximum_occurrence_count <= minimum_occurrence_count:
        raise ValueError('Maximum count not greater than minimum count')
    return count_to_values_dict[maximum_occurrence_count]

Other episodes