É uma boa prática declarar variáveis ​​de instância como None em uma classe em Python?

Considere a seguinte classe:

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

Meus colegas de trabalho tendem a defini-lo assim:

class Person:
    name = None
    age = None

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

A principal razão para isso é que o editor de sua escolha mostra as propriedades do preenchimento automático.

Pessoalmente, não gosto do último, porque não faz sentido que uma classe tenha essas propriedades definidas None.

Qual seria a melhor prática e por que razões?

Eu chamo a última prática ruim sob a regra "isso não faz o que você pensa que faz".

A posição do seu colega de trabalho pode ser reescrita como: "Vou criar um monte de variáveis ​​quase globais estáticas de classe que nunca são acessadas, mas que ocupam espaço nas tabelas de namespace das várias classes ( __dict__), apenas para fazer meu IDE funcionar alguma coisa."

1. Torne seu código fácil de entender

O código é lido com muito mais frequência do que escrito. Facilite a tarefa do seu mantenedor de código (também pode ser você mesmo no próximo ano).

Não conheço regras rígidas, mas prefiro que qualquer estado de instância futuro seja claramente declarado. Bater com um já AttributeErroré ruim o suficiente. Não ver claramente o ciclo de vida de um atributo de instância é pior. A quantidade de ginástica mental necessária para restaurar possíveis sequências de chamadas que levam ao atributo a ser atribuído pode facilmente se tornar não trivial, levando a erros.

Portanto, eu geralmente não apenas defino tudo no construtor, mas também me esforço para manter o número mínimo de atributos mutáveis.

2. Não misture membros de classe e instância

Qualquer coisa que você definir dentro da classdeclaração pertence à classe e é compartilhada por todas as instâncias da classe. Por exemplo, quando você define uma função dentro de uma classe, ela se torna um método igual para todas as instâncias. O mesmo se aplica aos membros de dados. Isso é totalmente diferente dos atributos de instância nos quais você geralmente define __init__.

Membros de dados em nível de classe são mais úteis como constantes:

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

Pessoalmente, defino os membros no método __ init __ (). Eu nunca pensei em defini-los na parte da aula. Mas o que eu sempre faço: inicio todos os membros no método __ init__, mesmo aqueles que não são necessários no método __ init__.

Exemplo:

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

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

Eu acho que é importante definir todos os membros em um só lugar. Isso torna o código mais legível. Se é dentro de __ init __ () ou fora, não é tão importante. Mas é importante que uma equipe se comprometa com mais ou menos o mesmo estilo de codificação.

Ah, e você pode notar que eu adiciono o prefixo "_" às variáveis ​​de membro.

Esta é uma má prática. Você não precisa desses valores, eles confundem o código e podem causar erros.

Considerar:

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

Eu irei com "um pouco como as doutrinas, então" e declararei isso inofensivo, desde que seja sempreNone , ou uma faixa estreita de outros valores, todos imutáveis.

Cheira a atavismo e apego excessivo a linguagens estaticamente tipadas. E isso não serve como código. Mas tem um objetivo menor que permanece na documentação.

Ele documenta quais são os nomes esperados; portanto, se eu combinar código com alguém e um de nós tiver 'username' e o outro user_name, haverá uma pista para os humanos de que nos separamos e não estamos usando as mesmas variáveis.

Forçar a inicialização completa como uma política consegue a mesma coisa de uma maneira mais pitônica, mas se houver um código real no __init__, isso fornece um local mais claro para documentar as variáveis ​​em uso.

Obviamente, o grande problema aqui é que ele tenta que as pessoas inicializem com valores diferentes de None, o que pode ser ruim:

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

deixa um rastreio global e não cria uma instância para x.

Mas isso é mais uma peculiaridade no Python como um todo do que nesta prática, e já deveríamos estar paranóicos com relação a isso.