উত্তর:
যদি আপনার তালিকায় সমস্ত অ-নেতিবাচক অন্তর অন্তর্ভুক্ত থাকে তবে আপনাকে numpy.bincounts একবার দেখে নেওয়া উচিত:
http://docs.scipy.org/doc/numpy/reference/generated/numpy.bincount.html
এবং তারপরে সম্ভবত এনপি.আরগম্যাক্স ব্যবহার করুন:
a = np.array([1,2,3,1,2,1,1,1,3,2,2,1])
counts = np.bincount(a)
print np.argmax(counts)আরও জটিল তালিকার জন্য (এতে সম্ভবত নেতিবাচক সংখ্যা বা অ-পূর্ণসংখ্যার মান রয়েছে), আপনি np.histogramএকইভাবে ব্যবহার করতে পারেন । বিকল্পভাবে, আপনি যদি অদ্ভুত ব্যবহার না করে অজগরটিতে কাজ করতে চান তবে collections.Counterএই ধরণের ডেটা পরিচালনা করার একটি ভাল উপায়।
from collections import Counter
a = [1,2,3,1,2,1,1,1,3,2,2,1]
b = Counter(a)
print b.most_common(1)scipy.stats.modeসাধারণ হলেও এর চেয়ে কমপক্ষে দ্রুততার একটি ক্রম ।
Counter(array).most_common(1)[0][0]
আপনি ব্যবহার করতে পারেন
(values,counts) = np.unique(a,return_counts=True)
ind=np.argmax(counts)
print values[ind] # prints the most frequent elementযদি কিছু উপাদান অন্য একটি হিসাবে ঘন ঘন হয়, এই কোডটি কেবলমাত্র প্রথম উপাদানটি ফেরত দেবে।
values[counts.argmax()]তবে প্রথম মানটি ফিরিয়ে দেবে। তাদের সব পেতে, আমরা ব্যবহার করতে পারি values[counts == counts.max()]।
>>> # small array
>>> a = [12,3,65,33,12,3,123,888000]
>>>
>>> import collections
>>> collections.Counter(a).most_common()[0][0]
3
>>> %timeit collections.Counter(a).most_common()[0][0]
100000 loops, best of 3: 11.3 µs per loop
>>>
>>> import numpy
>>> numpy.bincount(a).argmax()
3
>>> %timeit numpy.bincount(a).argmax()
100 loops, best of 3: 2.84 ms per loop
>>>
>>> import scipy.stats
>>> scipy.stats.mode(a)[0][0]
3.0
>>> %timeit scipy.stats.mode(a)[0][0]
10000 loops, best of 3: 172 µs per loop
>>>
>>> from collections import defaultdict
>>> def jjc(l):
... d = defaultdict(int)
... for i in a:
... d[i] += 1
... return sorted(d.iteritems(), key=lambda x: x[1], reverse=True)[0]
...
>>> jjc(a)[0]
3
>>> %timeit jjc(a)[0]
100000 loops, best of 3: 5.58 µs per loop
>>>
>>> max(map(lambda val: (a.count(val), val), set(a)))[1]
12
>>> %timeit max(map(lambda val: (a.count(val), val), set(a)))[1]
100000 loops, best of 3: 4.11 µs per loop
>>> সমস্যার মতো ছোট অ্যারেগুলির জন্য 'সেট' সহ সেরা 'হ'ল ।
@ ডেভিড স্যান্ডার্সের মতে, আপনি যদি অ্যারের আকারটি ১০০,০০০ উপাদানের মতো বাড়িয়ে দেন তবে "সর্বাধিক ডাব্লু / সেট" অ্যালগরিদম শেষ পর্যন্ত সবচেয়ে খারাপ হিসাবে শেষ হয় যেখানে "নম্পি বিঙ্কাউন্ট" পদ্ধতিটি সেরা।
a = (np.random.rand(100000) * 1000).round().astype('int'); a_list = list(a)) এ বাড়িয়ে দেন তবে আপনার "সর্বাধিক ডাব্লু / সেট" অ্যালগরিদমটি এখন পর্যন্ত সবচেয়ে খারাপ হিসাবে শেষ হবে যখন "নম্পি বিনপাউন্ট" পদ্ধতিটি সেরা। আমি ফলাফলটি স্ক্রাইংয়ের ব্যয়কে মার্শালিং এড়াতে a_listনেটিভ পাইথন কোড এবং aনম্পি কোডের জন্য ব্যবহার করে এই পরীক্ষাটি চালিয়েছি।
এছাড়াও আপনি যদি কোনও মডিউল লোড না করে সর্বাধিক ঘন মান (ধনাত্মক বা নেতিবাচক) পেতে চান তবে নীচের কোডটি ব্যবহার করতে পারেন:
lVals = [1,2,3,1,2,1,1,1,3,2,2,1]
print max(map(lambda val: (lVals.count(val), val), set(lVals)))max(set(lVals), key=lVals.count), যা lValsপ্রায় O (n ^ 2) (ও (এন) কে অনন্য বলে ধরে নিয়ে প্রতিটি অনন্য উপাদানের জন্য একটি O (n) গণনা করে ) উপাদান)। ব্যবহার collections.Counter(lVals).most_common(1)[0][0], যেমন মান লাইব্রেরি থেকে JoshAdel দ্বারা প্রস্তাবিত শুধুমাত্র O (ঢ) হয়।
যদিও উপরের উত্তরগুলির বেশিরভাগটি দরকারী, যদি আপনার ক্ষেত্রে: ১) অ-ধনাত্মক-পূর্ণসংখ্যার মানগুলি সমর্থন করা প্রয়োজন (যেমন ফ্লোটস বা নেতিবাচক পূর্ণসংখ্যা ;-)) এবং ২) পাইথন ২.7 এ নেই (যা সংগ্রহ.সূত্র) প্রয়োজন), এবং 3) আপনার কোডে স্কিপি (বা এমনকি ছদ্মবেশী) এর নির্ভরতা যুক্ত না করা পছন্দ করে, তবে ও (নলগন) (অর্থাত্ দক্ষ) হ'ল বিশুদ্ধ পাইথন ২.6 সমাধানটি কেবল এটি:
from collections import defaultdict
a = [1,2,3,1,2,1,1,1,3,2,2,1]
d = defaultdict(int)
for i in a:
d[i] += 1
most_frequent = sorted(d.iteritems(), key=lambda x: x[1], reverse=True)[0]এই পদ্ধতিটি প্রসারণ করে ডেটা মোডটি অনুসন্ধানের জন্য প্রয়োগ করা হয়েছে যেখানে বিতরণের কেন্দ্র থেকে মানটি কতটা দূরে রয়েছে তা দেখতে আপনার প্রকৃত অ্যারের সূচকের প্রয়োজন হতে পারে।
(_, idx, counts) = np.unique(a, return_index=True, return_counts=True)
index = idx[np.argmax(counts)]
mode = a[index]লেন (np.argmax (গণনা))> 1 এ মোডটি বাতিল করতে ভুলবেন না
পাইথন 3 এ নিম্নলিখিতগুলির কাজ করা উচিত:
max(set(a), key=lambda x: a.count(x))শুরু করে Python 3.4, স্ট্যান্ডার্ড লাইব্রেরিতে statistics.modeএকক সর্বাধিক প্রচলিত ডেটা পয়েন্ট ফেরত ফাংশন অন্তর্ভুক্ত ।
from statistics import mode
mode([1, 2, 3, 1, 2, 1, 1, 1, 3, 2, 2, 1])
# 1যদি একই ফ্রিকোয়েন্সি সহ একাধিক মোড থাকে statistics.modeতবে প্রথমটির মুখোমুখি ফিরে আসে।
শুরু করার পরে Python 3.8, statistics.multimodeফাংশনটি সবচেয়ে বেশি ঘন ঘন ঘটে যাওয়া মানগুলির একটি তালিকা ফিরে আসে যাতে তারা প্রথমে উপস্থিত হয়েছিল:
from statistics import multimode
multimode([1, 2, 3, 1, 2])
# [1, 2]এখানে একটি সাধারণ সমাধান যা নিখুঁতভাবে নির্লজ্জ ব্যবহার করে মান নির্বিশেষে অক্ষের সাথে প্রয়োগ করা যেতে পারে। আমি আরও খুঁজে পেয়েছি যে স্কিপি.স্ট্যাটস.মোডের তুলনায় এটি আরও দ্রুত if
import numpy
def mode(ndarray, axis=0):
# Check inputs
ndarray = numpy.asarray(ndarray)
ndim = ndarray.ndim
if ndarray.size == 1:
return (ndarray[0], 1)
elif ndarray.size == 0:
raise Exception('Cannot compute mode on empty array')
try:
axis = range(ndarray.ndim)[axis]
except:
raise Exception('Axis "{}" incompatible with the {}-dimension array'.format(axis, ndim))
# If array is 1-D and numpy version is > 1.9 numpy.unique will suffice
if all([ndim == 1,
int(numpy.__version__.split('.')[0]) >= 1,
int(numpy.__version__.split('.')[1]) >= 9]):
modals, counts = numpy.unique(ndarray, return_counts=True)
index = numpy.argmax(counts)
return modals[index], counts[index]
# Sort array
sort = numpy.sort(ndarray, axis=axis)
# Create array to transpose along the axis and get padding shape
transpose = numpy.roll(numpy.arange(ndim)[::-1], axis)
shape = list(sort.shape)
shape[axis] = 1
# Create a boolean array along strides of unique values
strides = numpy.concatenate([numpy.zeros(shape=shape, dtype='bool'),
numpy.diff(sort, axis=axis) == 0,
numpy.zeros(shape=shape, dtype='bool')],
axis=axis).transpose(transpose).ravel()
# Count the stride lengths
counts = numpy.cumsum(strides)
counts[~strides] = numpy.concatenate([[0], numpy.diff(counts[~strides])])
counts[strides] = 0
# Get shape of padded counts and slice to return to the original shape
shape = numpy.array(sort.shape)
shape[axis] += 1
shape = shape[transpose]
slices = [slice(None)] * ndim
slices[axis] = slice(1, None)
# Reshape and compute final counts
counts = counts.reshape(shape).transpose(transpose)[slices] + 1
# Find maximum counts and return modals/counts
slices = [slice(None, i) for i in sort.shape]
del slices[axis]
index = numpy.ogrid[slices]
index.insert(axis, numpy.argmax(counts, axis=axis))
return sort[index], counts[index]আমি সম্প্রতি একটি প্রকল্প করছি এবং সংগ্রহগুলি ব্যবহার করছি oun কাউন্টার ((যা আমাকে নির্যাতন করেছে)।
সংগ্রহে থাকা কাউন্টারে আমার মতে খুব খারাপ অভিনয় রয়েছে। এটি কেবল একটি শ্রেণি মোড়ানোর আদেশ ()।
সবচেয়ে খারাপ বিষয়, আপনি যদি সিপ্রোফিলটিকে এর পদ্ধতিটি প্রোফাইল করতে ব্যবহার করেন তবে আপনার পুরো সময় নষ্ট করা অনেক '__ মিসিং__' এবং '__instancecheck__' স্টাফ দেখতে হবে।
এর Most_common () ব্যবহার করে সাবধান থাকুন, কারণ প্রতিবার এটি এমন ধরণের সাড়া দেয় যা এটি অত্যন্ত ধীর করে তোলে। এবং যদি আপনি সর্বাধিক_কমোন (এক্স) ব্যবহার করেন তবে এটি একটি হিপ বাছাই শুরু করবে, এটিও ধীর is
বিটিডব্লিউ, নম্পির বিন্দাউন্টেও একটি সমস্যা রয়েছে: আপনি যদি এনপি.বিঙ্কাউন্ট ([1,2,4000000]) ব্যবহার করেন তবে 4000000 উপাদান সহ আপনি একটি অ্যারে পাবেন।
np.bincount([1, 2, 3, 1, 2, 1, 1, 1, 3, 2, 2, 1]).argmax()