È buona norma dichiarare variabili di istanza come nessuna in una classe in Python?

Considera la seguente classe:

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

I miei colleghi tendono a definirlo così:

class Person:
    name = None
    age = None

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

Il motivo principale di ciò è che il loro editor di scelta mostra le proprietà per il completamento automatico.

Personalmente, non mi piace quest'ultimo, perché non ha senso che una classe abbia queste proprietà impostate None.

Quale sarebbe la migliore pratica e per quali motivi?

Chiamo quest'ultima cattiva pratica sotto la regola "questo non fa ciò che pensi".

La posizione del tuo collega può essere riscritta come: "Ho intenzione di creare un gruppo di variabili quasi-globali statiche di classe a cui non si accede mai, ma che occupano spazio nelle tabelle dello spazio dei nomi delle varie classi ( __dict__), solo per far funzionare il mio IDE qualcosa."

1. Rendi il tuo codice facile da capire

Il codice viene letto molto più spesso di quanto scritto. Rendi il compito del manutentore del codice più semplice (potrebbe anche essere tu stesso l'anno prossimo).

Non sono a conoscenza di regole rigide, ma preferisco che qualsiasi stato di istanza futuro sia dichiarato chiaramente. Arrestare con un AttributeErrorè abbastanza brutto. Non vedere chiaramente il ciclo di vita di un attributo di istanza è peggio. La quantità di ginnastica mentale necessaria per ripristinare possibili sequenze di chiamate che portano all'attribuzione assegnata può facilmente diventare non banale, portando a errori.

Quindi di solito non solo definisco tutto nel costruttore, ma cerco anche di ridurre al minimo il numero di attributi mutabili.

2. Non mescolare membri a livello di classe e di istanza

Qualunque cosa tu definisca proprio all'interno della classdichiarazione appartiene alla classe ed è condivisa da tutte le istanze della classe. Ad esempio, quando si definisce una funzione all'interno di una classe, questa diventa un metodo uguale per tutte le istanze. Lo stesso vale per i membri dei dati. Questo è totalmente diverso dagli attributi di istanza che di solito definisci __init__.

I membri di dati a livello di classe sono più utili come costanti:

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
    # ...

Personalmente definisco i membri nel metodo __ init __ (). Non ho mai pensato di definirli nella parte di classe. Ma quello che faccio sempre: avvio tutti i membri nel metodo __ init__, anche quelli non necessari nel metodo __ init__.

Esempio:

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

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

Penso che sia importante definire tutti i membri in un unico posto. Rende il codice più leggibile. Che si tratti di __ init __ () o esterno, non è così importante. Ma è importante che un team si impegni più o meno allo stesso stile di codifica.

Oh, e potresti notare che ho mai aggiunto il prefisso "_" alle variabili membro.

Questa è una cattiva pratica. Non hai bisogno di quei valori, ingombrano il codice e possono causare errori.

Tener conto di:

>>> 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'

Andrò con "un po 'come i docstring, quindi" e lo dichiarerò innocuo, purché sia ​​sempreNone , o una gamma ristretta di altri valori, tutti immutabili.

Puzza di atavismo e di eccessivo attaccamento alle lingue tipicamente statiche. E non va bene come codice. Ma ha uno scopo secondario che rimane, nella documentazione.

Documenta quali sono i nomi previsti, quindi se combino il codice con qualcuno e uno di noi ha "username" e l'altro user_name, c'è un indizio per gli umani che ci siamo separati e non stiamo usando le stesse variabili.

Forzare l'inizializzazione completa come politica raggiunge la stessa cosa in un modo più Pythonic, ma se c'è un codice reale nel __init__, questo fornisce un posto più chiaro per documentare le variabili in uso.

Ovviamente il GRANDE problema qui è che tenta la gente a inizializzare con valori diversi da None, il che può essere negativo:

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

lascia una traccia globale e non crea un'istanza per x.

Ma è più una stranezza in Python nel suo insieme che in questa pratica, e dovremmo già essere paranoici al riguardo.