Ausführen von Allgemeinen post-Initialisierung Aufgaben-in vererbten Klassen?

Die Initialisierung einer Gruppe von Klassen, die einen gemeinsamen Elternteil kann in drei Teile unterteilt werden:

  • Gemeinsame Initialisierung
  • Unterklasse-spezifische Initialisierung
  • Gemeinsamen post-Initialisierung

Derzeit die ersten beiden Teile aufgerufen werden, von der __init__ - Methode jedes untergeordneten Klasse, aber der Letzte post-initialization-Teil aufgerufen werden separat, zum Beispiel

class BaseClass:
    def __init__(self):
        print 'base __init__'
        self.common1()

    def common1(self):
        print 'common 1'

    def finalizeInitialization(self):
        print 'finalizeInitialization [common2]'


class Subclass1(BaseClass):
    def __init__(self):
        BaseClass.__init__(self)
        self.specific()

    def specific(self):
        print 'specific'


if __name__ == '__main__':
    s = Subclass1()  # Don't forget to finalize the initialization
    s.finalizeInitialization()  # now the object is fully initialized

Gibt es eine Möglichkeit, um nicht zu rufen finalizeInitialization()? Oder kann man den Anruf auf finalizeInitialization() in Subclass1's __init__ (wie in S. Lott Antwort). Das macht das Leben leichter, aber immer noch daran zu erinnern, um die komplette Initialisierung, dieses mal im inneren der "Konstruktor". So oder so gibt es keine Möglichkeit, zu erzwingen, full initialization, das ist, was ich Suche.

InformationsquelleAutor Boris Gorelik | 2009-04-27
  1. 10

    Version 1 - delegieren alles.

    class Subclass1(BaseClass):
    def __init__(self):
        super( Subclass1, self ).__init__()
        self.specific()
        super( Subclass1, self ).finalizeInitialization()

    Version 2 - Delegierter nur ein Schritt

    class BaseClass:
    def __init__(self):
        print 'base __init__'
        self.common1()
        self.specific()
        self.finalizeInitialization()

    def common1(self):
        print 'common 1'

    def finalizeInitialization(self):
        print 'finalizeInitialization [common2]'

    def specific( self ):
        # two choices:
        # if this is "abstract": raise an exception
        # if this is "concrete": pass
    • Ich nehme Variante 2. Danke
    InformationsquelleAutor S.Lott
  2. 12

    Template Method Design Pattern zur Rettung:

    class BaseClass:
    def __init__(self, specifics=None):
        print 'base __init__'
        self.common1()
        if specifics is not None:
            specifics()
        self.finalizeInitialization()

    def common1(self):
        print 'common 1'

    def finalizeInitialization(self):
        print 'finalizeInitialization [common2]'


class Subclass1(BaseClass):
    def __init__(self):
        BaseClass.__init__(self, self.specific)

    def specific(self):
        print 'specific'
    InformationsquelleAutor Alex Martelli
  3. 1

    Ähnlich S. Lott Ansatz, außer es gibt keine Möglichkeit (kurz überschreiben __init__) für die abgeleiteten Klassen zu überschreiben (oder auch anrufen), die gemeinsame Methoden:

    class BaseClass:
    def __init__(self):
        def common():
            print "common initialization..."

        def final():
            print "common finalization..."

        common()
        self.specific()
        final()

    def final_init(self):
        print "BaseClass.final_init"


class Subclass1(BaseClass):

    def specific(self):
        print "Subclass1.specific"

    Möchten Sie vielleicht bieten eine Standard-Implementierung von specific im BaseClass wenn es nicht in Ordnung ist, um eine AttributeError wenn Sie erstellen eine Instanz einer beliebigen Unterklasse, die nicht seine eigenen Umsetzung.

    InformationsquelleAutor Robert Rossney
  4. 0

    Was ist falsch mit dem Aufruf finalInitilazation von der Unterklasse init?

       class BaseClass:
        def __init__(self):
            print 'base __init__'
            self.common1()

        def common1(self):
            print 'common 1'

        def finalizeInitialization(self):
            print 'finalizeInitialization [common2]'


    class Subclass1(BaseClass):
        def __init__(self):
            BaseClass.__init__(self)
            self.specific()
            BaseClass.finalizeInitialization(self)

        def specific(self):
            print 'specific'


    if __name__ == '__main__':
        s = Subclass1() #Don't forget to finalize the initialization
        s.finalizeInitialization()  # now the object is fully initialized
    InformationsquelleAutor Eric Palakovich Carr
  5. 0

    Wenn Sie den Aufruf mehrerer Methoden in einer bestimmten Reihenfolge, um die es in der Regel bedeutet, dass das design hat Probleme mit zu beginnen (es ist undicht detail). Also ich würde versuchen zu arbeiten, dass Ende.

    Auf der anderen Seite, wenn die Menschen von den Klassen abgeleitet werden und ändern müssen, um die Initialisierung sollte man sich bewusst sein, die Auswirkungen - es ist nicht etwas, das Sie haben wollen in Ihre normale API. Alternativ könnten Sie in der defensive die Letzte Initialisierung und überprüfen, dass es wurde als in Methoden, die von ihm abhängen (zu nennen oder eine Ausnahme auslösen, wenn nicht).

    InformationsquelleAutor nikow
Schreibe einen Kommentar