Czy dobrą praktyką jest deklarowanie zmiennych instancji jako Brak w klasie w Pythonie?

Rozważ następującą klasę:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Moi współpracownicy określają to w następujący sposób:

class Person:
    name = None
    age = None

    def __init__(self, name, age):
        self.name = name
        self.age = age

Głównym tego powodem jest to, że ich wybrany edytor pokazuje właściwości autouzupełniania.

Osobiście nie lubię tego drugiego, ponieważ nie ma sensu, aby klasa miała ustawione właściwości None.

Który byłby lepszą praktyką i z jakich powodów?

Nazywam tę drugą złą praktyką zasadą „nie robi się tak, jak myślisz”.

Pozycję twojego współpracownika można przepisać w następujący sposób: „Zamierzam stworzyć grupę statycznych quasi-globalnych zmiennych statycznych, do których nigdy nie ma dostępu, ale które zajmują miejsce w tabelach przestrzeni nazw różnych klas ( __dict__), tylko po to, aby moje IDE zrobiło coś."

1. Spraw, aby Twój kod był łatwy do zrozumienia

Kod jest odczytywany znacznie częściej niż pisany. Uprość zadanie opiekuna kodu (w przyszłym roku może to być Ty).

Nie wiem o żadnych twardych regułach, ale wolę, aby jakikolwiek stan przyszłej instancji był jasno określony. Upaść z AttributeErrorjest wystarczająco poważna. Gorzej widać brak jasności cyklu życia atrybutu instancji. Ilość gimnastyki umysłowej wymaganej do przywrócenia możliwych sekwencji wywołań, które prowadzą do przypisania atrybutu, może łatwo stać się trywialna, co prowadzi do błędów.

Zwykle więc nie tylko definiuję wszystko w konstruktorze, ale również staram się ograniczyć liczbę zmiennych do zminimalizowania.

2. Nie mieszaj członków klasy i instancji

Wszystko, co zdefiniujesz bezpośrednio w classdeklaracji, należy do klasy i jest wspólne dla wszystkich instancji klasy. Np. Kiedy zdefiniujesz funkcję wewnątrz klasy, staje się ona metodą, która jest taka sama dla wszystkich instancji. To samo dotyczy członków danych. Jest to całkowicie odmienne od atrybutów instancji, w których zwykle się definiuje __init__.

Elementy danych na poziomie klasy są najbardziej przydatne jako stałe:

class Missile(object):
  MAX_SPEED = 100  # all missiles accelerate up to this speed
  ACCELERATION = 5  # rate of acceleration per game frame

  def move(self):
    self.speed += self.ACCELERATION
    if self.speed > self.MAX_SPEED:
      self.speed = self.MAX_SPEED
    # ...

Osobiście definiuję członków w metodzie __ init __ (). Nigdy nie myślałem o zdefiniowaniu ich w części klasowej. Ale to, co zawsze robię: inicjuję wszystkie elementy w metodzie __ init__, nawet te niepotrzebne w metodzie __ init__.

Przykład:

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age
        self._selected = None

   def setSelected(self, value):
        self._selected = value

Myślę, że ważne jest zdefiniowanie wszystkich członków w jednym miejscu. Dzięki temu kod jest bardziej czytelny. Niezależnie od tego, czy znajduje się w __ init __ (), czy na zewnątrz, nie jest tak ważne. Ważne jest jednak, aby zespół zastosował mniej więcej ten sam styl kodowania.

Och, i możesz zauważyć, że kiedykolwiek dodałem przedrostek „_” do zmiennych składowych.

To zła praktyka. Nie potrzebujesz tych wartości, one zaśmiecają kod i mogą powodować błędy.

Rozważać:

>>> class WithNone:
...   x = None
...   y = None
...   def __init__(self, x, y):
...     self.x = x
...     self.y = y
... 
>>> class InitOnly:
...   def __init__(self, x, y):
...     self.x = x
...     self.y = y
... 
>>> wn = WithNone(1,2)
>>> wn.x
1
>>> WithNone.x #Note that it returns none, no error
>>> io = InitOnly(1,2)
>>> InitOnly.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class InitOnly has no attribute 'x'

Pójdę z „trochę jak dokumentacja, a następnie” i stwierdzę, że jestNone to nieszkodliwe, o ile jest to zawsze , lub wąski zakres innych wartości, wszystkie niezmienne.

Cuchnie atawizmem i nadmiernym przywiązaniem do języków pisanych statycznie. I nie ma to nic wspólnego z kodem. Ale ma to niewielki cel, który pozostaje w dokumentacji.

Dokumentuje to, jakie są oczekiwane imiona, więc jeśli połączę kod z kimś, a jedno z nas będzie miało „nazwę użytkownika”, a druga nazwa użytkownika, będzie to dla ludzi wskazówka, że ​​rozeszliśmy się i nie używamy tych samych zmiennych.

Wymuszanie pełnej inicjalizacji jako zasady osiąga to samo w bardziej Pythoński sposób, ale jeśli jest w niej rzeczywisty kod __init__, zapewnia to wyraźniejsze miejsce do dokumentowania używanych zmiennych.

Oczywiście BIG problem polega na tym, że kusi ludzi do inicjowania wartościami innymi niż None, co może być złe:

class X:
    v = {}
x = X()
x.v[1] = 2

pozostawia globalny ślad i nie tworzy instancji dla x.

Ale jest to bardziej dziwactwo w Pythonie jako całości niż w tej praktyce i powinniśmy już być na tym punkcie paranoiczni.