একটি তালিকার মোড সন্ধান করা হচ্ছে

Question

আইটেমের একটি তালিকা দেওয়া হয়েছে, মনে রাখবেন যে তালিকার মোডটি এমন আইটেম যা প্রায়শই ঘটে।

আমি কীভাবে একটি ফাংশন তৈরি করতে পারি যা তালিকার মোড খুঁজে পেতে পারে তবে তালিকার মোড না থাকলে কোনও বার্তা প্রদর্শন করে (উদাহরণস্বরূপ, তালিকার সমস্ত আইটেম কেবল একবার প্রদর্শিত হবে)। আমি কোনও ফাংশন আমদানি না করে এই ফাংশনটি তৈরি করতে চাই। আমি স্ক্র্যাচ থেকে নিজের ফাংশনটি তৈরি করার চেষ্টা করছি।

Comments

দুঃখিত, তবে 'তালিকার মোড' বলতে আপনার অর্থ কী বোঝাতে পারেন?

— বিকাশ

@ ভিকাস: মোডটি সর্বাধিক ঘন ঘন ঘটে যাওয়া উপাদান (যদি থাকে)। কিছু সংজ্ঞা এ জাতীয় সমস্ত উপাদানগুলির গাণিতিক গড় গ্রহণ করতে প্রসারিত করে যদি একের বেশি থাকে।

— জেরেমি রোমান

এত ভুল উত্তর এখানে! যেমন assert(mode[1, 1, 1]) == Noneএবং assert(mode[1, 2, 3, 4]) == None। একটি সংখ্যা হওয়ার জন্য mode, এটি অবশ্যই তালিকার অন্তত অন্য একটি সংখ্যার চেয়ে বেশি সংখ্যক বার সংঘটিত হতে হবে এবং তালিকার এটি কেবলমাত্র সংখ্যারই হবে না ।

— লাইফব্লেন্স

Answer 1

আপনি maxফাংশন এবং একটি কী ব্যবহার করতে পারেন । 'কী' এবং ল্যাম্বদা এক্সপ্রেশন ব্যবহার করে পাইথন সর্বাধিক ফাংশনটি দেখুন ।

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

Comments

এটি কোনও অতিরিক্ত আমদানির প্রয়োজন হয় না বিবেচনা করে এটি ওপির সঠিক উত্তর। ভাল কাজ, ডেভিড

— জেসন পারহাম

আমার কাছে মনে হচ্ছে এটি চলবে O(n**2)। এটা কি পারে?

— lirtosiast

— এটিতে

শুধু ব্যবহার করতে পারে max(lst, key=lst.count)। (এবং আমি সত্যিই একটি তালিকা কল করব না list।)

— স্টিফান পোচম্যান

কেউ কী দ্বি-মডেল বিতরণের জন্য এটি কাজ করে তা ব্যাখ্যা করতে পারেন? যেমন a = [22, 33, 11, 22, 11]; print(max(set(a), key=a.count))আয় 11। এটি কি সর্বদা সর্বনিম্ন মোডে ফিরে আসবে? আর যদি তাই হয় তবে কেন?

— battey

Answer 2

আপনি Counterসরবরাহ করা collectionsপ্যাকেজটিতে ব্যবহার করতে পারেন যার একটি- modeস্পেস ফাংশন রয়েছে

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

দ্রষ্টব্য: অজগর ২.7 এ কাউন্টারটি নতুন এবং পূর্ববর্তী সংস্করণগুলিতে পাওয়া যায় না।

Comments

প্রশ্নটিতে বলা হয়েছে যে ব্যবহারকারী স্ক্র্যাচ থেকে কোনও ফাংশন তৈরি করতে চায় - অর্থাত্ কোনও আমদানি নয়।

— dbliss

আপনার শেষ লাইনে একটি মোড এবং এর ফ্রিকোয়েন্সি সমন্বিত একটি টুপলযুক্ত একটি তালিকা ফিরে আসে। মাত্র একটি মোড ব্যবহার পেতে Counter(your_list_in_here).most_common(1)[0][0]। যদি একাধিক মোড থাকে তবে এটি একটি স্বেচ্ছাসেবীকে প্রদান করে।

