पाइथन आयात करने वाले क्लास गुणों को स्थानीय नेमस्पेस

Question

में आयात करता है यदि मैं स्थानीय नामस्थान विधि के लिए क्लास गुणों को असाइन करने का आसान तरीका है तो मैं थोड़ी देर के लिए सोच रहा हूं। उदाहरण के लिए, dosomething विधि में, मैं स्पष्ट रूप से संदर्भ self.a और self.b को बनाने:

class test: 
    def __init__(self): 
     self.a = 10 
     self.b = 20 

    def dosomething(self): 
     a = self.a 
     b = self.b 
     return(a + b) 

लेकिन कभी कभी मैं चर (10 से अधिक) का एक बहुत है और यह भी लिखते हैं और को देखने के लिए गंदा हो जाता है - मैं गुच्छा होता है एक विधि की शुरुआत में var = self.var बयान के।

क्या यह और अधिक कॉम्पैक्ट तरीका करने का कोई तरीका है? (मैं अद्यतन करने जानते local() एक अच्छा विचार नहीं है)

संपादित करें: आदर्श रूप में, मैं क्या चाहते हैं:

def dosomething(self): 
    populate_local_namespace('a', 'b') 
    return(a + b) 

Answer 1

प्र इस अधिक कॉम्पैक्ट तरह से करने के लिए कोई रास्ता नहीं है (हालांकि मैं समझने के लिए तुम क्यों वर्ग विधि स्थानीय नाम स्थान के लिए जिम्मेदार बताते हैं नकल करने की जरूरत में असमर्थ हूँ)?

1. चर केवल पढ़ने के लिए कर रहे हैं, यह काफी pythonic कारक आउट करने के लिए एक बहु चर एक्सेसर तरीका होगा:

class Test: 

    def __init__(self): 
     self.a = 10 
     self.b = 20 
     self.c = 30 

    def _read_vars(self): 
     return self.a, self.b, self.c 

    def dosomething(self): 
     a, b, c = self._read_vars() 
     return a + b * c 

    def dosomethingelse(self): 
     a, b, c = self._read_vars() 
     return a - b * c 

तो चर केवल पढ़ने के लिए नहीं कर रहे हैं , self.inst_var = value के साथ रहना सर्वोत्तम है। पाइथन कोड लिखना सामान्य तरीका है और आम तौर पर अधिकांश लोग अपेक्षा करते हैं।

---

2. कभी-कभार आप लोगों को संक्षिप्त एक छोटी चर नाम के साथ self देखेंगे। उन्हें स्टोर करने के लिए है एक बहुत बड़ी संख्या उदाहरण चर को संभालने के लिए

def updatesomethings(s): 
    s.a, s.b, s.c = s.a + s.c, s.b - s.a, s.c * s.b 

---

3. एक और तरीका है: यह प्रयोग किया जाता है जब decluttering की पठनीयता लाभ को दबा एक गैर मानक चर नाम का उपयोग कर की पठनीयता लागत

class Test: 

    def __init__(self, a, b, c, d, e, f, g, h, i): 
     self._vars = [a, b, c, d, e, f, g, h, i] 

    def fancy_stuff(self): 
     a, b, c, d, e, f, g, h, i = self._vars 
     a += d * h - g 
     b -= e * f - c 
     g = a + b - i 
     self._vars[:] = a, b, c, d, e, f, g, h, i 

---

4. वहाँ मैं: पैकिंग में आसानी और खोल के लिए एक परिवर्तनशील कंटेनर में यह भी है एक शब्दकोश में गड़बड़ी दृष्टिकोण है कि काम करेगा, लेकिन यह एक कोड गंध है कि ज्यादातर Pythonistas से बच जाएंगे दिया गया है:

def updatesomethings(self): 
    a = 100 
    b = 200 
    c = 300 
    vars(self).update(locals()) 
    del self.self 

Answer 2

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

data = {} 
copy_to_local_variables = ["a", "b", "c", "d"] 
for var_name in copy_to_local_variables: 
    data[var_name] = getattr(self, var_name) 

Answer 3

मैं एक रास्ता मिल गया: अगर यह खतरनाक है

def dosomething(self): 
    for key in ['a', 'b']: 
     exec('{} = self.{}'.format(key, key)) 

    return(a + b) 

मैं नहीं जानता या नहीं। अगर कोई इस पर टिप्पणी कर सकता है तो अच्छा होगा।