उपclassing dict: dict.__ init __() को बुलाया जाना चाहिए?

Question

यहाँ, एक दोहरा सवाल यह है कि एक सैद्धांतिक भाग के साथ, और एक व्यावहारिक एक:

जब उपवर्गीकरण dict:

class ImageDB(dict): 
    def __init__(self, directory): 
     dict.__init__(self) # Necessary?? 
     ... 

चाहिए dict.__init__(self) कहा जा, बस एक "सुरक्षा" उपाय के रूप में (जैसे, मामले में कुछ गैर-मामूली कार्यान्वयन विवरण हैं जो महत्वपूर्ण हैं)? क्या dict.__init__() नामक पाइथन के भविष्य के संस्करण के साथ कोड ब्रेक है? मैं एक चीज़ या दूसरे को करने का मौलिक कारण ढूंढ रहा हूं, यहां (व्यावहारिक रूप से, dict.__init__() को सुरक्षित करना सुरक्षित है)।

मेरा अनुमान है कि जब ImageDB.__init__(self, directory) कहा जाता है, तो स्वयं पहले से ही एक नया खाली खाली वस्तु है, और इसलिए dict.__init__ पर कॉल करने की आवश्यकता नहीं है (मैं चाहता हूं कि पहले खाली होना खाली हो)। क्या ये सही है?

संपादित:

बुनियादी सवाल इसके बाद के संस्करण के पीछे और अधिक व्यावहारिक प्रश्न इस प्रकार है। मैं उप-वर्गीकरण के बारे में सोच रहा था क्योंकि मैं डीबी [...] वाक्यविन्यास का उपयोग अक्सर करता हूं (db.contents [...] हर समय करने के बजाय); ऑब्जेक्ट का एकमात्र डेटा (विशेषता) वास्तव में वास्तव में एक नियम है। मैं डेटाबेस में कुछ विधियों को जोड़ना चाहता हूं (जैसे get_image_by_name(), या get_image_by_code(), उदाहरण के लिए), और केवल __init__() ओवरराइड करें, क्योंकि छवि डेटाबेस को उस निर्देशिका द्वारा परिभाषित किया गया है जिसमें यह शामिल है।

सारांश में, (व्यावहारिक) प्रश्न हो सकता है: क्या कुछ है कि एक शब्दकोश की तरह बर्ताव करता है, सिवाय इसके कि इसके प्रारंभ अलग है के लिए एक अच्छा कार्यान्वयन है (यह केवल एक निर्देशिका का नाम लेता है), और यह अतिरिक्त है कि तरीकों?

कई उत्तरों में "कारखानों" का उल्लेख किया गया था। तो मुझे लगता है कि यह सब नीचे उबलता है: क्या आप 0 वर्गओवरराइड करते हैं और विधियों को जोड़ते हैं, या आप एक (फैक्ट्री) फ़ंक्शन लिखते हैं जो एक नियम देता है, जिसमें आप विधियां जोड़ते हैं? मैं पहला समाधान पसंद करने के इच्छुक हूं, क्योंकि फैक्ट्री फ़ंक्शन एक ऑब्जेक्ट देता है जिसका प्रकार इंगित नहीं करता है कि इसमें अतिरिक्त अर्थशास्त्र और विधियां हैं, लेकिन आपको क्या लगता है?

संपादित 2:

मैं हर किसी के जवाब से इकट्ठा कि यह एक अच्छा विचार dict उपवर्ग के लिए जब नया वर्ग "एक शब्दकोश नहीं है", और विशेष रूप से अपने __init__ विधि ही नहीं ले जा सकते हैं जब नहीं है तर्क के रूप में तर्क __init__ (जो ऊपर "व्यावहारिक प्रश्न" में मामला है)। दूसरे शब्दों में, यदि मैं सही ढंग से समझता हूं, तो सर्वसम्मति प्रतीत होती है: जब आप उप-वर्ग करते हैं, तो सभी विधियों (प्रारंभिक समेत) में बेस क्लास विधियों के समान हस्ताक्षर होना चाहिए। यह उदाहरण के लिए dict.__init__() की तरह subclass_instance.__init__() की गारंटी के लिए isinstance (subclass_instance, dict) को अनुमति देता है।

एक और व्यावहारिक प्रश्न तब पॉप अप करता है: इसकी कक्षा प्रारंभिक विधि को छोड़कर, एक वर्ग जो सिर्फ ताना की तरह है, को लागू किया जाना चाहिए? subclassing के बिना? इसके लिए कुछ परेशान बॉयलरप्लेट कोड की आवश्यकता होगी, नहीं?

Answer 1

आपको उप-वर्गीकरण होने पर शायद dict.__init__(self) पर कॉल करना चाहिए; वास्तव में, आप नहीं जानते कि वास्तव में क्या हो रहा है (क्योंकि यह एक बिल्टिन है), और यह संस्करणों और कार्यान्वयन में भिन्न हो सकता है। इसे कॉल न करने के परिणामस्वरूप अनुचित व्यवहार हो सकता है, क्योंकि आप नहीं जानते कि कहां अपने आंतरिक डेटा संरचनाओं को पकड़ रहा है।

