दिलचस्प पोस्ट
मैं एक रिपॉजिटरी के लिए जीआईटी के क्रेडेंशियल सहायक को कैसे अक्षम करूं? सफल पीईपी स्थापना के बाद आयात करें सी # में किसी अन्य अनुप्रयोग की खिड़की स्थिति कैसे प्राप्त करें और सेट करें आर में पढ़ने के लिए एक विशाल (3.5 जीबी) सीएसवी फ़ाइल ट्रिम कर रहा है NSFileManager (जेलब्रेक) के लिए IOS पर रूट अनुमतियां प्राप्त करना एंड्रॉइड नेविगेशन ड्रॉवर का उपयोग करके टुकड़ों को कैसे बदलना है ऐप स्टोर (iTunes) में अपने ऐप को कैसे जोड़ सकता हूं? Android पर नोडजेएस चलाने के लिए व्यवहार्य विकल्प (अगस्त 2017) इकाई फ़्रेमवर्क के साथ अहस्ताक्षरित int / long types का उपयोग कैसे करें? java.io.FileWriter में फ्लश एक SWF को एक WebView में लोड करें सी # मुझे एक अपरिवर्तनीय शब्दकोश देने का एक तरीका है? जावास्क्रिप्ट वादा नहीं सभी तर्क (क्यू का उपयोग कर) गतिशील RequireJS में आवश्यक है, "मॉड्यूल नाम अभी तक संदर्भ के लिए लोड नहीं किया गया है" त्रुटि? रेगेक्स: प्रश्न चिह्न और बृहदान्त्र

एक सूची का मोड ढूँढना

आइटमों की सूची को देखते हुए, याद रखें कि सूची का मोड वह आइटम होता है जो सबसे अधिक बार होता है।

मैं जानना चाहूंगा कि किसी फ़ंक्शन को कैसे बनाया जाए जो किसी सूची का मोड पा सकता है, लेकिन वह सूची प्रदर्शित करता है यदि सूची में कोई मोड नहीं है (उदाहरण के लिए, सूची में सभी आइटम केवल एक बार दिखाई देते हैं) मैं किसी फ़ंक्शन को आयात किए बिना इस फ़ंक्शन को बनाना चाहता हूं। मैं खरोंच से अपना खुद का कार्य करने की कोशिश कर रहा हूं

Solutions Collecting From Web of "एक सूची का मोड ढूँढना"

आप संकुल पैकेज में दिए गए Counter उपयोग कर सकते हैं जिसमें 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 

नोट: काउंटर अजगर 2.7 में नया है और पहले के संस्करणों में उपलब्ध नहीं है।

आप max फ़ंक्शन और एक कुंजी का उपयोग कर सकते हैं 'कुंजी' और लैम्ब्डा अभिव्यक्ति का उपयोग करके अजगर अधिकतम फ़ंक्शन पर एक नज़र डालें।

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

पायथन 3.4 में विधि 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' 

कुछ आँकड़े सॉफ़्टवेयर, जैसे कि SciPy और MATLAB , से पत्ते लेते हुए, ये सबसे छोटी सबसे आम मान लौटते हैं, इसलिए यदि दो मान समान रूप से समान होते हैं, तो इनमें से सबसे छोटी लौटे जाते हैं उम्मीद है कि एक उदाहरण में मदद मिलेगी:

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

क्या कोई कारण है कि आप इस सम्मेलन का पालन नहीं कर सकते हैं?

पायथन में एक सूची के मोड को खोजने के लिए कई सरल तरीके हैं जैसे कि:

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

मैंने मोड खोजने के लिए यह आसान फ़ंक्शन लिखा।

 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 

लघु, लेकिन किसी तरह बदसूरत:

 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 

यह फ़ंक्शन किसी फ़ंक्शन के मोड या मोड को लौटाता है चाहे कितने, साथ ही डेटासेट में मोड या मोड की आवृत्ति। अगर कोई विधा नहीं है (यानी सभी आइटम केवल एक बार होते हैं), फ़ंक्शन त्रुटि स्ट्रिंग देता है। यह ऊपर ए_एनजीपाल के कार्य के समान है, परन्तु मेरी विनम्र राय में, और अधिक पूर्ण है, और मुझे लगता है कि यह किसी भी पायथन नौसिखियों (जैसे कि तुम्हारा सचमुच) के लिए समझने में आसान है, समझने के लिए इस प्रश्न को पढ़ रहा है।

  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 

थोड़ा और लंबा है, लेकिन एक से अधिक मोड हो सकते हैं और अधिक संख्याओं या आंकड़ों के मिश्रण के साथ स्ट्रिंग प्राप्त कर सकते हैं।

 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 

क्यों न सिर्फ

 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 

इसमें कुछ त्रुटि जांच नहीं होनी चाहिए, लेकिन यह किसी भी फ़ंक्शन को आयात किए बिना मोड को मिलेगा और सभी मान केवल एक बार प्रदर्शित होने पर संदेश प्रिंट करेगा। यह एक ही अधिकतम संख्या को साझा करने वाले कई आइटम का भी पता लगाएगा, हालांकि यह स्पष्ट नहीं था कि अगर आप चाहते थे कि

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

यहां एक साधारण कार्य है जो एक सूची में होने वाला पहला मोड मिलता है। यह सूची तत्वों की कुंजी और घटनाओं की संख्या के साथ एक शब्दकोश बनाता है और फिर मोड प्राप्त करने के लिए निर्देश मूल्यों को पढ़ता है।

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

यदि आप सबसे छोटी, सबसे बड़ी या सभी तरीकों में रुचि रखते हैं:

 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 

यह सभी मोड वापस करेगा:

 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 

यदि आप एक स्पष्ट दृष्टिकोण चाहते हैं, कक्षा के लिए उपयोगी और केवल सूचियों और शब्दकोशों का उपयोग करके समझ से, आप ऐसा कर सकते हैं:

 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 appearence = {a:my_list.count(a) for a in unique_dist} # Calculate max number of appearences max_app = max(appearence.values()) # Return the elements of the dictionary that appear that # of times return {k: v for k, v in appearence.items() if v == max_app}