क्या यह __new__ में काम करने के लिए एक 'मूल पाप' है? यदि हां, तो सिंगलेट्स के लिए एक बार इनिट को कैसे संभालना सबसे अच्छा है?

Question

मेरे पास एक कक्षा है जिसमें मानक पायथन सिंगलटन फॉर्म है जिसका उपयोग मैं करता हूं। यह एक सिंगल वैल्यू भी करता है, लेकिन प्रत्येक इंस्टेंस में इसे इटिट करने के बजाए, जब मैं सिंगलटन हैंडलिंग करता हूं तो इसे __new__() में लगाता हूं। क्या यह करने के लिए यह पाइथोनिक तरीका है? यदि नहीं, तो मैं और कैसे कर सकता हूं?

class Foo(object): 
    _inst = None 
    def __new__(cls, val): 
     if Foo._inst is None: 
      Foo._inst = super(Foo, self).__new__(cls) 
      Foo._inst.val = val 
     return Foo._inst 

यह स्पष्ट रूप से सरलीकृत रूप है। मैंने तक प्रतीक्षा करने के लिए Foo._inst को एक सिंगलटन के लिए एक बार चलने के लिए सेट करने के लिए उपयोग किया है, लेकिन यह एक बहुप्रचारित स्थिति में सिंक्रनाइज़ेशन त्रुटियों के लिए परिपक्व लगता है। ऐसी परिस्थितियों के लिए जहां मौजूदा मान में कोई भी मान नहीं है जो __init__() फिर से चलाया जाता है, __init__() में init डालने में कोई हानि नहीं है, सिवाय इसके कि आप कोड चला रहे हैं जो प्रभावी रूप से कुछ भी नहीं करता है जब आपको आवश्यकता नहीं होती है, लेकिन अक्सर भ्रष्ट राज्य मूल्य होते हैं जिन्हें मैं ओवरराइट नहीं करना चाहता हूं। मुझे पता है कि सिंगलेट भी बुराई हैं, लेकिन कुछ बार, वे सबसे अच्छे समाधान हैं (जैसे विशेष उपयोग प्रकारों को परिभाषित करना, मैं is के साथ जांच करने में सक्षम होना चाहता हूं)।

ऐसा लगता है कि मैं सबसे अच्छा समाधान कर सकता हूं, लेकिन मुझे __new__() में उदाहरण मानों को गंदे शुरू करना लगता है। क्या किसी के पास इस तरीके को बेहतर तरीके से संभालने के बारे में विचार है?

Answer 1

पहले प्रश्न का उत्तर देने के लिए: सिंगलटन का उपयोग पायथन में अक्सर नहीं किया जाता है क्योंकि वास्तव में इसकी आवश्यकता नहीं होती है।

दूसरा जवाब देने के लिए: आपको लगता है कि आप वास्तव में उन्हें जरूरत है, थोड़ा क्लीनर, समान पैटर्न "बोर्ग" जो कभी कभी प्रयोग किया जाता है कहा जाता है, देखें: the Borg design pattern तुम सिर्फ उदाहरण हैं और डॉन के बीच कुछ विशेषताओं को साझा करने की जरूरत है 'टी पूर्ण विकसित सिंगलटन (जो एक बार instantiated जा सकता है) की जरूरत है तो आप बस वर्ग तो जैसे विशेषताओं का उपयोग कर सकते हैं:

class Foo(object): 
    val = ... 

    def __init__(self): 
     ... 

तो सभी उदाहरणों "वैल" विशेषता का एक ही मूल्य को साझा करेंगे।

Answer 2

सिंगलेट बनाने के लिए कोई बेहतर तरीका नहीं है। यदि आप इसके लिए जा रहे हैं (और तीन मूल्यवान तर्क एकमात्र उदाहरण के बारे में है, तो मैं सोच सकता हूं कि यह कहां समझता है), तो आप इसे वैसे ही कर सकते हैं।

Answer 3

आप हमेशा सिंगलेट के बजाय वैश्विक चर का उपयोग कर सकते हैं। तीन अलग-अलग उदाहरणों के साथ एक वर्ग के लिए उदाहरण:

class _Ternary(object): 
    """Internal class. Don't instantiate!""" 
    def __init__(self, value): 
     self.value = value 

ternary_0 = _Ternary(0) 
ternary_1 = _Ternary(1) 
ternary_2 = _Ternary(2) 

def ternary(value): 
    """Factory function to request a "ternary" instance.""" 
    return {0: ternary_0, 1: ternary_1: 2: ternary_2}[value] 

यह सीधी-सपाट है और एकमात्र के दर्द से बचने होगा।