La classe Python imbriquée doit accéder à la variable dans la classe englobante

J'ai vu quelques "solutions" pour cela, mais la solution à chaque fois semble être: "Ne pas utiliser les classes imbriquées, définir les classes à l'extérieur et ensuite de les utiliser normalement". Je n'aime pas cette réponse, car il ignore la principale raison que j'ai choisi classes imbriquées, qui est, de disposer d'un pool de constantes (associée à la classe de base accessible à tous les sous-instances de classes qui sont créés.

Voici un exemple de code:

class ParentClass:

    constant_pool = []
    children = []

    def __init__(self, stream):
        self.constant_pool = ConstantPool(stream)
        child_count = stream.read_ui16()
        for i in range(0, child_count):
            children.append(ChildClass(stream))

    class ChildClass:

        name = None

        def __init__(self, stream):
            idx = stream.read_ui16()
            self.name = constant_pool[idx]

Toutes les classes sont passées à un seul paramètre, qui est une coutume bitstream classe. Mon intention est d'avoir une solution qui ne nécessite pas de moi de lire le idx valeur pour ChildClass tout en restant dans la Myclass. Tous les enfants de la classe de flux de lecture devrait être fait dans la classe enfant.

Cet exemple est simplifiée. La constante de la piscine n'est pas la seule variable j'ai besoin d'disponibles pour toutes les sous-classes. Idx variable n'est pas la seule chose à lire à partir du lecteur de flux.

Est-ce encore possible en python? Il n'y a pas moyen d'avoir accès au parent?

source d'informationauteur Gerald Thibault

Malgré mon "peu condescendant" commentaire (fair-play à l'appeler comme ça!), il ya effectivement des façons d'obtenir ce que vous voulez: une autre voie d'héritage. Un couple:

Écrire un décorateur qui introspecte une classe juste après elle est déclarée, trouve les classes internes, et copie les attributs de l'extérieur de la classe.
Faire la même chose avec une métaclasse.

Voici le décorateur approche, puisque c'est le plus simple:

def matryoshka(cls):

    # get types of classes
    class classtypes:
        pass
    classtypes = (type, type(classtypes))

    # get names of all public names in outer class
    directory = [n for n in dir(cls) if not n.startswith("_")]

    # get names of all non-callable attributes of outer class
    attributes = [n for n in directory if not callable(getattr(cls, n))]

    # get names of all inner classes
    innerclasses = [n for n in directory if isinstance(getattr(cls, n), classtypes)]

    # copy attributes from outer to inner classes (don't overwrite)
    for c in innerclasses:
        c = getattr(cls, c)
        for a in attributes:
            if not hasattr(c, a):
                setattr(c, a, getattr(cls, a))

    return cls

Voici un simple exemple de son utilisation:

@matryoshka
class outer(object):

    answer = 42

    class inner(object):

        def __call__(self):
            print self.answer

outer.inner()()   # 42

Cependant, je ne peux pas aider mais penser à certaines idées suggérées dans d'autres réponses vous servir au mieux.

Vous n'avez pas besoin de deux classes ici. Voici l'exemple de code écrit dans un plus concise de la mode.

class ChildClass:
    def __init__(self, stream):
        idx = stream.read_ui16()
        self.name = self.constant_pool[idx]

def makeChildren(stream):
    ChildClass.constant_pool = ConstantPool(stream)
    return [ChildClass(stream) for i in range(stream.read_ui16())]

Bienvenue à Python. Les Classes sont mutables au moment de l'exécution. Profitez de.

Vous pouvez accéder à la classe parent par le biais de son nom:

class ChildClass:

    name = None

    def __init__(self, stream):
        idx = stream.read_ui16()
        self.name = ParentClass.constant_pool[idx]

Encore une fois, je ne suis pas sûr de comprendre ce que vous essayez d'atteindre.

1

Une autre alternative de conception à prendre en compte:

Quand vous vous trouvez en essayant d'utiliser les classes comme des espaces de noms, il pourrait faire plus de sens de mettre à l'intérieur des classes dans un module de leur propre et de faire ce qu'étaient les attributs de l'extérieur de la classe des variables globales. En d'autres termes, si vous n'avez jamais l'intention d'instancier votre ParentClasspuis il est simplement un être glorifié module.

Variables globales mauvaise réputation dans la plupart des langages de programmation, mais ils ne sont pas véritablement mondiale en Python, et bien encapsulé pour le module.

Bien, les ouvrages suivants (encore simplifié à partir de votre exemple). Notez que vous n'avez pas à "déclarer" membre des variables au niveau de la classe comme C++/C#/Java etc, juste de la mettre sur self dans __init__:

class ParentClass:
    def __init__(self):
        self.constant_pool = ["test"]
        self.ChildClass.constant_pool = self.constant_pool
        self.children = [self.ChildClass()]

    class ChildClass:
        def __init__(self):
            self.name = self.constant_pool[0]
            print "child name is", self.name

p = ParentClass() # Prints "child name is test"

Notez que vous pouvez toujours faire le même genre de chose sans l'enfant des classes imbriquées.

0

Votre question utilise le mot sous-classe, donc je suis d'incrustation de que de les interpréter à votre question. Comme avec les autres qui ont répondu, je ne suis pas certain que je comprends ce que vous cherchez.
```
class ParentClass(object):
  constant_pool = [c1, c2, c3]
  def __init__(self):
    # anything not included in your question

class ChildClass(ParentClass):
  def __init__(self, stream):
    ParentClass.__init__(self)
    self.name = ParentClass.constant_pool[stream.read_ui16()]

stream = get_new_stream()
children = []
for count in range(stream.read_ui16()):
  children.append(ChildClass(stream))
```
Ce code utilise l'héritage de dériver ChildClass de Myclass (et toutes les méthodes, etc). Le constant_pool est un attribut de Myclass lui-même, si c'est OK pour le traiter comme un attribut de toute instance de Myclass ou ChildClass (en disant self.constant_pool dans ChildClass.__init__ serait l'équivalent de ce qui précède, mais, à mon avis, trompeuse).

De nidification les définitions de classe n'est pas nécessaire. L'imbrication de la définition de ChildClass dans Myclass signifie simplement que ChildClass est un attribut de Myclass, rien de plus. Il ne fait pas cas de ChildClass héritent de Myclass.

Vous devez vous connecter pour publier un commentaire.