— ররি ডাউলটন

ধরা যাক nসর্বাধিক প্রচলিত আছে modes। যদি কাউন্টার (আপনার_লিস্ট_ইন_এখানে)। মোস্ট_কমোন (1) [0] [0] আপনাকে প্রথম মোডে পেয়ে যায়, তবে আপনি কীভাবে অন্য কোনও সাধারণ দেখতে পাবেন mode? শুধু 0সঙ্গে শেষ প্রতিস্থাপন 1? কেউ modeতাদের পছন্দ অনুসারে কাস্টমাইজ করতে একটি ফাংশন তৈরি করতে পারে ..

যদি একাধিক মোড থাকে তবে আমি এই সংখ্যার বৃহত্তমটি কীভাবে ফিরিয়ে দেব?

— আকিন হাওয়ান

Answer 3

পাইথন ৩.৪ এ পদ্ধতিটি অন্তর্ভুক্ত রয়েছে statistics.mode, তাই এটি সোজা:

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

কেবলমাত্র সংখ্যায় নয়, তালিকায় আপনার কোনও ধরণের উপাদান থাকতে পারে:

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

Comments

মোড ([1, 1,1,1, 2, 3, 3, 3, 3, 4]) ব্যবহার করতে গিয়ে ত্রুটি ফেলে যেখানে 1 এবং 3 সমান সংখ্যার পুনরাবৃত্তি করে। আদর্শভাবে, সংখ্যার মধ্যে সবচেয়ে ছোট কিন্তু সমান সংখ্যার বারটি ফিরে আসা উচিত। পরিসংখ্যানের ত্রুটি: কোনও অনন্য মোড নয়; 2 সমানভাবে সাধারণ মান খুঁজে পেয়েছে

— aman_novice

এই 3.4 পরিসংখ্যান প্যাকেজটি ব্যবহার করেন নি, তবে scipy.stats.mode সবচেয়ে ক্ষুদ্রতমটি ফিরিয়ে দেবে, এই ক্ষেত্রে ১. আমি তবে কিছু ক্ষেত্রে ত্রুটি ছুঁড়ে মারতে পছন্দ করব ...

— শব্দগঠনে

@ আমান_নোভিস, পাইথন ৩.৮ এ সমস্যাটি সমাধান করা হয়েছিল। docs.python.org/3/library/statistics.html#statistics.mode

— মাইকেল ডি

পাইথন ৩.৮ এছাড়াও যুক্ত করেছে multimode, যখন একাধিক মোড থাকে যখন একাধিক মোড ফিরে আসে।

— ঝাঁপ দাও

Answer 4

কিছু পরিসংখ্যান সফ্টওয়্যার, যেমন সাইপাই এবং ম্যাটল্যাব থেকে একটি পাতা নেওয়া , এগুলি কেবলমাত্র সর্বাধিক সাধারণতম মানটি দেয়, সুতরাং যদি দুটি মান সমানভাবে ঘটে থাকে তবে এর মধ্যে ক্ষুদ্রতমটি ফিরে আসবে। আশা করি একটি উদাহরণ সাহায্য করবে:

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

আপনি এই সম্মেলনটি অনুসরণ করতে না পারার কোনও কারণ আছে কি?

Comments

যখন একাধিক থাকবে তখন কেন কেবল ক্ষুদ্রতম মোড ফিরে আসবে?

— zyxue

@zyxue সরল পরিসংখ্যান কনভেনশন

— ক্রিশ্ফস

@ ক্রিসফস এবং একাধিক থাকলে এটি বৃহত্তম মোডে ফেরাতে চান?

— আকিন হাওয়ান

Answer 5

পাইথনের তালিকার মোড খুঁজতে অনেকগুলি সহজ উপায় রয়েছে যেমন:

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

