Innere Klassen: Wie kann ich das Objekt der äußeren Klasse zur Konstruktionszeit erhalten?

Question

Betrachten Sie den folgenden Python (läuft in 2.x oder 3.x):

class Outer(object): 
    pass 

    class Inner(object): 
    def __init__(self): 
     print("Inner.self", self) 

o = Outer() 
i = o.Inner() 

Ich mag, während im Innern Inner.__init__() auf o meine Hände zu bekommen. Aber:

• Ich will nicht o ein expliziter Parameter auf Inner sein.
• Ich möchte O.Inner und o.Inner ein Klassenobjekt sein, nicht etwas Seltsames wie eine Schließung.

Können Sie mir vorschlagen, wie ich das erreichen könnte?

Im Moment ist meine beste Idee, lokalen Threadspeicher zu verwenden. In meinem Anwendungsfall, wenn ich ein o.Inner() konstruieren, ich bin schon in einem Verfahren auf o irgendwo, und es wäre keine große Sache

threading.local()["my o object"] = o 

zu meinem Code hinzuzufügen sein.

Dies gibt Ihnen eine Vorstellung von dem Grad der Verdorbenheit, die ich bereit bin zu berücksichtigen.

Answer 1

In Python 2.6, einer Klasse Dekorateur, das ist auch eine benutzerdefinierte Deskriptor passt die Spezifikationen Sie geben:

class InnerClassDescriptor(object): 
    def __init__(self, cls): 
    self.cls = cls 
    def __get__(self, instance, outerclass): 
    class Wrapper(self.cls): 
     outer = instance 
    Wrapper.__name__ = self.cls.__name__ 
    return Wrapper 

class Outer(object): 
    @InnerClassDescriptor 
    class Inner(object): 
    def __init__(self): 
     print self.outer 

o = Outer() 
i = o.Inner() 
print 'Outer is a', type(Outer) 
print 'Inner is a', type(o.Inner) 

Dieses aussendet:

<__main__.Outer object at 0x82f90> 
Outer is a <type 'type'> 
Inner is a <type 'type'> 

nur um das zu bestätigen

o.Inner ist [[ist]] eine Klasse Objekt, nicht etwas komisch wie ein Verschluss

nach Ihren besonderen Angaben.die folgende sogar in einer Welt, single-threaded, - Natürlich braucht es eine verschiedene Klasse jedes Mal für reentrancy sein:

o1 = Outer() 
o2 = Outer() 
i1 = o1.Inner 
i2 = o2.Inner 
print i1(), i2(), i1(), i2() 

arbeiten sauber sollte, und stashing o1 vs o2 anderswo als in den Klassen kehrt von o1.Inner vs o2.Inner (zB in TLS) würde schreckliche Ergebnisse für diese Verwendung bedeuten.

Aber dann Sie hat nicht angeben „o.Inner hat genau die gleiche Klasse sein Objekt für jeder möglich o, dass eine Instanz von Outer ist“, so dass dieser Code erfüllt die Spezifikationen Sie tat give ;-).

Answer 2

Sie sollten Ihren Code so umgestalten, dass keine inneren Klassen verwendet werden und die Instanz von Outer nach Inner explizit übergeben wird, wenn Sie sie erstellen oder nicht.

Answer 3

Sie können nicht (in irgendeiner tragbaren, zuverlässigen oder effizienten Weise). Geschachtelte Klassen haben keine Beziehung zu der Schachtelungsklasse. Sie haben auch keinen Mehrwert. Verwenden Sie nicht geschachtelte Klassen, sondern verwenden Sie die Eingrenzung von Instanzen - definieren Sie Outer und Inner separat und erstellen Sie eine Instanz von Inner in , möglicherweise Outer oder die Outer Instanz, wenn Sie es benötigen. Sie können Inner ein Klassenattribut von Outer machen, wenn Sie darauf bestehen, aber es wird keinen speziellen Zugriff auf Outer haben.

Answer 4

Kann nicht gemacht werden. Aber mit ein bisschen Redesign:

class Outer(object): 
    pass 

    class _Inner(object): 
    def __init__(self, outobj): 
     self.outobj = outobj 

    def Inner(self): 
    return self._Inner(self) 

o = Outer() 
i = o.Inner() 

print o, i.outobj 

Answer 5

Sie können eine Metaklasse verwenden, um einen __get__ Deskriptor zu implementieren, der die innere Klasse an die äußere Klasse bindet. Und da Sie nur an einer Bindung an eine Klasse interessiert zu sein scheinen, sollten Sie in Betracht ziehen, die innere Klasse an Ort und Stelle zu ändern, im Gegensatz zu einer Funktion, die in eine Methode eingebettet ist.

>>> class Outer(object): 
    class Inner(object): 
     class __metaclass__(type): 
      def __get__(self, instance, owner): 
       self.owner = owner 
       return self 


>>> Outer.Inner is Outer().Inner 
True 
>>> Outer.Inner.owner is Outer 
True 

Wenn Sie eher die innere Klasse über eine Unterklasse wickeln würde dann ersetzen Sie den __get__ Körper mit:

return type(self.__name__, (self,), {'owner': owner}) 

Answer 6

Siehe Access outer class from inner class in python (https://stackoverflow.com/a/35118717/3787376)
für eine einfache zuverlässige Antwort, die ich, dass nur aus Anwendungen Variablen, Attribute, Funktionen und Klassen - kein spezieller Code.