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 max
en 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 Counter
gebruiken die in de collections
pakket 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 mode
moet 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 difference
methode) 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 numpy
of pandas
niet 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]