অথবা, আপনি তার গণনা দ্বারা সর্বাধিক সন্ধান করতে পারেন

max(array, key = array.count)

এই দুটি পদ্ধতির সমস্যা হ'ল তারা একাধিক মোডের সাথে কাজ করে না। প্রথমটি একটি ত্রুটি প্রদান করে, যখন দ্বিতীয়টি প্রথম মোড দেয়।

কোনও সেটটির মোডগুলি সন্ধান করতে আপনি এই ফাংশনটি ব্যবহার করতে পারেন:

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

Comments

মোড ব্যবহার করে ত্রুটি দেয় যখন দুটি উপাদান একই পরিমাণে ঘটে থাকে।

— অভিষেক মিশ্র

দুঃখিত, এই মন্তব্যটি সত্যই দেরিতে দেখেছি। পরিসংখ্যান.মোড (অ্যারে) একাধিক মোডের সাথে একটি ত্রুটি ফেরত পাঠায়, তবে অন্য পদ্ধতিগুলির কোনওটিই তা করে না।

— ম্যাথউইজুরড

Answer 6

সম্প্রদায়ের উত্তরটি প্রসারিত করা যা তালিকা খালি থাকলে কার্যকর হবে না, এখানে মোডের জন্য কোডিং কোড রয়েছে:

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

Answer 7

আপনি যদি ক্ষুদ্রতম, বৃহত্তম বা সমস্ত মোডে আগ্রহী হন:

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 8

মোডটি সন্ধান করতে আমি এই সহজ কাজটি লিখেছি।

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

Comments

2 টি আইটেমের একই নম্বর থাকলে এই পদ্ধতিটি ব্যর্থ হবে। ঘটনা।

— অক্ষয়নাগপাল

Answer 9

সংক্ষিপ্ত, তবে কিছুটা কুরুচিপূর্ণ:

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

একটি অভিধান ব্যবহার করে, কিছুটা কম কুরুচিপূর্ণ:

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 10

কিছুটা দীর্ঘ, তবে একাধিক মোড থাকতে পারে এবং বেশিরভাগ গণনা বা ডেটাটাইপগুলির মিশ্রণে স্ট্রিং পেতে পারে।

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 11

একটি সংখ্যা হওয়ার জন্য mode, এটি অবশ্যই তালিকার অন্তত অন্য একটি সংখ্যার চেয়ে বেশি সংখ্যক বার সংঘটিত হতে হবে এবং তালিকার এটি কেবলমাত্র সংখ্যারই হবে না । সুতরাং, আমি @ ম্যাথউইজুরদের উত্তরটি ( differenceপদ্ধতিটি ব্যবহার করার জন্য ) নিম্নরূপে রিফ্যাক্ট করেছি :

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

এই পরীক্ষাগুলি সফলভাবে পাস:

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

Answer 12

শুধু না কেন

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

এটিতে এটি হওয়া উচিত কয়েকটি ত্রুটিযুক্ত চেক নেই, তবে এটি কোনও ফাংশন আমদানি না করে মোডটি সন্ধান করবে এবং সমস্ত মান একবারে উপস্থিত হলে কোনও বার্তা মুদ্রণ করবে। এটি একই সর্বাধিক গণনা ভাগ করে নেওয়ার একাধিক আইটেম সনাক্ত করবে, যদিও আপনি এটি চেয়েছিলেন তা পরিষ্কার ছিল না।

Comments

সুতরাং আমি যা করার চেষ্টা করছি তা হ'ল একই গণনা প্রদর্শনকারী একাধিক আইটেম সনাক্ত করা এবং তারপরে একই গণনা সহ সমস্ত আইটেম প্রদর্শন করা

— ব্লিওলান্টার

আপনি কি আসলে নিজে চেষ্টা করেছেন? আমার কোড থেকে বাড়ানো এটিকে একই গণনা সহ সমস্ত আইটেম মুদ্রণ করতে মোটামুটি সোজা।

— lxop

Answer 13

