দক্ষতার সাথে নামার ক্রমে একটি নমপি অ্যারে বাছাই করা?

Question

আমি অবাক হয়েছি যে এই নির্দিষ্ট প্রশ্ন এর আগে জিজ্ঞাসা করা হয়নি, তবে আমি সত্যিই এটি এসও তে খুঁজে পাইনি বা এর ডকুমেন্টেশনেও পাইনি np.sort।

বলুন আমার কাছে একটি এলোমেলো নাম্পার অ্যারে হোল্ডিং পূর্ণসংখ্যা রয়েছে, যেমন:

> temp = np.random.randint(1,10, 10)    
> temp
array([2, 4, 7, 4, 2, 2, 7, 6, 4, 4])

যদি আমি এটি বাছাই করি, আমি ডিফল্টরূপে আরোহী ক্রম পাই:

> np.sort(temp)
array([2, 2, 2, 4, 4, 4, 4, 6, 7, 7])

তবে আমি চাই সমাধানটি সাজানো ক্রমে সাজানো হোক ।

এখন, আমি জানি আমি সবসময় করতে পারি:

reverse_order = np.sort(temp)[::-1]

কিন্তু এই শেষ বিবৃতি কার্যকর ? এটি কি আরোহণের ক্রমে একটি অনুলিপি তৈরি করে না, এবং তারপরে বিপরীত ক্রমে ফলাফল পেতে এই অনুলিপিটি বিপরীত করে? যদি সত্যই এটি হয়, একটি কার্যকর বিকল্প আছে? দেখে মনে হচ্ছে না np.sortবিপরীত ক্রমে জিনিসগুলি সাজানোর ক্রিয়াকলাপের তুলনাগুলির চিহ্নটি পরিবর্তনের জন্য পরামিতিগুলি গ্রহণ করে।

Answer 1

temp[::-1].sort()স্থানে অ্যারে বাছাই np.sort(temp)[::-1]করে , যেখানে একটি নতুন অ্যারে তৈরি করা হয়।

In [25]: temp = np.random.randint(1,10, 10)

In [26]: temp
Out[26]: array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4])

In [27]: id(temp)
Out[27]: 139962713524944

In [28]: temp[::-1].sort()

In [29]: temp
Out[29]: array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2])

In [30]: id(temp)
Out[30]: 139962713524944

Comments

ধন্যবাদ, তবে কীভাবে temp[::-1].sort()জানতে পারে যে এটির বিপরীত ক্রম অনুসারে বাছাই করতে হবে ?? আমি এটি যেভাবে পড়েছি তা হ'ল: মূল অ্যারেটি বিপরীত করুন এবং তারপরে এটি সাজান (ক্রমবর্ধমান ক্রমে)। আসল অ্যারেটি কেন বিপর্যয় করা হবে (এলোমেলো ক্রমে আসছে) এবং তারপরে ক্রমবর্ধমান ক্রম অনুসারে বাছাই করলে অ্যারেটিকে বিপরীত ক্রমে ফিরিয়ে দেওয়া হবে?

— আমেলিও ওয়াজকেজ-রেইনা

এই আচরণটি কী নথিভুক্ত, এটি বেশ অনিশ্চিত।

— ইবার

এটি দেখে মনে হচ্ছে এটি কাজ করে কারণ [::-1]কেবল অ্যারেটিকে পুনরায় সাজানোর পরিবর্তে অ্যারেটিকে পুনরাবৃত্তি করার জন্য কেবল নমিকে বলে। সুতরাং যখন স্থানের সাজানটি ঘটে তখন এটি প্রকৃতপক্ষে আরোহী ক্রম অনুসারে বাছাই করে এবং বিটগুলি চারপাশে সরিয়ে দেয় তবে পিছনের দিকের - পুনরাবৃত্তির অংশটি ছোঁয়াচে ফেলে দেয়।

— পেরিমোসোকর্ডিয়া

সঙ্গে a=np.array((...))বাগ্ধারা a[::-1]কিছু বিপরীত নয়, এটা শুধু একটা ব্যাপার নতুন দৃশ্য একই ডেটা, আরো নির্দিষ্টভাবে একটি মিরর দৃশ্য। পদ্ধতি a[::-1].sort() মিরর ইমেজ উপর পরিচালনা , implying যে যখন sortপ্যাচসমূহ বাম তার মিরর ইমেজ একটি ছোট আইটেম, বাস্তবে তা থেকে সরানোর হয় ডান প্রকৃত মেমরি ব্লক মধ্যে aঅ্যারে। মিরর করা ভিউ সাজানো ক্রম অনুসারে বাছাই করা হয়, আসল ডেটা সাজানো ক্রমে সাজানো হয়। কিছু আলাদা কয়েন এবং একটি আয়না দিয়ে ঘরে বসে নিজেই চেষ্টা করুন!

— gboffi

