मान लीजिए कि आपके पास एक वर्ग फू है :

class Foo(object): def __init__(self, x, y=0): self.x = x self.y = y 

जब आप इसकी वस्तु बनाते हैं तो क्या होता है?

 f = Foo(1, y=2) 

फू को इस कॉल के साथ किस विधि को पहले कहा जाता है? अधिकांश नवागंतुकों, और शायद कुछ अनुभवी pythonists, तुरंत जवाब देंगे: " __in____ विधि।" लेकिन यदि आप ऊपर के स्निपेट्स को करीब से देखते हैं, तो यह जल्द ही स्पष्ट हो जाएगा कि ऐसा उत्तर गलत है।

__init__ कोई परिणाम नहीं देता है, और फू (1, y = 2) , इसके विपरीत, वर्ग का एक उदाहरण देता है । इसके अलावा, __init__ पहले पैरामीटर के रूप में स्वयं को लेता है, जो फू (1, y = 2) को कॉल करते समय नहीं होता है। एक उदाहरण बनाना थोड़ा अधिक जटिल है, जिसके बारे में हम इस लेख में बात करेंगे।

ऑब्जेक्ट क्रिएशन प्रोसीजर

पायथन तात्कालिकता में कई चरण होते हैं। प्रत्येक चरण को समझना हमें भाषा को समग्र रूप से समझने के लिए थोड़ा निकट बनाता है। फू एक वर्ग है, लेकिन पायथन में, कक्षाएं भी वस्तुएं हैं! कक्षाएं, फ़ंक्शंस, विधियाँ और उदाहरण सभी ऑब्जेक्ट हैं, और जब भी आप उनके नाम के बाद कोष्ठक लगाते हैं , तो आप उनकी __call__ विधि कहते हैं। तो Foo (1, y = 2) Foo .__ कॉल __ (1, y = 2) के समतुल्य है। इसके अलावा, __call__ विधि फू वस्तु के वर्ग में घोषित की जाती है। फू वस्तु का वर्ग क्या है?

 >>> Foo.__class__ <class 'type'> 

तो Foo वर्ग एक प्रकार की कक्षा का एक उदाहरण है और अंतिम वर्ग के __call__ विधि को कॉल करना Foo वर्ग को देता है। अब देखते हैं कि टाइप क्लास का __call__ तरीका क्या है। नीचे C में CPython में और PyPy में इसके कार्यान्वयन हैं। यदि आप उन्हें देखकर थक जाते हैं, तो सरलीकृत संस्करण खोजने के लिए थोड़ा और स्क्रॉल करें:

CPython

स्रोत से लिंक करें

 static PyObject * type_call(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *obj; if (type->tp_new == NULL) { PyErr_Format(PyExc_TypeError, "cannot create '%.100s' instances", type->tp_name); return NULL; } obj = type->tp_new(type, args, kwds); obj = _Py_CheckFunctionResult((PyObject*)type, obj, NULL); if (obj == NULL) return NULL; /* Ugly exception: when the call was type(something), don't call tp_init on the result. */ if (type == &PyType_Type && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 && (kwds == NULL || (PyDict_Check(kwds) && PyDict_Size(kwds) == 0))) return obj; /* If the returned object is not an instance of type, it won't be initialized. */ if (!PyType_IsSubtype(Py_TYPE(obj), type)) return obj; type = Py_TYPE(obj); if (type->tp_init != NULL) { int res = type->tp_init(obj, args, kwds); if (res < 0) { assert(PyErr_Occurred()); Py_DECREF(obj); obj = NULL; } else { assert(!PyErr_Occurred()); } } return obj; } 

PyPy

स्रोत से लिंक करें

 def descr_call(self, space, __args__): promote(self) # invoke the __new__ of the type if not we_are_jitted(): # note that the annotator will figure out that self.w_new_function # can only be None if the newshortcut config option is not set w_newfunc = self.w_new_function else: # for the JIT it is better to take the slow path because normal lookup # is nicely optimized, but the self.w_new_function attribute is not # known to the JIT w_newfunc = None if w_newfunc is None: w_newtype, w_newdescr = self.lookup_where('__new__') if w_newdescr is None: # see test_crash_mro_without_object_1 raise oefmt(space.w_TypeError, "cannot create '%N' instances", self) w_newfunc = space.get(w_newdescr, self) if (space.config.objspace.std.newshortcut and not we_are_jitted() and isinstance(w_newtype, W_TypeObject)): self.w_new_function = w_newfunc w_newobject = space.call_obj_args(w_newfunc, self, __args__) call_init = space.isinstance_w(w_newobject, self) # maybe invoke the __init__ of the type if (call_init and not (space.is_w(self, space.w_type) and not __args__.keywords and len(__args__.arguments_w) == 1)): w_descr = space.lookup(w_newobject, '__init__') if w_descr is not None: # see test_crash_mro_without_object_2 w_result = space.get_and_call_args(w_descr, w_newobject, __args__) if not space.is_w(w_result, space.w_None): raise oefmt(space.w_TypeError, "__init__() should return None") return w_newobject 

