Python - Was sind Ihre Konventionen, um Ihre Attribute in einer Klasse zu erklären?

Question

In Python kann ich in der gesamten Klasse Attribute deklarieren. Zum Beispiel :

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

def foo(self):
    self.b = 0

Es ist schwierig, alle Attribute in meiner Klasse abzurufen, wenn ich eine große Klasse mit vielen Attributen habe.

Ist es besser, den folgenden Code (a) oder den nächsten folgenden Code (b) zu haben:

a) Hier ist es schwierig, alle Attribute zu lokalisieren:

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) Hier ist es einfach, alle Attribute zu lokalisieren, aber ist es schön?

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

Kurz gesagt, was sind Ihre Konventionen, um Ihre Attribute in einer Klasse zu erklären?

BEARBEITEN:

Natürlich ist es ein einfaches Beispiel und es ist nicht erforderlich, meinen Code hier zu verbessern. Stellen Sie sich eine komplexe Klasse mit vielen "kleinen Methoden" vor (um meinen Code zu teilen, die Lesbarkeit zu verbessern) in _drin_().

Answer 1

Im Idealfall sollte Ihr Konstruktor keine Methoden aufrufen: Ein Konstruktor sollte keine echte Arbeit leisten.

Wenn die Anzahl der Attribute unverhältnismäßig wächst, sollten Sie Ihre Klasse neu umrüsten, beispielsweise verwenden Sie Klasse extrahieren Um Ihre Klasse in mehrere Klassen zu unterbrechen und damit die zu respektieren Einzelverantwortungsprinzip.

Answer 2

Was ist los daran:

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

Oder wenn a, b und c Sind Sie in irgendeiner Weise verwandt, können Sie sie in einer einzigen Zeile deklarieren:

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

Oder wenn a, b und c sind in irgendeiner Weise verwandt und Sie initialisieren sie auf denselben unveränderlichen Wert, Sie können sie in einer einzigen Aufgabe deklarieren:

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

Answer 3

Zunächst sprechen Sie hier nicht über Klassenattribute, sondern über Instanzattribute. Meine Konvention dafür ist nur alle im Konstruktor mit dem Wert von None, wenn sie in einer anderen Methode initialisiert werden. Auf diese Weise kann ich immer erkennen, was mich erwartet. Es ist so, als würde man sie deklarieren, obwohl es nicht obligatorisch ist.

z.B:

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

Nun, ich mag es auch, Inititializer als Keyword -Argumente zu machen, es macht es flexibler. Ich kann die Standardeinstellungen auch auf diese Weise leicht überschreiben.

Answer 4

In Python kann ich in der gesamten Klasse Attribute deklarieren.

Richtig.

Es ist schwierig, alle Attribute in meiner Klasse abzurufen, wenn ich eine große Klasse mit vielen Attributen habe.

Nö. dir(object) oder obj.__dict__ sind dort hilfreich. Und außerdem warum sollten Sie alle Attribute abrufen wollen?

Hier ist es schwierig, alle Attribute zu finden

Ein guter Editor/eine gute IDE kann Ihnen helfen, die Definition zu finden. Ich benutze Wingide dafür, es ist ziemlich gut.

Hier ist es einfach, alle Attribute zu lokalisieren, aber ist es schön?

Nun, dieser bestimmte Code, vielleicht auch nicht, aber es ist ziemlich üblich, alle öffentlichen Attribute in zu deklarieren __init__ oder in der Klasse (aber pass auf die Jabberwock Wenn Sie das tun). Auf diese Weise wissen Sie, dass sie verfügbar sind, was gut ist.