এই np.sort(temp,order='descending')ধরণের হ্যাকের চেয়ে বরং পাঠযোগ্য পরামিতি হিসাবে এটি যুক্ত করা উচিত

— নাথান

Answer 2

>>> a=np.array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4])

>>> np.sort(a)
array([2, 2, 4, 4, 4, 4, 5, 6, 7, 8])

>>> -np.sort(-a)
array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2])

Comments

সেরা উত্তর - সংক্ষিপ্ত এবং মিষ্টি, এবং axisকোনটি np.sortপ্রয়োগ করা হয়েছিল সে সম্পর্কে কোনও জ্ঞানের প্রয়োজন নেই।

— লুক ডেভিস

এটি সামনের পরিবর্তে অ্যারের পিছনে np.sort(temp)[::-1]রাখে nanতার চেয়ে এটি আলাদা । তা ভাল হোক বা খারাপ তা বিতর্কের

— বেন

Answer 3

সংক্ষিপ্ত অ্যারেগুলির জন্য আমি np.argsort()বাছাই করা নেতিবাচক অ্যারের সূচকগুলি সন্ধান করে ব্যবহার করার পরামর্শ দিচ্ছি , যা সাজানো অ্যারেটি উল্টানোর চেয়ে কিছুটা দ্রুত is

In [37]: temp = np.random.randint(1,10, 10)

In [38]: %timeit np.sort(temp)[::-1]
100000 loops, best of 3: 4.65 µs per loop

In [39]: %timeit temp[np.argsort(-temp)]
100000 loops, best of 3: 3.91 µs per loop

Comments

a[np.argsort(-a)]এই পৃষ্ঠায় অন্য যে কোনও ব্যক্তির পক্ষে সম্ভবত সেরা পন্থা। কোনও -1 পদক্ষেপের বিপরীতমুখী এবং ভাবার জন্য একটি কম বিয়োগ চিহ্ন।

— জারাড

Answer 4

দুর্ভাগ্যক্রমে যখন আপনার একটি জটিল অ্যারে থাকে, কেবল np.sort(temp)[::-1]সঠিকভাবে কাজ করে। এখানে উল্লিখিত অন্য দুটি পদ্ধতি কার্যকর নয়।

Comments

@ anishtain4: "জটিল অ্যারে" দ্বারা, আপনি কি জটিল সংখ্যার অ্যারে বোঝাতে চেয়েছিলেন? বা আপনি কি অন্য কিছু জটিলতার সাথে একটি অ্যারের বোঝাতে চেয়েছিলেন (যদি pls কী ধরণের জটিলতা নির্দিষ্ট করে)। উভয় ক্ষেত্রেই, আমি অনুভব করি যে অন্যান্য পদ্ধতি কীভাবে ব্যর্থ হতে পারে সে সম্পর্কে জানতে পেরে আপনি নিজের উত্তরে আরও কিছুটা ব্যাখ্যা করতে পারেন। ধন্যবাদ।

— ফাউন্টেনহেড

@ ফাউন্টেনহেড মানে জটিল সংখ্যার অ্যারে mean এটি একটি পুরানো প্রশ্ন যেহেতু আমি আমার পরীক্ষার কেসটি এর পরে আরও বিস্তারিতভাবে মনে করি না don't

— anishtain4

Answer 5

মাত্রা সহ সতর্কতা অবলম্বন করুন।

দিন

x  # initial numpy array
I = np.argsort(x) or I = x.argsort() 
y = np.sort(x)    or y = x.sort()
z  # reverse sorted array

সম্পূর্ণ বিপরীত

z = x[-I]
z = -np.sort(-x)
z = np.flip(y)

• flipপরিবর্তিত 1.15, পূর্ববর্তী সংস্করণ প্রয়োজন । সমাধান: ।1.14 axispip install --upgrade numpy

প্রথম মাত্রা বিপরীত

z = y[::-1]
z = np.flipud(y)
z = np.flip(y, axis=0)

দ্বিতীয় মাত্রা বিপরীত

z = y[::-1, :]
z = np.fliplr(y)
z = np.flip(y, axis=1)

পরীক্ষামূলক

100 × 10 × 10 অ্যারে 1000 বার পরীক্ষা করা হচ্ছে।

Method       | Time (ms)
-------------+----------
y[::-1]      | 0.126659  # only in first dimension
-np.sort(-x) | 0.133152
np.flip(y)   | 0.121711
x[-I]        | 4.611778

x.sort()     | 0.024961
x.argsort()  | 0.041830
np.flip(x)   | 0.002026

এটি মূলত পরিবর্তে পুনর্নির্মাণের কারণে argsort।

# Timing code
import time
import numpy as np


def timeit(fun, xs):
    t = time.time()
    for i in range(len(xs)):  # inline and map gave much worse results for x[-I], 5*t
        fun(xs[i])
    t = time.time() - t
    print(np.round(t,6))

