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

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
HolgiHero
User
Beiträge: 2
Registriert: Montag 29. Oktober 2007, 12:42
Wohnort: FFM

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

Beitragvon HolgiHero » Donnerstag 1. November 2007, 16:04

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
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Donnerstag 1. November 2007, 16:24

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 8) )
My god, it's full of CARs! | Leonidasvoice vs Modvoice
BlackJack

Beitragvon BlackJack » Donnerstag 1. November 2007, 16:31

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
User
Beiträge: 2
Registriert: Montag 29. Oktober 2007, 12:42
Wohnort: FFM

Beitragvon HolgiHero » Donnerstag 1. November 2007, 17:07

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

Wer ist online?

Mitglieder in diesem Forum: Bing [Bot]