python - font - Encontrar el modo de una lista

subplot title python

Question

Dada una lista de elementos, recuerde que el modo de la lista es el elemento que ocurre con mayor frecuencia.

Me gustaría saber cómo crear una función que pueda encontrar el modo de una lista pero que muestre un mensaje si la lista no tiene un modo (por ejemplo, todos los elementos de la lista solo aparecen una vez). Quiero hacer esta función sin importar ninguna función. Estoy tratando de hacer mi propia función desde cero.

Answer 1

¿Por qué no solo

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

Esto no tiene algunas comprobaciones de error que debería tener, pero encontrará el modo sin importar ninguna función e imprimirá un mensaje si todos los valores aparecen solo una vez. También detectará varios elementos que comparten el mismo recuento máximo, aunque no estaba claro si usted quería eso.

Answer 2

Aquí hay una función simple que obtiene el primer modo que ocurre en una lista. Hace un diccionario con los elementos de la lista como claves y número de apariciones y luego lee los valores dict para obtener el 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.")

Answer 3

Corto, pero de alguna manera feo:

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 un diccionario, un poco menos feo:

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

Answer 4

En caso de que esté interesado en el modo más pequeño, más grande o 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

Answer 5

Escribí esta práctica función para encontrar el 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

Answer 6

Esta función devuelve el modo o modos de una función sin importar cuántos, así como la frecuencia del modo o modos en el conjunto de datos. Si no hay un modo (es decir, todos los elementos aparecen solo una vez), la función devuelve una cadena de error. Esto es similar a la función de A_nagpal anterior, pero es, en mi humilde opinión, más completo, y creo que es más fácil de entender para cualquier principiante de Python (como el tuyo) leer esta pregunta para entenderla.

 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

Answer 7

Esto devolverá todos los 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

Answer 8

Hay muchas formas simples de encontrar el modo de una lista en Python, como por ejemplo:

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

O bien, podrías encontrar el máximo por su conteo

max(array, key = array.count)

El problema con esos dos métodos es que no funcionan con múltiples modos. El primero devuelve un error, mientras que el segundo devuelve el primer modo.

Para encontrar los modos de un conjunto, puede usar esta función:

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

Answer 9

Para que un número sea un mode , debe ocurrir más veces que al menos otro número en la lista, y no debe ser el único número en la lista. Entonces, reformulé la respuesta de @ mathwizurd (para usar el método de difference ) de la siguiente manera:

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

Estas pruebas pasan exitosamente:

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

Answer 10

Puede usar el Counter suministrado en el paquete de collections que tiene una función de mode -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: Counter es nuevo en Python 2.7 y no está disponible en versiones anteriores.

Answer 11

Puede usar la función max y una clave. Eche un vistazo a la función máxima de Python usando ''clave'' y expresión lambda .

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

Answer 12

Python 3.4 incluye el método statistics.mode , por lo que es sencillo:

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

Puede tener cualquier tipo de elementos en la lista, no solo numéricos:

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

Answer 13

Si quieres un enfoque claro, útil para el aula y solo usar listas y diccionarios por comprensión, puedes hacer:

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}

Answer 14

Tomando una hoja de algún software de estadísticas, concretamente SciPy y MATLAB , estos solo devuelven el valor más pequeño más común, de modo que si dos valores ocurren con la misma frecuencia, se devuelve el más pequeño de estos. Esperemos que un ejemplo ayude:

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

¿Hay alguna razón por la cual no puedes seguir esta convención?

Answer 15

Un poco más, pero puede tener múltiples modos y puede obtener cadenas con la mayoría de los conteos o la combinación de tipos de datos.

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

Answer 16

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

Answer 17

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

Answer 18

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