Code vernünftig strukturieren (Module verwenden)

[Neu111]

Guten Morgen!
Mein Script ist inzwischen sehr lang und unübersichtlich geworden, weshalb ich nun Module verwenden möchte.
Zunächst ein paar Hintergrundinfos:
Ich habe mir eine grafische Benutzeroberfläche (GUI1) gebaut. Aus dieser Hauptanwendung heraus kann bei Bedarf noch eine zweite grafische Benutzeroberfläche (GUI2) gestartet werden, ich nenne sie hier "Anwendung2".

Ich habe meinen Programmiercode nun aufgeteilt, in

• hauptanwendung.py

• anwendung2.py

anwendung2.py ist ein Modul, welches innerhalb von hauptanwendung.py importiert wird.
Beide py-Dateien beinhalten zahlreiche Klassen.

Ich benötige zusätzlich aber Funktionen/Methoden, die ich sowohl in den Klassen von hauptanwendung.py als auch in den Klassen von anwendung2.py nutzen kann.

Heißt das jetzt, dass ich mir ein weiteres Modul (gemeinsame_funktionen.py) bauen muss, welches sowohl in hauptanwendung.py als auch in anwendung2.py importiert wird?

hauptanwendung.py importiert anwendung2.py, hauptanwendung.py importiert gemeinsame_funktionen.py und anwendung2.py importiert auch gemeinsame_funktionen.py?? Ist diese Struktur "richtig"?

[Sirius3]

Die Module sollten noch bessere Namen bekommen. Was sind denn das für gemeinsame Funktionen? Ansonsten spricht nichts gegen so eine Einteilung.
Aus den zwei grafischen Benutzeroberflächen sollte dann EINE werden, eventuell mit mehreren Fenstern.

[Neu111]

Was sind denn das für gemeinsame Funktionen?

Zum Beispiel das Auslesen und Beschreiben der Windows Zwischenablage.

Folgende Situation liegt nun vor:

hauptanwendung.py importiert anwendung2.py und beide Scripte importieren zusätzlich gemeinsame_funktionen.py

In der hauptanwendung.py wird nun ein Objekt "GUI1" erstellt, und wenn dort ein bestimmter Button gedrückt wird, wird ein weiteres Objekt namens GUI2 generiert.

In GUI2 wird nun die Methode schreibe_wert_in_die_zwischenablage aus der Datei gemeinsame_funktionen.py ausgeführt.

Nun möchte ich diesen Wert aber zusätzlich in GUI1 anzeigen lassen. Wie kriege ich den Wert aus schreibe_wert_in_die_zwischenablage, der über das Objekt GUI2 ausgeführt wurde, in das Objekt GUI1 ??

[grubenfox]

beim erzeugen von GUI2 eine Methode "setze_wert_in_gui1" aus GUI1 mit an GUI2 übergeben und dann in GUI2 vor oder nach dem Aufruf von schreibe_wert_in_die_zwischenablage "setze_wert_in_gui1" aufrufen

[Neu111]

beim erzeugen von GUI2 eine Methode "setze_wert_in_gui1" aus GUI1 mit an GUI2 übergeben

"Methoden übergeben" - wie meinst du das? Ich stehe jetzt leider auf den Schlauch.

[__deets__]

GUI2 ist doch von GUI1 erzeugt worden. Also kann es auch an GUI2 sich selbst uebergeben, und dann ist das trivial.

Code: Alles auswählen

class GUI2:
     def __init__(self, gui1):Q
        self._gui1 = gui1

     def tu_was_mit_dem_clipboard(self):
           self._gui1.da_ist_was_mit_dem_clipboard_passiert()

class GUI1:
    def __init__(self):
         self._gui2 = None
    def create_gui2(self):
         self._gui2 = GUI2(self)
    def da_ist_was_mit_dem_clipboard_passiert(self):
         print("gui1 macht sachen mit dem clipboard!")

g1 = GUI1()
g2 = g1.create_gui2()
g2.tu_was_mit_dem_clipboard()

[grubenfox]

und statt mit self sich selbst an GUI2 zu übergeben könnte es mit self.da_ist_was_mit_dem_clipboard_passiert [Wichtig: ohne Klammern!] auch eine Methode übergeben

in diesem Beispiel dann:

Code: Alles auswählen

    def create_gui2(self):
         self._gui2 = GUI2(self.da_ist_was_mit_dem_clipboard_passiert)

Den Code GUI2 müsste man dann noch etwas umbauen, weil nun keine gui1 übergeben wird, sondern eine Callback-Methode:

Code: Alles auswählen

class GUI2:
     def __init__(self, clipboard_callback):
        self._clipboard_callback = clipboard_callback

     def tu_was_mit_dem_clipboard(self):
        self._clipboard_callback()

Und in beiden Fällen fehlt da zur Funktion des Beispiels in gui1 noch die Rückgabe der erzeugten gui2

Code: Alles auswählen

    def create_gui2(self):
         self._gui2 = GUI2(self.da_ist_was_mit_dem_clipboard_passiert)
         return self._gui2

[__blackjack__]

Zu den Modulen generell vielleicht noch der Hinweis, dass es Sinn macht die in einem Package zusammenzufassen, damit es auf ”oberster Ebene” nur *einen* Namen gibt, der mit anderen Modul- und Packagenamen in Konflikt stehen kann.