Korrekte Implementierung der Methodenvererbung während der Klassenkonstruktion

Question

Wie implementiere ich superähnliches Verhalten in Methoden, die aufgerufen werden, bevor eine Klasse vollständig erstellt wurde? Kann ich eine Reihe voneinander abhängiger Methoden wie diese implementieren?

from six import with_metaclass 

class Meta(type): 
    """a metaclass""" 

    def __init__(cls, name, bases, classdict): 
     cls.setup_class() 

    def setup_class(cls): 
     pass 


class A(with_metaclass(Meta, object)): 
    """a class""" 

    @classmethod 
    def instantiate(cls, name): 
     print("instantiating through '%s'" % name) 

    @classmethod 
    def setup_class(cls): 
     cls.instantiate('A') 


class B(A): 

    @classmethod 
    def setup_class(cls): 
     super(B, cls).setup_class() 
     cls.instantiate('B') 

class C(B) pass 

Offensichtlich kann dies allerdings nicht funktionieren, da B existiert nicht richtig, wenn setup_class genannt wird.

• related question

Answer 1

hatte ich diese Frage für eine ganze Weile und nicht wirklich einen Beitrag, die diesen Aspekt der metaclasses erklärt finden. In der Tat hatte ich es so lange, dass ich mit dieser Alternative und letztlich unnötig, solution kam. Technisch entspricht es genau der Art von Syntax, die ich wollte (was cool ist), aber am Ende ist es ein Hack. Da ich so lange Zeit damit verbracht habe, einen sinnlosen (aber immer noch coolen) Code zu schreiben, dachte ich mir, ich würde wenigstens versuchen, sicherzustellen, dass niemand in der gleichen Spur steckenbleibt.

Meine Verwirrung beruhte wirklich auf der Tatsache, dass ich mein Verständnis von Metaklassen und die Beziehung, die sie zu ihren Klassen haben, zu seiner logischen Schlussfolgerung nicht vollständig erweitert hatte. So wie es sich herausstellte, war der beste Weg, um die Art der Vererbung, die ich wollte, tatsächlich in einer Reihe von Metaklassen durchzuführen - aus den gleichen Gründen macht der Versuch, Attribute durch die Instanzen einer Klasse zu erben, keinen Sinn, macht nein Sinn zu machen, die Instanzen einer Metaklasse polymorphe:

from six import with_metaclass 

class Meta(type): 
    """a metaclass""" 

    def __init__(cls, name, bases, classdict): 
     print("Beginning '%s' setup" % name) 
     cls.setup_class() 
     print("Finished '%s' setup \n" % name) 

    def setup_class(cls): 
     cls.attribute = 0 
     cls.instantiate('Meta') 


class AMeta(Meta): 

    def setup_class(cls): 
     super(AMeta, cls).setup_class() 
     cls.instantiate('A') 

    def instantiate(cls, name): 
     print("instantiating through '%s'" % name) 

class A(with_metaclass(AMeta, object)): pass 


class BMeta(AMeta): 

    def setup_class(cls): 
     super(BMeta, cls).setup_class() 
     cls.instantiate('B') 

class B(with_metaclass(BMeta, object)): pass 


class C(B): pass 

Wenn jemand kümmert sich dies genauer zu untersuchen, ich bin sicher, dass jemand da draußen es schätzen würde.