दिलचस्प पोस्ट
क्या मैं अंतर्निहित पायथन प्रकारों में कस्टम विधियों / विशेषताओं को जोड़ सकता / सकती हूं? क्या बाश कमांड के लिए संभव है पिछले कमान के परिणाम से पहले? क्या पीडीओ रिवाइंड को रिवाइंड करना संभव है? ऐप अग्रभूमि में है, जबकि दिखाने के लिए स्थानीय सूचनाएं प्राप्त करना स्विफ्ट 3 मृत कोड खोजने के लिए आप उपकरण और तकनीकों का उपयोग क्यों करते हैं? मैं एक सरणी कैसे फेर सकते हैं? एंड्रॉइड – बूट पर सर्विस प्रारंभ करें एंड्रॉइड: डबल-टैप को कैसे पता लगा सकता है? पृष्ठ के जावास्क्रिप्ट के निष्पादन के बाद पृष्ठ का HTML आउटपुट सहेजें सप्ताहांत की अनदेखी की तारीखों के बीच दिनों की संख्या की गणना करें मैं ऐप पूल को कैसे क्रैश कर सकता हूं? मणि इवेंटमैचिन घातक त्रुटि: 'openssl / ssl.h' फ़ाइल नहीं मिली पर्यावरण चर जहां रजिस्ट्री में संग्रहीत हैं? जावा 7 में Regex-replace-with-function-evaluation के बराबर क्या है? रेल 3.1 और jquery-UI संपत्तियां

स्तंभ द्वारा NumPy में क्रमबद्ध सरणियाँ

मैं NumPy में n के स्तंभ से एक सरणी कैसे सॉर्ट कर सकता हूँ?

उदाहरण के लिए,

a = array([[1, 2, 3], [4, 5, 6], [0, 0, 1]]) 

मैं दूसरे कॉलम से पंक्तियों को सॉर्ट करना चाहता हूं, जैसे कि मैं वापस आती हूं:

 array([[0, 0, 1], [1, 2, 3], [4, 5, 6]]) 

Solutions Collecting From Web of "स्तंभ द्वारा NumPy में क्रमबद्ध सरणियाँ"

@स्टेस्ट वास्तव में ऐसा करने का सबसे शानदार तरीका है

"सही" रास्ते के लिए numpy.ndarray.sort का ऑर्डर कीवर्ड तर्क देखें

हालांकि, आपको खेतों (एक संरचित सरणी) के साथ एक सरणी के रूप में अपनी सरणी को देखने की आवश्यकता होगी।

"सही" रास्ता काफी बदसूरत है अगर आपने शुरू में अपनी सरणी को खेतों के साथ नहीं परिभाषित किया …

एक त्वरित उदाहरण के रूप में, इसे सॉर्ट करने के लिए और एक प्रति वापसी:

 In [1]: import numpy as np In [2]: a = np.array([[1,2,3],[4,5,6],[0,0,1]]) In [3]: np.sort(a.view('i8,i8,i8'), order=['f1'], axis=0).view(np.int) Out[3]: array([[0, 0, 1], [1, 2, 3], [4, 5, 6]]) 

इसे क्रमबद्ध करने के लिए:

 In [6]: a.view('i8,i8,i8').sort(order=['f1'], axis=0) #<-- returns None In [7]: a Out[7]: array([[0, 0, 1], [1, 2, 3], [4, 5, 6]]) 

@ स्टीव वास्तव में ऐसा करने का सबसे शानदार तरीका है, जहां तक ​​मुझे पता है …

इस पद्धति का एकमात्र फायदा यह है कि "ऑर्डर" तर्क फ़ील्ड की एक सूची है जो खोज को ऑर्डर करता है। उदाहरण के लिए, आप दूसरे कॉलम के अनुसार क्रमबद्ध कर सकते हैं, फिर तीसरा कॉलम, तब पहला कॉलम ऑर्डर = ['एफ 1', 'एफ 2', 'एफ 0'] प्रदान कर रहा है।

मुझे लगता है कि यह काम करता है: a[a[:,1].argsort()]

अजगर प्रलेखन विकी से , मुझे लगता है कि आप ऐसा कर सकते हैं:

 a = ([[1, 2, 3], [4, 5, 6], [0, 0, 1]]); a = sorted(a, key=lambda a_entry: a_entry[1]) print a 

