दिलचस्प पोस्ट
कैस्परजेएस / फेंटमोज एस एच पी एस पृष्ठ लोड नहीं करता है jQuery के सरणी इनपुट तत्व को गतिशील रूप से बनाया गया है किसी पूर्ववर्ती फ़ंक्शन का उपयोग किए बिना किसी भी स्ट्रिंग का रिवर्स छपाई? सी ++: अस्थायी तर्कों का जीवन काल? जावा प्रतिबिंब: घोषणा आदेश में फ़ील्ड और तरीके प्राप्त करना टीटीएसटी फ़ाइल को लिखना और इसे वापस पढ़ना? अनाम स्ट्रैक्ट्स / यूनियनों के साथ सी कोड कैसे संकलित करें? क्यों file_get_contents () का उपयोग करते समय मुझे 500 त्रुटि मिल रही है, लेकिन ब्राउज़र में काम करता है? R के लिए RMySQL पैकेज जोड़ना विफल रहता है (Windows पर)? PostgreSQL नामकरण सम्मेलनों स्टोरीबोर्ड में कस्टम सेल रो ऊंचाई सेटिंग प्रतिसाद नहीं दे रहा है कैसे एक हैशमैप में संग्रहीत विधि को कॉल करें? (जावा) ब्राउज़र-आधारित एप्लिकेशन में जेडब्ल्यूटी को कैसे बचाया जाता है और इसे कैसे इस्तेमाल किया जाए जावा: ऑटोबॉक्सिंग और कास्टिंग के बीच अंतर क्या है? दो गतिविधियों के बीच बिटमैप पासिंग

डुप्लिकेट कॉलम और पंक्तियाँ एक NumPy 2D सरणी से निकालना

मैं लंबे अक्षरों के जोड़ों को संग्रहीत करने के लिए 2 डी आकार सरणी का उपयोग कर रहा हूं + अक्षांश एक बिंदु पर, मुझे इनमें से दो 2 डी सरणियों को मिला दिया जाना है, और फिर किसी भी डुप्लिकेट प्रविष्टि को हटा दें। मैं एक समारोह के लिए खोज कर रहा था जैसे numpy.unique, लेकिन मैं कोई भाग्य था किसी भी कार्यान्वयन पर मैं सोच रहा था बहुत "unoptimizied" उदाहरण के लिए, मैं सरणी को ट्यूपल्स की सूची में परिवर्तित करने की कोशिश कर रहा हूं, सेट के साथ डुप्लिकेट को निकाल रहा हूं, और फिर एक सरणी में फिर से परिवर्तित करना चाहता हूं:

coordskeys = np.array(list(set([tuple(x) for x in coordskeys]))) 

क्या कोई मौजूदा समाधान है, इसलिए मैं पहिया को फिर से नहीं बदलता हूं?

इसे स्पष्ट करने के लिए, मैं देख रहा / रही हूं:

 >>> a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) >>> unique_rows(a) array([[1, 1], [2, 3],[5, 4]]) 

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

Solutions Collecting From Web of "डुप्लिकेट कॉलम और पंक्तियाँ एक NumPy 2D सरणी से निकालना"

यहां एक विचार है, यह थोड़ा सा काम करेगा, लेकिन बहुत तेज हो सकता है मैं आपको 1d मामले दूँगा और आपको यह पता चलेगा कि इसे 2d तक कैसे बढ़ाया जाए। निम्न फ़ंक्शन 1 डी सरणी के अनन्य तत्व ढूंढता है:

 import numpy as np def unique(a): a = np.sort(a) b = np.diff(a) b = np.r_[1, b] return a[b != 0] 

अब इसे 2 डी तक विस्तार करने के लिए आपको दो चीजों को बदलना होगा। आपको यह पता करने की ज़रूरत होगी कि आप खुद को कैसे सॉर्ट करें, इस प्रकार की महत्वपूर्ण बात यह होगी कि दो समान प्रविष्टियां एक-दूसरे के बगल में समाप्त होंगी दूसरा, आपको कुछ करना होगा (b != 0).all(axis) क्योंकि आप संपूर्ण पंक्ति / स्तंभ की तुलना करना चाहते हैं मुझे बताएं कि क्या आपको शुरू करने के लिए पर्याप्त है।

