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