आउटपुट है:

 [[[0, 0, 1], [1, 2, 3], [4, 5, 6]]] 

स्टीव Tjoa की विधि के अनुसार आप मर्जरेटेज जैसे एक स्थिर प्रकार का उपयोग करके और सूचकांकों को कम से कम महत्वपूर्ण से सबसे महत्वपूर्ण कॉलम तक क्रमबद्ध करके कई स्तंभों पर सॉर्ट कर सकते हैं:

 a = a[a[:,2].argsort()] # First sort doesn't need to be stable. a = a[a[:,1].argsort(kind='mergesort')] a = a[a[:,0].argsort(kind='mergesort')] 

इस तरह के स्तंभ 0, फिर 1, फिर 2 से

NumPy मेलिंग सूची से , यहां एक और समाधान है:

 >>> a array([[1, 2], [0, 0], [1, 0], [0, 2], [2, 1], [1, 0], [1, 0], [0, 0], [1, 0], [2, 2]]) >>> a[np.lexsort(np.fliplr(a).T)] array([[0, 0], [0, 0], [0, 2], [1, 0], [1, 0], [1, 0], [1, 0], [1, 2], [2, 1], [2, 2]]) 

अगर कोई अपने कार्यक्रमों के एक महत्वपूर्ण हिस्से पर छंटनी का उपयोग करना चाहता है तो यहां विभिन्न प्रस्तावों के लिए प्रदर्शन की तुलना है:

 import numpy as np table = np.random.rand(5000, 10) %timeit table.view('f8,f8,f8,f8,f8,f8,f8,f8,f8,f8').sort(order=['f9'], axis=0) 1000 loops, best of 3: 1.88 ms per loop %timeit table[table[:,9].argsort()] 10000 loops, best of 3: 180 µs per loop import pandas as pd df = pd.DataFrame(table) %timeit df.sort_values(9, ascending=True) 1000 loops, best of 3: 400 µs per loop 

इसलिए, ऐसा लगता है कि आर्गसोर्ट के साथ अनुक्रमण अभी तक सबसे तेज़ तरीका है …

मुझे भी ऐसी ही समस्या का समाधान करना पड़ा था।

मेरी समस्या:

मैं एक एसवीडी की गणना करना चाहता हूं और अपने ऊगमों को अवरोही क्रम में क्रमबद्ध करने की आवश्यकता है। लेकिन मैं eigenvalues ​​और eigenvectors के बीच मैपिंग रखना चाहते हैं मेरी प्राथमिक संख्याएं पहली पंक्ति में थीं और इसी कॉलम में इसके नीचे संबंधित एगेन्वेक्टर थे।

इसलिए मैं अवरोही क्रम में पहली पंक्ति से दो-आयामी सरणी स्तंभ-वार को हल करना चाहता हूं।

मेरा समाधान

 a = a[::, a[0,].argsort()[::-1]] 

यह कैसे काम करता है?

a[0,] केवल पहली पंक्ति है जिसे मैं सॉर्ट करना चाहता हूं

अब मैं इंडेक्स के ऑर्डर पाने के लिए आर्गसोर्ट का उपयोग करता हूं।

मैं [::-1] उपयोग करता हूं क्योंकि मुझे अवरोही क्रम की आवश्यकता है

अंत में मैं सही क्रम में कॉलमों के साथ एक दृश्य प्राप्त करने के लिए a[::, ...] का उपयोग a[::, ...] हूं।

थोड़ा और अधिक जटिल lexsort उदाहरण – 1 स्तंभ पर उतरते हैं, दूसरी ओर दूसरे पर चढ़ते हैं। lexsort साथ चालें lexsort हैं कि यह पंक्तियों पर (इसलिए .T ), और अंतिम को प्राथमिकता देता है

 In [120]: b=np.array([[1,2,1],[3,1,2],[1,1,3],[2,3,4],[3,2,5],[2,1,6]]) In [121]: b Out[121]: array([[1, 2, 1], [3, 1, 2], [1, 1, 3], [2, 3, 4], [3, 2, 5], [2, 1, 6]]) In [122]: b[np.lexsort(([1,-1]*b[:,[1,0]]).T)] Out[122]: array([[3, 1, 2], [3, 2, 5], [2, 1, 6], [2, 3, 4], [1, 1, 3], [1, 2, 1]])