अद्यतन: doug के साथ कुछ मदद के साथ, मुझे लगता है कि यह 2 डी मामले के लिए काम करना चाहिए।

 import numpy as np def unique(a): order = np.lexsort(aT) a = a[order] diff = np.diff(a, axis=0) ui = np.ones(len(a), 'bool') ui[1:] = (diff != 0).any(axis=1) return a[ui] 

यह काम कर जाना चाहिए:

 def unique_rows(a): a = np.ascontiguousarray(a) unique_a = np.unique(a.view([('', a.dtype)]*a.shape[1])) return unique_a.view(a.dtype).reshape((unique_a.shape[0], a.shape[1])) 

उदाहरण:

 >>> a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) >>> unique_rows(a) array([[1, 1], [2, 3], [5, 4]]) 

मेरी विधि एक 2d सरणी को 1d जटिल सरणी में बदलकर है, जहां असली भाग 1 कॉलम है, काल्पनिक भाग दूसरा कॉलम है। फिर np.unique का उपयोग करें हालांकि यह केवल 2 कॉलम के साथ काम करेगा

 import numpy as np def unique2d(a): x, y = aT b = x + y*1.0j idx = np.unique(b,return_index=True)[1] return a[idx] 

उदाहरण –

 a = np.array([[1, 1], [2, 3], [1, 1], [5, 4], [2, 3]]) unique2d(a) array([[1, 1], [2, 3], [5, 4]]) 
 >>> import numpy as NP >>> # create a 2D NumPy array with some duplicate rows >>> A array([[1, 1, 1, 5, 7], [5, 4, 5, 4, 7], [7, 9, 4, 7, 8], [5, 4, 5, 4, 7], [1, 1, 1, 5, 7], [5, 4, 5, 4, 7], [7, 9, 4, 7, 8], [5, 4, 5, 4, 7], [7, 9, 4, 7, 8]]) >>> # first, sort the 2D NumPy array row-wise so dups will be contiguous >>> # and rows are preserved >>> a, b, c, d, e = AT # create the keys for to pass to lexsort >>> ndx = NP.lexsort((a, b, c, d, e)) >>> ndx array([1, 3, 5, 7, 0, 4, 2, 6, 8]) >>> A = A[ndx,] >>> # now diff by row >>> A1 = NP.diff(A, axis=0) >>> A1 array([[0, 0, 0, 0, 0], [4, 3, 3, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 1, 0, 0], [2, 5, 0, 2, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> # the index array holding the location of each duplicate row >>> ndx = NP.any(A1, axis=1) >>> ndx array([False, True, False, True, True, True, False, False], dtype=bool) >>> # retrieve the duplicate rows: >>> A[1:,:][ndx,] array([[7, 9, 4, 7, 8], [1, 1, 1, 5, 7], [5, 4, 5, 4, 7], [7, 9, 4, 7, 8]]) 

Numpy_indexed पैकेज (अस्वीकरण: मैं इसकी लेखक हूँ) उपयोगकर्ता 545424 द्वारा एक अच्छा और परीक्षणित इंटरफ़ेस में पोस्ट किया गया समाधान, साथ ही कई संबंधित विशेषताएं:

 import numpy_indexed as npi npi.unique(coordskeys) 

चूंकि आप numpy.unique का उल्लेख करते हैं, आप मूल आदेश को बनाए रखने की परवाह नहीं करते, सही है? सेट में परिवर्तित, जो डुप्लिकेट को निकालता है, और फिर सूची में वापस अक्सर मुहावरे का उपयोग किया जाता है:

 >>> x = [(1, 1), (2, 3), (1, 1), (5, 4), (2, 3)] >>> y = list(set(x)) >>> y [(5, 4), (2, 3), (1, 1)] >>>