किसी ऑब्जेक्ट के दूसरे प्रारंभिकरण पर, __init__ को __del__ से पहले क्यों कहा जाता है?

Question

निम्न उदाहरण कोड

class A: 
    def __init__(self, i): 
     self.i = i 
     print("Initializing object {}".format(self.i)) 

    def __del__(self): 
     print("Deleting object {}".format(self.i)) 

for i in [1, 2]: 
    a = A(i) 

वस्तु बनाना भीतर पाश आश्वस्त करने के लिए है कि इससे पहले कि नया एक वस्तु बनाया जा होगा एक की नाशक कहा जाएगा इरादा था पर विचार करें। लेकिन जाहिरा तौर पर निम्न होता है:

आरंभ किया जा रहा वस्तु 1

आरंभ किया जा रहा वस्तु 2

हटाया जा रहा वस्तु 1

हटाया जा रहा वस्तु 2

क्यों वस्तु 1 का नाशक है केवल नई वस्तु शुरू करने के बाद बुलाया गया है? क्या यह एक इरादा व्यवहार है? मुझे पता है कि लूप के लिए अजगर में कोई गुंजाइश नहीं है। उदाहरण के लिए, सी ++ में, 1 के विनाशक को निश्चित रूप से ऑब्जेक्ट 2 के लिए कन्स्ट्रक्टर के समक्ष कहा जाएगा (कम से कम यदि ऑब्जेक्ट लूप के भीतर घोषित किया गया हो)।

मेरे कार्यक्रम में मैं यह आश्वस्त करना चाहता हूं कि नया ऑब्जेक्ट बनाया गया है इससे पहले कि नया ऑब्जेक्ट बनाया गया हो। क्या लूप के अंत में a को हटाने से अलग कोई और संभावना है?

अग्रिम धन्यवाद।

Answer 1

दूसरे वस्तु का निर्माण नाम रिबाउंड से पहले होता है और पहली वस्तु का निपटारा किया जाता है।

1. पहला A तत्काल है।
2. a बाध्य है।
3. दूसरा A तत्काल है।
4. a रिबाउंड है, और पहले A का निपटारा किया गया है।
5. कार्यक्रम समाप्त होता है, और दूसरा A का निपटारा किया जाता है।

Answer 2

आप आजीवन निर्भरताओं की योजना बनाते समय कचरा कलेक्टर के कार्यान्वयन विवरण पर भरोसा नहीं कर सकते हैं। आपको इसे स्पष्ट रूप से एक या दूसरे तरीके से करने की ज़रूरत है।

प्रसंग प्रबंधकों वसंत मन में, उदाहरण के लिए:

from contextlib import contextmanager 

@contextmanager 
def deleting(obj): 
    try: 
     yield 
    finally: 
     del(obj) 

class A: 
    def __init__(self, i): 
     self.i = i 
     print("Initializing object {}".format(self.i)) 

    def __del__(self): 
     print("Deleting object {}".format(self.i)) 

for i in [1,2]: 
    with deleting(A(i)) as obj: 
     pass 

print 

for i in [1,2]: 
    a = A(i) 

यह निम्न उत्पादन का उत्पादन:

Initializing object 1 
Deleting object 1 
Initializing object 2 
Deleting object 2 

Initializing object 1 
Initializing object 2 
Deleting object 1 
Deleting object 2 

Answer 3

यह मानते हुए कि आप वस्तु चाहते हैं अपने अंतिम मूल्य के रूप में परिभाषित किया जा करने के लिए जब पाश बाहर निकलता है , अंत पाश के लिए की पर स्पष्ट रूप से वस्तु को नष्ट नहीं करते हैं, लूप के शुरुआत पर ऐसा करते हैं, इस तरह:

class A: 
    def __init__(self, i): 
     self.i = i 
     print("Initializing object {}".format(self.i)) 

    def __del__(self): 
     print("Deleting object {}".format(self.i)) 

for i in [1, 2, 3]: 
    a = None 
    a = A(i) 

कि प्रिंट:

Initializing object 1 
Deleting object 1 
Initializing object 2 
Deleting object 2 
Initializing object 3 
Deleting object 3 

(नोट: Ignatio कारण है कि यह जिस तरह से यह काम करता है काम करता है के बारे में सही है, लेकिन KennyTM भी सही है, यह है कि यह और अधिक स्पष्ट क्या हो रहा है आप बनाना चाहिए बनाने के लिए यह लूप के माध्यम से कम से कम तीन बार जाता है।)