Tìm chế độ của danh sách

Đưa ra một danh sách các mục, nhớ lại rằng chế độ của danh sách là mục xảy ra thường xuyên nhất.

Tôi muốn biết cách tạo một chức năng có thể tìm thấy chế độ của danh sách nhưng sẽ hiển thị một thông báo nếu danh sách không có chế độ (ví dụ: tất cả các mục trong danh sách chỉ xuất hiện một lần). Tôi muốn thực hiện chức năng này mà không cần nhập bất kỳ chức năng. Tôi đang cố gắng thực hiện chức năng của riêng mình từ đầu.

Bạn có thể sử dụng maxchức năng và một phím. Hãy xem hàm python max sử dụng biểu thức 'key' và lambda .

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

Bạn có thể sử dụng gói Counterđược cung cấp trong collectionsgói có modechức năng -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

Lưu ý: Bộ đếm mới trong python 2.7 và không có sẵn trong các phiên bản trước.

Python 3.4 bao gồm phương thức statistics.mode, vì vậy nó rất đơn giản:

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

Bạn có thể có bất kỳ loại phần tử nào trong danh sách, không chỉ là số:

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

Lấy một lá từ một số phần mềm thống kê, cụ thể là SciPy và MATLAB , những thứ này chỉ trả về giá trị chung nhỏ nhất, vì vậy nếu hai giá trị xảy ra như nhau thường xuyên, thì giá trị nhỏ nhất sẽ được trả về. Hy vọng một ví dụ sẽ giúp:

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

Có bất kỳ lý do tại sao bạn không thể theo quy ước này?

Có nhiều cách đơn giản để tìm chế độ của danh sách trong Python, chẳng hạn như:

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

Hoặc, bạn có thể tìm tối đa theo số lượng của nó

max(array, key = array.count)

Vấn đề với hai phương pháp đó là chúng không hoạt động với nhiều chế độ. Cái đầu tiên trả về một lỗi, trong khi cái thứ hai trả về chế độ đầu tiên.

Để tìm các chế độ của một bộ, bạn có thể sử dụng chức năng này:

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

Mở rộng câu trả lời của Cộng đồng sẽ không hoạt động khi danh sách trống, đây là mã làm việc cho chế độ:

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

Trong trường hợp bạn quan tâm đến các chế độ nhỏ nhất, lớn nhất hoặc tất cả:

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

Tôi đã viết lên chức năng tiện dụng này để tìm chế độ.

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

Ngắn, nhưng có phần xấu xí:

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

Sử dụng từ điển, hơi xấu xí:

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

Lâu hơn một chút, nhưng có thể có nhiều chế độ và có thể nhận chuỗi với hầu hết số lượng hoặc hỗn hợp các kiểu dữ liệu.

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 

Để một số là một mode, nó phải xuất hiện nhiều lần hơn ít nhất một số khác trong danh sách và nó không phải là số duy nhất trong danh sách. Vì vậy, tôi đã tái cấu trúc câu trả lời của @ mathwizurd (để sử dụng differencephương thức) như sau:

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

Các xét nghiệm này vượt qua thành công:

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

Tại sao không chỉ

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

Điều này không có một vài kiểm tra lỗi mà nó nên có, nhưng nó sẽ tìm chế độ mà không cần nhập bất kỳ chức năng nào và sẽ in một thông báo nếu tất cả các giá trị chỉ xuất hiện một lần. Nó cũng sẽ phát hiện nhiều mục chia sẻ cùng một số lượng tối đa, mặc dù điều đó không rõ ràng nếu bạn muốn điều đó.

Hàm này trả về chế độ hoặc chế độ của hàm cho dù có bao nhiêu, cũng như tần số của chế độ hoặc chế độ trong tập dữ liệu. Nếu không có chế độ (nghĩa là tất cả các mục chỉ xảy ra một lần), hàm sẽ trả về một chuỗi lỗi. Điều này tương tự như chức năng của A_nagpal ở trên nhưng, theo ý kiến ​​khiêm tốn của tôi, đầy đủ hơn và tôi nghĩ rằng sẽ dễ hiểu hơn đối với bất kỳ người mới Python nào (chẳng hạn như bạn thực sự) đọc câu hỏi này để hiểu.

 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

Điều này sẽ trả về tất cả các chế độ:

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

Mã đơn giản tìm thấy chế độ của danh sách mà không cần nhập bất kỳ:

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)

Trong trường hợp có nhiều chế độ, nó sẽ trả về nút tối thiểu.

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

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

Đây là một chức năng đơn giản có chế độ đầu tiên xảy ra trong một danh sách. Nó tạo ra một từ điển với các thành phần danh sách là các khóa và số lần xuất hiện và sau đó đọc các giá trị dict để có chế độ.

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

Nếu bạn muốn một cách tiếp cận rõ ràng, hữu ích cho lớp học và chỉ sử dụng danh sách và từ điển theo cách hiểu, bạn có thể làm:

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}

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

Đây là cách bạn có thể tìm thấy trung bình, trung bình và chế độ của một danh sách:

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

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

Đối với những người tìm kiếm chế độ tối thiểu, ví dụ: trường hợp phân phối hai chế độ, sử dụng numpy.

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

Chế độ của một tập dữ liệu là / là (các) thành viên xảy ra thường xuyên nhất trong tập hợp. Nếu có hai thành viên xuất hiện thường xuyên nhất với cùng số lần, thì dữ liệu có hai chế độ. Cái này được gọi là lưỡng kim .

Chức năng sau modes()có thể hoạt động để tìm (các) chế độ trong danh sách dữ liệu đã cho:

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

Đầu ra:

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

Nếu chúng ta không muốn nhập numpyhoặc pandasgọi bất kỳ hàm nào từ các gói này, thì để có cùng đầu ra này, modes()hàm có thể được viết là:

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