Variable aus äußerer Klasse nutzen in einer inneren Klasse

[HolgiHero]

Hallo ,

möglicherweise bin ich jetzt verwirrt, aber ich habe ein Problem mit verschachtelten Klassen:
Ich möchte in der Definition (genauer: Funktion __init__) einer Klasse auf eine Variable zugreifen, die in einer äußeren Klassendef. gesetzt wurde.

Etwa so:

Code: Alles auswählen

class Outer():

    def __init__(self):
        self.var=21 # Diese Variable soll in der inneren Klasse genutzt werden

        class Inner():
            val=Outer.__init__.var # hier möchte ich auf die äußere Variable zugreifen (geht so natürlich nicht)
            self.out=val*2

        out=Inner()
        print str(out.out)+' ist die Antwort!'


if __name__ == '__main__' : run=Outer()

Geht sowas überhaupt? Oder muss ich jeweils die Variable dediziert übergeben (so mach ich es z.Z.)

Grüße, Holgi

[Leonidas]

Etwa so?

Code: Alles auswählen

# -*- coding: UTF-8 -*-
class Outer(object):

    def __init__(self):
        # Diese Variable soll in der inneren Klasse genutzt werden
        var = 21     

        class Inner(object):
            # hier möchte ich auf die äußere Variable zugreifen (geht so natürlich nicht)
            val = var               

            def __init__(self):
                self.out = self.val * 2

        out = Inner()
        print str(out.out) + ' ist die Antwort!'


if __name__ == '__main__': 
    run = Outer()

(achja, PEP8-angepasst )

[BlackJack]

Also so bekommst Du wenigstens die "Antwort":

Code: Alles auswählen

class Outer():
    def __init__(self):
        self.var = 21

        class Inner(): 
            val = self.var
            out = val * 2

        out = Inner()
        print str(out.out) + ' ist die Antwort!'

Aber das ist sicher alles nicht das was Du willst. Was willst Du überhaupt!?

Innere Klassen braucht man nur sehr selten, wenn überhaupt und *so* tief innen drin schon gar nicht. Deine Klasse ist in der Methode, dass heisst die ``class``-Anweisung, denn das ist es, eine *ausführbare Anweisung* wird bei jedem Aufruf der Methode ausgeführt. Das heisst bei jedem Aufruf wird eine *neue* Klasse erzeugt. Wenn Du die Methode nie aufrufst, gibt es gar keine `Inner`-Klasse, wenn Du sie x-mal aufrufst, werden x verschiedene `Inner`-Klassen erstellt.

Gehen wir mal Deinen Code durch: In Zeile 4 wird 21 an das Attribut `var` der `Outer`-Instanz gebunden. Dann wird die ``class``-Anweisung ausgeführt bei der eine neue Klasse erzeugt wird, die auf den lokalen Namen `Inner` hört. Auf *Klassenebene* willst Du jetzt an das Klassenattribut `Inner.val` das Objekt von `self.var` binden (`self` ist immer noch die `Outer`-Instanz in deren `__init__()` wir uns gerade befinden).

Zeile 8 bindet dann "die Antwort" an die `Outer`-Instanz, nicht an die `Inner`-Klasse.

Dann erzeugst Du eine `Inner`-Instanz und versuchst in Zeile 11 auf das nicht vorhandene Attribut `out` auf dieser Instanz zuzugreifen.

[HolgiHero]

Was willst Du überhaupt!?

Tja, vielleicht wirklich etwas anderes, als das, was ich mir da als Beispiel ausgedacht habe...

Innere Klassen braucht man nur sehr selten, wenn überhaupt und *so* tief innen drin schon gar nicht. Deine Klasse ist in der Methode, dass heisst die ``class``-Anweisung, denn das ist es, eine *ausführbare Anweisung* wird bei jedem Aufruf der Methode ausgeführt. Das heisst bei jedem Aufruf wird eine *neue* Klasse erzeugt. Wenn Du die Methode nie aufrufst, gibt es gar keine `Inner`-Klasse, wenn Du sie x-mal aufrufst, werden x verschiedene `Inner`-Klassen erstellt.

Mhh, das sind Argumente, die mir doch zu denken geben. Tatsächlich hab ich eine Klassendefinition in der __init__definition einer anderen Klasse drin. Da muss sie sicher nicht rein.
Das muss ich mal durchdenken und auseinanderziehen.
Damit hat sich dann sicherlich auch die ursprüngliche Frage erledigt.

Bedankt, Holgi