Instanzübergabe für Funktionsaufruf

[Lucathon]

Hi, mal eine allgemeine Frage.

Mal angenommen man hat eine Klasse A und in dieser instanziert man Klasse B. Nun benötigt Klasse B die möglichkeit 1- 2 Funktionen der Klasse A aufzurufen. Ist es dann ein guter Weg bei der Instanzierung von B die Instanz von A mitzuübergeben damit B über diese dann die Funktionen ansprechen kann? Oder kennt ihr bessere Wege? Etwa aussehen würde dass dann:

Code: Alles auswählen

class A():
	def __init__(self):
		...
	
		b = B(instanz_Der_Klasse_A) 		#hier irgendwie die Instanz der Klasse A ermitteln

	def func_von_A():
		...
class B():
	def __init__(self, instanz_Der_Klasse_A):
		...
		instanz_Der_Klasse_A.func_von_A()
 

Danke schonmal für eure Antworten, bin gespannt was es hier für bessere Lösungen gibt.

LG
Lucathon

[rogerb]

@Lucathon,

wie ich das Beispiel verstehe, benötigt Klasse A nichts von Klasse B. Es würde reichen Klasse A in Klasse B zu instantieren.
Oder haben beide Klassen etwa gegenseitige Abhängigkeiten? Das kann und sollte man vermeiden.
Wie genau das dann zu lösen ist, ist schwer zusagen, da ich nicht mehr über den Code weiß.

[__blackjack__]

@Lucathon: Das „irgendwie … ermitteln“ in dem Kommentar heisst `self`.

Code: Alles auswählen

class B:
    def __init__(self, a):
        ...
        a.method_on_a()


class A:
    def __init__(self):
        ...
        b = B(self)

    def method_on_a(self):
        ...

[Lucathon]

wie ich das Beispiel verstehe, benötigt Klasse A nichts von Klasse B. Es würde reichen Klasse A in Klasse B zu instantieren.

In meinem Anwendungsfall wäre Klasse A als erstes instanziert, sie verwaltet eine GUI.
Klasse B wäre für eine serielle Schnittstelle zuständig und deshalb erst als 2tes erzeugt worden.

[Lucathon]

@Lucathon: Das „irgendwie … ermitteln“ in dem Kommentar heisst `self`.

Ach danke, sieht ellegant aus. Ist das eine Lösung wie man sie regelmäßig im Code verwenden kann?
Oder doof gefragt, ist das eine "schöne" Lösung?

[__blackjack__]

@Lucathon: Nach der Beschreibung eher nicht. Da würde man die Programmlogik als erstes erstellen und der GUI als Argument übergeben. Und die Programmlogik sollte auch nichts über die GUI-Klasse wissen müssen. Wie rogerb schon sagte: so eine gegenseitige Abhängigkeit sollte man vermeiden.

[Sirius3]

@Lucathon: was muß denn die Serielle Schnittstelle konkret von der GUI wissen?

[Lucathon]

@__blackjack__ Ok verstehe ich natürlich. Um besser damit umgehen zu können möchte ich noch ein Beispiel nennen.

Ein Programm geht los mit der GUI, also der instanz der Klasse A. Später soll von dieser eine serielle Schnittstelle gestartet werden. Je nach dem Zustand der Seriellen soll die GUI ein Terminalfenster anzeigen oder nicht. Dafür muss Klasse B der Klasse A ja irgendwie bescheid geben, dass sie Serielle offen ist (z.B. in Form eines flags oder eines funktionsaufrufs einer Funktion von A. wofür ich ja dann die Instanz von A in B benötigen würde. Da hier die GUI definitiv zuerst existieren muss, wie würde ich das am Besten umsetzen?

P.S. ist jetzt nur theoretisch und dient mir zum lernen ^^

[Lucathon]

@Lucathon: was muß denn die Serielle Schnittstelle konkret von der GUI wissen?

Zum Beispiel nachschauen ob in einem Textfeld schon ein bestimmter String steht, der ebenfalls früher aus der Seriellen entstammt und dementsprechend direkt nach dem lesen weggeworfen werden kann.

Mir gehts so grundlegend um das Prinzip "was passiert wenn die Klasse B, welche in A instanziert wird, irgendetwas in A erledigen soll. Vllt zu sagen" Hey, die Serielle ist jetzt zu, erstelle mal bitte ein neues Fenster um eine neue zu öffnen. Versteht man was ich meine?

[__blackjack__]

@Lucathon: Die serielle Schnittstelle öffnet sich doch nicht von selbst, sondern das wird doch von der GUI angestossen. Dementsprechend weiss die GUI danach auch ob die Schnittstelle offen ist, oder kann das leicht prüfen.

Und die serielle Schnittstelle hat nichts in irgendwelchen GUI-Textfeldern nachzusehen.

Angetrieben wird das ganze doch sowieso von der Hauptschleife des GUI-Rahmenwerks. Da kann die Schnittstelle sowieso nicht selbst irgend etwas machen. Es sei denn sie läuft nebenläufig. Dann hat sie aber noch weniger an der GUI zu suchen, weil das dann nicht nur schlecht entworfen ist, sondern in der Regel ein Fehler weil GUI-Rahmenwerke in der Regel nur sehr bedingt threadsicher sind.