यदि आप सभी प्रकार की त्रुटि जांच के बारे में भूल जाते हैं, तो ऊपर दिए गए कोड लगभग इसके बराबर हैं:

 def __call__(obj_type, *args, **kwargs): obj = obj_type.__new__(*args, **kwargs) if obj is not None and issubclass(obj, obj_type): obj.__init__(*args, **kwargs) return obj 

__new__ "खाली" ऑब्जेक्ट के लिए मेमोरी आवंटित करता है और इसे इनिशियलाइज़ करने के लिए __init__ को कॉल करता है।

संक्षेप में:

1. Foo (* args, ** kwargs) Foo .__ कॉल __ (* args, ** kwargs) के बराबर है।
2. चूंकि फू ऑब्जेक्ट टाइप क्लास का एक उदाहरण है, जिसमें फू .__ कॉल __ (* आर्ग्स, ** कवर्स) टाइप के बराबर है ।__ कॉल __ (फू, अर्ग्स, ** कवर्स) ।
3. प्रकार .__ कॉल __ (फू, * आर्ग्स, ** कवर्स) टाइप करते हैं ।__ नई __ (फू, * आर्ग्स, ** कवर्स) विधि, जो ओब्ज रिटर्न करती है।
4. obj को obj .__ init __ (* args, ** kwargs) कहकर आरम्भ किया जाता है।
5. पूरी प्रक्रिया का परिणाम एक प्रारंभिक ओब्जेक्ट है ।

अनुकूलन

अब हम __new__ की ओर अपना ध्यान आकर्षित करते हैं। यह विधि ऑब्जेक्ट के लिए मेमोरी आवंटित करती है और उसे वापस करती है। आप इस प्रक्रिया को कई अलग-अलग तरीकों से अनुकूलित करने के लिए स्वतंत्र हैं। यह ध्यान दिया जाना चाहिए कि यद्यपि __new__ एक स्थिर विधि है, आपको @staticmethod का उपयोग करके इसे घोषित करने की आवश्यकता नहीं है: दुभाषिया __new__ को एक विशेष मामले के रूप में मानता है।

__New__ ओवरराइड्स का एक सामान्य उदाहरण सिंगलटन बना रहा है:

 class Singleton(object): _instance = None def __new__(cls, *args, **kwargs): if cls._instance is None: cls._instance = super().__new__(cls, *args, **kwargs) return cls._instance 

तब:

 >>> s1 = Singleton() ... s2 = Singleton() ... s1 is s2 True 

ध्यान दें कि __in__ को हर बार सिंगलटन () कहा जाता है, इसलिए देखभाल की जानी चाहिए।

__New__ ओवरराइड का एक और उदाहरण बोर्ग पैटर्न ("बोर्ग") का कार्यान्वयन है:

 class Borg(object): _dict = None def __new__(cls, *args, **kwargs): obj = super().__new__(cls, *args, **kwargs) if cls._dict is None: cls._dict = obj.__dict__ else: obj.__dict__ = cls._dict return obj 

तब:

 >>> b1 = Borg() ... b2 = Borg() ... b1 is b2 False >>> b1.x = 8 ... b2.x 8 

ध्यान रखें कि हालांकि ऊपर दिए गए उदाहरण __new__ को ओवरराइड करने की संभावनाओं को प्रदर्शित करते हैं, इसका मतलब यह नहीं है कि इसका उपयोग किया जाना चाहिए:

__new__ दुरुपयोग की सबसे लगातार शिकार लोगों में से एक है। इस विधि को ओवरराइड करके क्या किया जा सकता है सबसे अधिक बार अन्य तरीकों से बेहतर हासिल किया जाता है। हालांकि, जब यह वास्तव में आवश्यक है, तो __new__ एक अत्यंत उपयोगी और शक्तिशाली उपकरण है।

- पाइथन में एरियन स्पैग, द वेल फॉरगॉटेन ओल्ड

एक शायद ही कभी पायथन में एक समस्या का सामना करता है, जहां सबसे अच्छा समाधान __new__ का उपयोग करना था । लेकिन जब आपके पास एक हथौड़ा होता है, तो हर समस्या नाखून की तरह दिखना शुरू हो जाती है, इसलिए हमेशा सबसे उपयुक्त एक का उपयोग करने के लिए सबसे शक्तिशाली उपकरण का उपयोग करना पसंद करें ।