এই ফাংশনটি ফাংশনের মোড বা মোডগুলি প্রদান করে না কতই না, সেইসাথে মোডের ফ্রিকোয়েন্সি বা ডেটাসেটের মোডগুলি। যদি কোনও মোড না থাকে (যেমন, সমস্ত আইটেম কেবল একবারই ঘটে), ফাংশনটি একটি ত্রুটির স্ট্রিং দেয়। এটি উপরের এ_নাগপালের ফাংশনের অনুরূপ তবে আমার বিনীত মতে এটি আরও সম্পূর্ণ এবং আমি মনে করি যে কোনও পাইথন নভিসিদের (যেমন আপনার সত্যিকারের মতো) এই প্রশ্নটি বোঝার জন্য এটি বোঝা আরও সহজ।

 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

Comments

আমি এটি কেবল বলেছি কারণ আপনি বলেছেন "ফাংশনটি একটি ত্রুটির স্ট্রিং প্রদান করে।" যে রেখাটি পড়েছে সেটিকে return 'There is no mode for this data set. All values occur only once.'ত্রুটি বার্তায় পরিণত করা যেতে পারে tracebackcondition যদি শর্ত থাকে: ইনডেন্টের সাথে পরবর্তী লাইন ভ্যালুএরর ('এই ডেটা সেট করার জন্য কোনও মোড নেই All সমস্ত মান শুধুমাত্র একবার ঘটে' ') এখানে বিভিন্ন ধরণের একটি তালিকা রয়েছে ত্রুটি আপনি উত্থাপন করতে পারেন।

Answer 14

এটি সমস্ত মোড ফিরে আসবে:

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 15

সাধারণ কোড যা কোনও আমদানি ছাড়াই তালিকার মোডটি সন্ধান করে:

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)

একাধিক মোডের ক্ষেত্রে এটি ন্যূনতম নোডটি ফিরিয়ে আনবে।

Answer 16

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

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 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 19

আপনি যদি ক্লাসরুমের জন্য দরকারী এবং কেবল উপলব্ধি দ্বারা তালিকাগুলি এবং অভিধান ব্যবহার করে একটি স্পষ্ট পদ্ধতি চান তবে আপনি এটি করতে পারেন:

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 20

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

Comments

আপনার উত্তরটি মন্তব্য বা আরও বিশদ সহকারে ব্যাখ্যা করতে হবে

— মাইকেল

Answer 21

এখানে আপনি কীভাবে কোনও তালিকার গড়, মধ্যমা এবং মোড খুঁজে পাবেন:

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

Answer 22

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

Answer 23

যারা ন্যূনতম মোডের সন্ধান করছেন তাদের উদাহরণস্বরূপ: দ্বি-মডেল বিতরণের ক্ষেত্রে, নমপি ব্যবহার করে।

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

Answer 24

মোড একটি ডাটা সেটের / হয় সদস্য (গুলি) যে ঘটতে (গুলি) সবচেয়ে ঘন ঘন সেটে। যদি এমন দুটি সদস্য থাকে যা প্রায়শই একই সংখ্যার বারের সাথে উপস্থিত হয়, তবে ডেটাতে দুটি মোড রয়েছে। একে বলা হয় বিমোডাল ।

যদি 2 টিরও বেশি মোড থাকে তবে ডেটাটিকে মাল্টিমোডাল বলা হবে । যদি ডেটা সেটের সমস্ত সদস্য একই সংখ্যক বার উপস্থিত হয়, তবে ডেটা সেটের কোনও মোড নেই ।

নিম্নলিখিত ফাংশন প্রদত্ত তথ্যের তালিকাতে মোড (গুলি) সন্ধান modes()করতে কাজ করতে পারে :

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

আউটপুট:

# 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']

আমরা যদি এই প্যাকেজগুলি থেকে আমদানি করতে numpyবা pandasকোনও ফাংশন কল করতে না চাই , তবে এই একই আউটপুটটি পেতে modes()ফাংশনটি এইভাবে লেখা যেতে পারে:

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