Python - ce qui est vos conventions de déclarer vos attributs dans une classe?

Question

En Python, je peux déclarer les attributs dans toute la classe. Par exemple:

class Foo:
def __init__(self):
    self.a = 0

def foo(self):
    self.b = 0

Il est difficile de récupérer tous les attributs de ma classe quand j'ai une grande classe avec beaucoup d'attributs.

Est-il préférable d'avoir le code suivant (a) ou le prochain code suivant (b):

a) Ici, il est difficile de localiser tous les attributs:

class Foo:
    def __init__(self):
        foo_1()
        foo_2()

    def foo_1(self):
        self.a = 0
        self.b = 0

    def foo_2(self):
        self.c = 0

b) Ici, il est facile de localiser tous les attributs mais est-ce beau?

class Foo:
    def __init__(self):
        (self.a, self.b) = foo_1()
        self.c = foo_2()

    def foo_1(self):
        a = 0
        b = 0
        return (a, b)

    def foo_2(self):
        c = 0
        return c

En un mot, ce qui est vos conventions de déclarer vos attributs dans une classe?

EDIT:

Bien sûr, il est un exemple simple et il n'y a pas besoin d'améliorer mon code ici. Imaginez une classe complexe avec beaucoup de « petites méthodes » (diviser mon code, afin d'améliorer la lisibilité) appelés dans _ _ initialisation ().

Answer 1

Idéalement, votre constructeur ne devrait pas appeler des méthodes: un constructeur ne doit pas faire le travail réel .

Si le nombre d'attributs se développe hors de proportion, vous devez factoriser votre classe, par exemple en utilisant pour briser votre classe en plusieurs classes, respectant ainsi le principe seule responsabilité .

Answer 2

Quel est le problème avec ceci:

class Foo:
    def __init__(self):
        self.a = 0
        self.b = 1
        self.c = 2

Ou si a, b et c sont liés d'une certaine façon, vous pouvez les déclarer sur une seule ligne:

class Foo:
    def __init__(self):
        self.a, self.b, self.c = 0, 1, 2

Ou si a, b et c sont liés d'une certaine façon et vous les initialisant à la même valeur immuable, vous pouvez les déclarer en une seule mission:

class Foo:
    def __init__(self):
        self.a = self.b = self.c = 0

Answer 3

Tout d'abord, vous ne parlez pas d'attributs de classe, mais les attributs d'instance. Ma convention pour c'est-à, mais tous dans le constructeur, avec la valeur de None si elles sont initialisés dans une autre méthode. De cette façon, je peux toujours dire ce qu'il faut attendre. Il est un peu comme les déclarer, même si elle est pas obligatoire.

par exemple:.

class Foo(object):
    def __init__(self, a=None, b=None, c=None):
        self.a = a
        self.b = b
        self.c = c

Eh bien, je aime aussi faire inititializers comme arguments mot-clé, il rend plus flexible. Je peux facilement passer outre les valeurs par défaut de cette façon aussi.

Answer 4

  

En Python, je peux déclarer les attributs   toute la classe.

Correct.

  

Il est difficile de récupérer tous   attributs dans ma classe quand j'ai   grande classe avec beaucoup d'attributs.

Non. dir(object) ou obj.__dict__ sont là utiles. Et d'ailleurs, pourquoi voudriez-vous récupérer tous les attributs?

  

Ici, il est difficile de localiser tous les   attributs

Un bon éditeur / IDE peut vous aider à trouver la définition. J'utilise WingIDE pour cela, il est assez bon.

  

Ici, il est facile de localiser tous les   attributs mais est-ce beau?

Eh bien, ce code particulier, peut-être pas, mais il est assez fréquent de déclarer tous les attributs publics dans __init__ ou dans la classe (mais attention Jabberwock quand vous faites cela). De cette façon, vous savez qu'ils sont disponibles, ce qui est bon.