उप-वर्गीकरण numpy ndarray समस्या

Question

मैं numpy ndarray subclass करना चाहता हूँ। हालांकि, मैं सरणी नहीं बदल सकता। क्यों self = ... सरणी नहीं बदलता है? धन्यवाद।

import numpy as np 

class Data(np.ndarray): 

    def __new__(cls, inputarr): 
     obj = np.asarray(inputarr).view(cls) 
     return obj 

    def remove_some(self, t): 
     test_cols, test_vals = zip(*t) 
     test_cols = self[list(test_cols)] 
     test_vals = np.array(test_vals, test_cols.dtype) 

     self = self[test_cols != test_vals] # Is this part correct? 

     print len(self) # correct result 

z = np.array([(1,2,3), (4,5,6), (7,8,9)], 
    dtype=[('a', int), ('b', int), ('c', int)]) 
d = Data(z) 
d.remove_some([('a',4)]) 

print len(d) # output the same size as original. Why? 

Answer 1

शायद बल्कि एक विधि की तुलना में इस एक समारोह बनाने के लिए,:

import numpy as np 

def remove_row(arr,col,val): 
    return arr[arr[col]!=val] 

z = np.array([(1,2,3), (4,5,6), (7,8,9)], 
    dtype=[('a', int), ('b', int), ('c', int)]) 

z=remove_row(z,'a',4) 
print(repr(z)) 

# array([(1, 2, 3), (7, 8, 9)], 
#  dtype=[('a', '<i4'), ('b', '<i4'), ('c', '<i4')]) 

---

या, यदि आप यह एक विधि के रूप चाहते हैं,

import numpy as np 

class Data(np.ndarray): 

    def __new__(cls, inputarr): 
     obj = np.asarray(inputarr).view(cls) 
     return obj 

    def remove_some(self, col, val): 
     return self[self[col] != val] 

z = np.array([(1,2,3), (4,5,6), (7,8,9)], 
    dtype=[('a', int), ('b', int), ('c', int)]) 
d = Data(z) 
d = d.remove_some('a', 4) 
print(d) 

मुख्य अंतर यह यहाँ है remove_someself को संशोधित करने का प्रयास नहीं करता है, यह केवल Data का एक नया उदाहरण देता है।

Answer 2

कारण आप परिणाम आप उम्मीद नहीं मिल रहे हैं क्योंकि आप कर रहे हैं पद्धति remove_some भीतर फिर से बताए self है। आप बस एक नया स्थानीय चर self बना रहे हैं। यदि आपके सरणी आकार को बदलने के लिए नहीं थे, तो आप बस स्वयं [:] = ... कर सकते हैं और आप संदर्भ को self पर रख सकते हैं और सभी ठीक होंगे, लेकिन आप self के आकार को बदलने की कोशिश कर रहे हैं। जिसका अर्थ है कि हमें कुछ नई मेमोरी फिर से आवंटित करने की आवश्यकता है और जब हम self देखेंगे तो हम कहां इंगित करते हैं।

मैं ऐसा करने के तरीके पता नहीं है। मैंने सोचा कि इसे __array_finalize__ या __array__ या __array_wrap__ द्वारा हासिल किया जा सकता है। लेकिन मैंने जो भी कोशिश की है वह कम हो रही है।

अब, इस बारे में जाने का एक और तरीका है जो ndarray उपखंड नहीं करता है।

Class Data(object): 
    def __init__(self, inarr): 
     self._array = np.array(inarr) 
    def remove_some(x): 
     self._array = self._array[x] 
    def __add__(self, other): 
     return np.add(self._array, other) 

ठीक है, आप चित्र प्राप्त: आप एक नया वर्ग है कि एक विशेषता एक ndarray है और उसके बाद इस तरह सभी सामान्य __add__, __mul__, आदि .. कुछ ओवरराइड कि रहता है बना सकते हैं। यह सभी ऑपरेटरों को ओवरराइड करने का दर्द है, लेकिन लंबे समय तक, मुझे लगता है कि अधिक लचीला लगता है।

आपको इसे सही करने के लिए this को पढ़ना होगा। __array_finalize__ जैसी विधियां हैं जिन्हें "क्लीनअप" करने का सही समय कहा जाना चाहिए।

Answer 3

मैंने ऐसा करने की कोशिश की, लेकिन यह वास्तव में subclass ndarray के लिए बहुत जटिल है।

यदि आपको केवल कुछ कार्यक्षमता जोड़नी है, तो मैं एक वर्ग बनाने का सुझाव दूंगा जो सरणी को विशेषता के रूप में संग्रहीत करता है।

class Data(object): 

    def __init__(self, array): 
     self.array = array 

    def remove_some(self, t): 
     //operate on self.array 
     pass 

d = Data(z) 
print(d.array)