Python importuje atrybuty klas do metody lokalnej przestrzeni nazw

Question

Zastanawiam się przez chwilę, czy istnieje łatwiejszy sposób przypisania atrybutów klas do metody lokalnej przestrzeni nazw. Na przykład, w dosomething metody, ja wyraźnie odwołują się do self.a i 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) 

Ale czasami mam wiele zmiennych (ponad 10) i robi się bałagan na rodzaj i patrzeć - Chciałbym mieć kilka instrukcji var = self.var na początku metody.

Czy istnieje sposób na bardziej kompaktowy sposób? (Wiem aktualizowania local() nie jest dobrym pomysłem)

Edycja: Najlepiej, co chcę jest:

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

Answer 1

Q. Czy istnieje jakiś sposób, aby to zrobić bardziej zwarty sposób?

1. Jeśli zmienne są tylko do odczytu, byłoby rozsądnie pythonowy czynnik out wielo-zmiennej metody dostępowej:

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 

Jeśli zmienne nie są tylko do odczytu , najlepiej trzymać się z self.inst_var = value. Jest to normalny sposób pisania kodu w Pythonie i zwykle jest to, czego większość ludzi się spodziewa.

---

2. Raz na jakiś czas można zobaczyć ludzi skracać self z krótszą nazwą zmiennej. Jest on stosowany, gdy korzyści czytelności decluttering przewyższają koszty czytelność przy użyciu niestandardowego nazwę zmiennej:

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

---

3. Innym sposobem obsłużyć bardzo dużą ilość zmiennej instancji jest je przechowywać zmienny w pojemniku na łatwość pakowania i rozpakowywania:

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. Istnieje ja s również słownik podejście manipulacja, że ​​będzie działać, ale ma zapach kodu, że większość Pythonistas by unikać:

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

Answer 2

można łatwo rozwiązać ten problem kompromis, poprzez przechowywanie zmiennych w słowniku.

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

(choć jestem w stanie zrozumieć, dlaczego trzeba skopiować atrybuty klasy z metodą lokalnej przestrzeni nazw)

Answer 3

znalazłem inny sposób:

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

    return(a + b) 

ja nie wiem, czy to jest niebezpieczne albo nie. Byłoby wspaniale, gdyby ktoś mógł to skomentować.