Variablen in init von außen nicht einsehbar?

Momentan versuche ich ein kleines Spiel zu programmieren dabei müssen Variablen von einer Klasse in einer anderen eigesehen werden können. Ich weiß nicht ganz genau wie man das am besten macht deswegen erstelle ich eine Instanz der Klasse und versuche darüber dann die Variablen einzusehen einzusehen.

Nur leider funktoniert das nicht. Wo ran könnte das liegen?

Hier der Code: https://pastebin.com/LHH38DLV

Hauptsächlich geht es um den Code von Zeile 42 bis 96

P.S ist nur ein Testprogramm momentan(d.h um die globalen Variablen kümmer ich mich noch)

Answer 1

[KarlRanseierIII]

    class Easy_name2flag_game: 
        def __init__(self):
             .....
        @run_once
        def getvalues(self):
            .........
 
        def rendering(self):  # renders the text, etc.
            global text_render
            var = Game.Easy_name2flag_game()  ########

####### Du instanziierst die Klasse in ihrer eigenen MEthode, oder übersehe ich hier etwas?

Eine Möglichgkeit, um die Variablen einer anderen Klasse zu nutzen, ist ein getter, das wäre als Schnittstelel sauber, sonst kannst Du auch direkt auf Attribute einer Fremden Klasse zugreifen.

Hier mal eien kurze Demonstration:

>>> class A:
...    def __init__(this,name,age):
...          this.name=name
...          this.age=age
...    def getvals(self):
...          return self.name,self.age
...
>>> test=A('Hans',12)
>>> test
<__main__.A object at 0x7f0be7d85ea0>
>>> test.getvals()
('Hans', 12)
>>> test.name
'Hans'

Das sollte selbsterklärend sein, getvals() liefert einfach alle Attribute als Tupel, ich kann auch auf ein Attribut der Objektinstanz direkt zugreifen.

Nun nutzen wir diese Klasse in einer anderen:

>>> class B:
...     def __init__(self):
...         self.foreign=A('Klaus',14)
...     def getassoc(self):
...         return self.foreign
...     def getv1(self):
...         return self.foreign.getvals()  #call to foreign method
...     def getv2(self):
...         return self.foreign.name,self.foreign.age 
...     def getassocm(self):
...         return self.foreign.getvals
...
>>> check=B()

Soweit so klar, wir instanziieren die Klasse B, die nun eine Instanz von A enthält.

>>> check.getassoc()
<__main__.A object at 0x7f0be7d85f60> #Die Instanz von A
>>> check.getassoc().getvals() #Methode von A() von außen aufr.
('Klaus', 14)
>>> check.getassoc().name # Durchgriff auf die Attribute
'Klaus'
>>> check.getassoc().age
14

Wenn ich also die Referenz auf die Objektinstanz nach außen reiche, kann ich die normal nutzen.

>>> check.getv1()
('Klaus', 14)
>>> check.getv2()
('Klaus', 14)

Einmal Nutzung von getter durch B, einmal direkter Durchgriff.

>>> check.getassocm()
<bound method A.getvals of <__main__.A object at 0x7f0be7d85f60>>

Hier lasse ich mir von der Methode von B eine Referenz auf die getter-Methode von A nach außen reichen. Der Aufruf ist entsprechend:

>>> check.getassocm()()
('Klaus', 14)

Python kennt die typische Kapselung nicht, man macht das einfach über die Benennung, aber hier mal der volle Durchgriff:

>>> check.foreign.getvals()
('Klaus', 14)
>>> check.foreign.name
'Klaus'

So, ich hoffe damit kannst Du Deine Wunschkomposition hinbekommen.

Comments

[Max1236]

Dankeschön jetzt klappt es wie ich mit das vorgestellt hatte :)