I, N = 1000, (100, 10, 10)
xs = np.random.rand(I,*N)
timeit(lambda x: np.sort(x)[::-1], xs)
timeit(lambda x: -np.sort(-x), xs)
timeit(lambda x: np.flip(x.sort()), xs)
timeit(lambda x: x[-x.argsort()], xs)
timeit(lambda x: x.sort(), xs)
timeit(lambda x: x.argsort(), xs)
timeit(lambda x: np.flip(x), xs)

Answer 6

হ্যালো আমি একটি দ্বি মাত্রিক নিম্পের অ্যারে বাছাইয়ের জন্য একটি সমাধান অনুসন্ধান করছিলাম, এবং আমি কাজ করে এমন কোনও কিছুই খুঁজে পেলাম না, তবে আমি মনে করি যে কোনও একটি একই নৌকায় থাকাকালীন আমি আপলোড করছি এমন একটি সমাধানে আমি হোঁচট খেয়েছি।

x=np.sort(array)
y=np.fliplr(x)

np.sort বাছাই করুন যা আপনি যা চান তা নয়, তবে কমান্ড fliplr সারিগুলি বাম থেকে ডানে উল্টে দেয়! মনে হচ্ছে কাজ!

এটি আপনাকে সাহায্য করে আশা করি!

আমি অনুমান করি যে এটি উপরে -np.sort (-a) সম্পর্কে পরামর্শের অনুরূপ তবে এটি সর্বদা কার্যকর হয় না বলে মন্তব্য করে আমার পক্ষে এটি বন্ধ করে দেওয়া হয়েছিল। সম্ভবত আমার সমাধানটি সর্বদা কার্যকর হয় না তবে আমি এটি কয়েকটি অ্যারে দিয়ে পরীক্ষা করেছি এবং ঠিক আছে বলে মনে হচ্ছে।

Answer 7

আপনি প্রথমে অ্যারে বাছাই করতে পারেন (ডিফল্ট অনুসারে আরোহণ ) এবং তারপরে np.flip () প্রয়োগ করুন ( https://docs.scipy.org/doc/numpy/references/generated/numpy.flip.html )

এফওয়াইআই এটি ডেটটাইম অবজেক্টগুলির সাথেও কাজ করে।

উদাহরণ:

    x = np.array([2,3,1,0]) 
    x_sort_asc=np.sort(x) 
    print(x_sort_asc)

    >>> array([0, 1, 2, 3])

    x_sort_desc=np.flip(x_sort_asc) 
    print(x_sort_desc)

    >>> array([3,2,1,0])

Comments

যাদের অ্যারেতে এনএএন রয়েছে তাদের সাবধানতা অবলম্বন করুন, বিভিন্ন প্রস্তাবিত পদ্ধতিগুলি বিভিন্ন ফলাফল দেয়। উদাহরণস্বরূপ যদি x = np.array([2,3,np.nan,1,0]) তারপর np.flip(np.sort(x))পদ্ধতির ফলন হয় [ন্যান ৩. ২. ১.০], তবে -np.sort(-x)পদ্ধতির ফলস্বরূপ [৩.২. ১. 0. ন্যান]।

— উয়েউ মায়ার

Answer 8

এখানে একটি দ্রুত কৌশল

In[3]: import numpy as np
In[4]: temp = np.random.randint(1,10, 10)
In[5]: temp
Out[5]: array([5, 4, 2, 9, 2, 3, 4, 7, 5, 8])

In[6]: sorted = np.sort(temp)
In[7]: rsorted = list(reversed(sorted))
In[8]: sorted
Out[8]: array([2, 2, 3, 4, 4, 5, 5, 7, 8, 9])

In[9]: rsorted
Out[9]: [9, 8, 7, 5, 5, 4, 4, 3, 2, 2]

Answer 9

আমি এটি ব্যবহার করার পরামর্শ দিচ্ছি ...

np.arange(start_index, end_index, intervals)[::-1]

উদাহরণ স্বরূপ:

np.arange(10, 20, 0.5)
np.arange(10, 20, 0.5)[::-1]

তারপরে আপনার পুনরারম্ভ:

[ 19.5,  19. ,  18.5,  18. ,  17.5,  17. ,  16.5,  16. ,  15.5,
    15. ,  14.5,  14. ,  13.5,  13. ,  12.5,  12. ,  11.5,  11. ,
    10.5,  10. ]

Comments

এটি কীভাবে সমস্যার সমাধান করবে? প্রণালী দ্বারা - - আপনি মাত্র সম্পূর্ণরূপে সম্পর্কহীন, নতুন (সাজানো) অ্যারে যা তৈরি করছেন আরও কার্যকর ভাবে কাজ করা যেতে পারে: np.arange(20-0.5, 10-0.5, -0.5)। তবে এটি একটি ভিন্ন গল্প এবং আরও খারাপ পাঠযোগ্যতার কারণে, বিতর্কযোগ্য। একটি ইনপুট অ্যারে মোটেও বাছাই করা হয় না

— ড্যানিয়েল