वैसे, आपने हमें यह नहीं बताया कि आप करना चाहते हैं; यदि आप एक कक्षा (मैपिंग) व्यवहार के साथ एक कक्षा चाहते हैं, और आपको वास्तव में एक निर्देश की आवश्यकता नहीं है (उदाहरण के लिए आपके सॉफ़्टवेयर में कहीं भी isinstance(x, dict) कोई कोड नहीं है, जैसा कि यह होना चाहिए), तो संभवतः आप UserDict.UserDict या UserDict.DictMixin का उपयोग करने से बेहतर हो सकते हैं यदि आप पाइथन < = 2.5, या collections.MutableMapping पर हैं यदि आप अजगर> = 2.6 पर हैं। वे आपकी कक्षा को एक उत्कृष्ट श्रद्धा व्यवहार के साथ प्रदान करेंगे।

संपादित करें: मैंने एक और टिप्पणी में पढ़ा है कि आप किसी भी विधि की विधि को ओवरराइड नहीं कर रहे हैं! फिर सबक्लासिंग में कोई बात नहीं है, ऐसा मत करो।

def createImageDb(directory): 
    d = {} 
    # do something to fill in the dict 
    return d 

संपादित करें 2: आप नए तरीकों को जोड़ने के लिए dict से उत्तराधिकारी होना चाहते हैं, लेकिन आपको किसी को ओवरराइड करने की आवश्यकता नहीं है। एक अच्छी पसंद से हो सकता है:

class MyContainer(dict): 
    def newmethod1(self, args): 
     pass 

    def newmethod2(self, args2): 
     pass 


def createImageDb(directory): 
    d = MyContainer() 
    # fill the container 
    return d 

वैसे: आप किन तरीकों को जोड़ रहे हैं? क्या आप वाकई एक अच्छा अमूर्त बना रहे हैं? हो सकता है कि आप बेहतर ढंग से एक वर्ग का उपयोग करें जो आपको आवश्यक विधियों को परिभाषित करता है और आंतरिक रूप से "सामान्य" नियम का उपयोग करता है।

फैक्टरी समारोह: http://en.wikipedia.org/wiki/Factory_method_pattern

यह बस एक समारोह के लिए एक उदाहरण के निर्माण सौंपने के बजाय अधिभावी/इसके निर्माताओं को बदलने का एक तरीका है।

Answer 2

PEP 372 संग्रह मॉड्यूल को आदेशित आदेश जोड़ने के साथ संबंधित है।

यह चेतावनी देता है कि "उप-वर्गीकरण dict एक गैर-तुच्छ कार्य है और कई कार्यान्वयन सभी विधियों को ठीक से ओवरराइड नहीं करते हैं जो अप्रत्याशित परिणामों का कारण बन सकते हैं।"

प्रस्तावित (और स्वीकार किए जाते हैं) patch python3.1 करने के लिए उपयोग करता है एक __init__ कि इस तरह दिखता है:

+class OrderedDict(dict, MutableMapping): 
+ def __init__(self, *args, **kwds): 
+  if len(args) > 1: 
+   raise TypeError('expected at most 1 arguments, got %d' % len(args)) 
+  if not hasattr(self, '_keys'): 
+   self._keys = [] 
+  self.update(*args, **kwds) 

इस आधार पर यह dict.__init__() तरह लग रहा है कहा जा की जरूरत नहीं है

। संपादित करें: यदि आप dict के किसी भी तरीके को ओवरराइड या विस्तारित नहीं कर रहे हैं, तो मैं एलन फ्रांज़ोनी से सहमत हूं: उप-वर्गीकरण के बजाए एक dict कारखाने का उपयोग करें:

def makeImageDB(*args,**kwargs): 
    d = {} 
    # modify d 
    return d 

Answer 3

आपको आम तौर पर बेस क्लास '__init__ पर कॉल करना चाहिए, तो यहां अपवाद क्यों करें?

या तो __init__ पर हावी नहीं है या आप __init__ कॉल आधार वर्ग __init__ ओवरराइड करने के लिए की जरूरत है, आप तर्क के बारे में चिंता है, तो बस * args, ** kwargs या कुछ भी नहीं अगर आप चाहते हैं खाली dict उदा पारित

class MyDict(dict): 
    def __init__(self, *args, **kwargs): 
     myparam = kwargs.pop('myparam', '') 
     dict.__init__(self, *args, **kwargs) 

हम क्या baseclass कर रहा है या नहीं कर रही नहीं मानना ​​चाहिए, यह गलत है नहीं आधार वर्ग कॉल करने के लिए __init__

Answer 4

जब dict उपवर्गीकरण अचार बनाने से सावधान रहें; उदाहरण के लिए 2.7, में __getnewargs__ की आवश्यकता है और पुराने संस्करणों में शायद __getstate__ __setstate__ की आवश्यकता है। (मुझे कोई जानकारी नहीं है की क्यों।)

class Dotdict(dict): 
    """ d.key == d["key"] """ 

    def __init__(self, *args, **kwargs): 
     dict.__init__(self, *args, **kwargs) 
     self.__dict__ = self 

    def __getnewargs__(self): # for cPickle.dump(d, file, protocol=-1) 
     return tuple(self)