Comment obtenir Python Objet Parent?

Donc, j'essaie de faire l'objet que d'un objet personnalisé 'à l'intérieur de. Voici un exemple.

Supposons que o est un objet - il n'a pas d'importance ce genre, il peut tout stocker des variables.

o = Object()
class Test():
    def __init__(self):
        self.parent = o ## This is where I fall off; I want to be able to access
                        ## the o object from within the Test object

o.test = Test()

Alors, comment pourrais-je obtenir o de l'intérieur de Test? Je sais que je pourrais écrire la fonction de Test à passer dans avec

o.test = Test(o)

mais je préfère le faire de l'intérieur de la définition de la classe.

pouvez-vous illustrer ce que vous cherchez dans d'autres langues? Parce que ma compréhension de votre question n'a aucun sens dans un langage orienté objet...
Que voulez-vous être retourné lorsqu'il y a plusieurs pointeurs vers le même objet? Je ne pense pas que ce que vous recherchez est vraiment possible.
Eh bien, ce que je cherche est fondamentalement une méthode pour être en mesure d'atteindre un objet un objet d'une classe est un attribut de l'intérieur de la classe personnalisée. Permettez-moi de le dire comme ça - je ne peux pas définir le "parent" de la classe - c'est codé en dur dans un moteur de jeu que j'utilise. Ainsi, la classe A est déjà défini, et peut gérer des attributs comme un objet normal. La classe B est une classe personnalisée - je créer un objet de la Classe B et de le placer dans un attribut de la Classe A. Ainsi, parentobj.objb = ClassB(). Maintenant, est-il un moyen pour objb de dire ce parentobj est?

OriginalL'auteur SolarLune | 2011-07-04

  1. 7

    (Je sais c'est une vieille question, mais puisque c'est sans réponse...)

    Vous pouvez essayer de jouer avec le garbage collector. Va proposer à la recherche au niveau du module d'objets, mais certains rapide code de l'expérimentation a donné ceci: Essayez le gc.get_referrers(*objs) fonction.

    import gc

class Foo(object):
    """contains Bar"""
    def __init__(self, val):
        self.val = val
        self.bar = None

class Bar(object):
    """wants to find its parents"""
    def __init__(self, something):
        self.spam = something

    def find_parents(self):
        return gc.get_referrers(self)

    Les résultats ne sont pas simple de sorte que vous devrez appliquer votre logique propre pour comment déterminer qui f est celui que vous cherchez. Avis de la 'f': <__main__.Foo object at ...> ci-dessous:

    >>> f = Foo(4)
>>> b = Bar('ham')
>>> f.bar = b
>>> b.find_parents()
[{'bar': <__main__.Bar object at 0x7f3ec5540f90>, 'val': 4}, <frame object at 0x238c200>,
{'b': <__main__.Bar object at 0x7f3ec5540f90>,
    'Bar': <class '__main__.Bar'>,
    'f': <__main__.Foo object at 0x7f3ec5540f10>,    # <-- these might be
                                          # the droids you're looking for
    '__builtins__': <module '__builtin__' (built-in)>,
    '__package__': None, 'gc': <module 'gc' (built-in)>, '__name__': '__main__',
    'Foo': <class '__main__.Foo'>, '__doc__': None
}]

    Pour les points de bonus, utilisez gc.get_referents(*objs) sur ceux à vérifier si les mêmes b est dans leur liste.

    Quelques notes/avertissements:

    • Je pense que vous devriez passer le parent objet Foo Bar, soit dans init ou une autre méthode. C'est ce que je voudrais faire, au lieu de ma suggestion ci-dessus.
    • Cette SORTE de réponse souligne certains problèmes, le garbage collector a lors de la liaison de deux façons - vous n'êtes pas en train de faire cela, mais si vous le faites, fyi.

    OriginalL'auteur aneroid

  2. 5

    vous pourriez faire quelque chose comme ceci:

    class Object:
    def __setattr__(self, name, value):
        if isinstance(value, Test):
            value.set_parent(self)
        self.__dict__[name] = value

class Test:
    def set_parent(self, parent):
        self.parent = parent

o = Object()
o.test = Test()
assert o.test.parent is o
    le problème c'est qu'il n'ya aucun moyen pour Test() de réagir au assiged à un nom test sur un autre objet o autres que pour cet objet o de réagir à la cession de o.test et pour dire l'objet affecté Test().

    OriginalL'auteur Dan D.

  3. 2

    bien, je donno exactement ce que vous essayez. mais j'ai fait quelque chose comme ça.

    class Node(object):

    def __init__(self, name):
        self.parent = ''
        self.child = []
        self.name = name

    def setParent(self, parent):
        if isinstance(parent, tempNode):
            self.parent = parent.name
            parent.setChild(self.name)

    def setChild(self, child):
        self.child.append(child)

    def getParent(self):
        return self.parent

    def getChild(self):
        return self.child

    et pour faire d'un parent, vous pouvez dire

    n1 = Node('Father')
n2 = Node('Son')
n2.setParent('Father') # it will set n1 as parent and n2 as child at the same time.

    Espère que cela va vous aider.

    OriginalL'auteur RAHUL MISHRA

  4. 1

    Si vous voulez pouvant être héritées des objets de le faire correctement

    class Test(object):
    def __init__(self):
        self.a = 1

class Bobcat(Test):
    def __init__(self):
        Test.__init__(self)
        self.b = 4
    Ils ne sont pas héritables à tous les deux classes n'ont rien à voir les uns avec les autres. Le point est juste pour obtenir l'objet que d'un objet d'une classe est stockée dans - en fait, compte tenu de objectA.obj = ObjectB(), est-il un moyen d'obtenir objectA de l'intérieur ObjectB du code, comme un propriétaire propriété ou quelque chose comme ça? Ou dois-je le faire moi-même?
    vous pouvez faire référence à un objet d'un gazillion reprises, par exemple a = b = c = obj. Lequel de ces trois .retour de propriétaire? Vous avez gc.get_referrers(*objs) mais qui (peut-être) est-ce que vous voulez. Edit: oups, c'est VIEUX. Le mépris.

    OriginalL'auteur Jakob Bowyer

  5. 0

    Êtes-vous parler à propos de l'héritage? C'est pas très clair ce que tu veux dire, mais si vous voulez juste pour ce faire:

    class Test():
  def __init__(self,o):
    self.parent = o
  def other_method(self):
    do_something_with(self.parent)

    Il fonctionne parfaitement.

    **ndlr: Ce n'est pas du tout la façon dont vous devriez faire de l'héritage, si vous voulez le faire. Cependant, la façon dont vous décrivez votre problème, je pense que vous voulez pour créer une structure arborescente d'objets, pas de classes héritent des propriétés de chaque autre.

    Mauvaise façon de le faire inheratence
    Il n'a pas à se référer à son code des droits de succession. Il a juste montré qu'il (l'OP) peut simplement accéder à o via self.parent à partir de l'intérieur de l'objet, parce que c'est ce qu'il a demandé, le plus probable.
    Ce phant0m dit. La manière dont il décrit son besoin en tant que "l'objet que d'un objet personnalisé 'à l'intérieur de," je ne pense pas que l'héritage est ce qu'il veut.
    Ou même inheratence.
    Non, comme kasnero et phant0m dit, ma question n'a rien à faire avec l'héritage, mais plutôt un problème de l'obtention d'un objet dans un autre objet.

    OriginalL'auteur krasnerocalypse