GUI von Logic trennen?

[Andyh]

Hallo

es gab hier schon mal die frage, aber ich finde diese wurde nicht zufriedenstellend beantwortet.

Ich mache das normaler weise so:
(Bsp: Tkinter)

Code: Alles auswählen

import Tkinter as tk

class Gui(tk.Frame):
    def __init__(self, l):
        self.logic = l
        self.root = tk.Tk()

    def start(self):
        self.root.mainloop()

class Logic():
    def __init__(self):
        pass

if __name__ == "__main__":
    l = Logic()
    g = Gui(l)
    g.start()

Ich gebe ja der Gui die logic mit, oder sollte man das andersherum machen?

oder noch ganz anders?

Gruß
Andyh

[tordmor]

Ich gebe ja der Gui die logic mit, oder sollte man das andersherum machen?

oder noch ganz anders?

Schon so herum, da die Gui den Aufbau der Logik kennen soll (muss), aber die Logik ja gerade nicht den Aufbau der Gui. D.h. die gui ist für den korrekten Ablauf verantwortlich, die Logik wird dann funktional programmiert, damit die Gui die nötigen Komponenten aufrufen kann, wann auch immer sie will.

Noch ganz anders wäre es möglich eine Abstraktion der GUI zu schreiben, aber das denke ich, verkompliziert den Aufbau unnötig.

[Andyh]

Hallo

Das hört sich ja schon gut an!
Da habe ich ja mal tatsächlich was richtig gemacht.

So wie ich die gui starte ist auch gut mit der "start()" funktion?

Gruß
Andyh

[lunar]

die Logik wird dann funktional programmiert

Funktionale Programmierung ist etwas anderes als "Programmierung mit Funktionen" Im Allgemeinen kann man die Logik implementieren, wie man lustig ist, sei es als Ansammlung von Funktionen oder als objektorientierte API. Das hängt ganz von Größe, Komplexität und Zweck der Logikschicht ab. Die GUI kann sich dann aus dieser API entsprechend bedienen.

Ein imho guter Ansatz ist, die Logik nicht im Hinblick auf die GUI zu entwerfen. Stattdessen entwirft man erstmal eine API für ein bestimmtes Problem, entwickelt also quasi ein Modul/Paket. Dann implementiert man ein kleines Kommandozeilenprogramm zum Testen und erst wenn die API steht, implementiert man die GUI, in dem man das eigene Logik-Modul/Paket nutzt, wie man eben jede andere Modul oder Paket aus der Standardbibliothek oder aus dem Cheeseshop nutzen würde.

[Darii]

Man unterteilt das ganze dann ach meist in drei Teile. Model, View und Controller. View ist dabei das was du GUI nennst. Der Controller ist die Logik, die aber auch durchaus Wissen über das GUI haben darf und muss. Und das Modell wird unabhängig von dem GUI entworfen.

Ein kleines Beispiel:

Code: Alles auswählen

class View(GUIToolkit):
    def __init__(self, controller):
        self.controller = controller
        self.controller.status_widget = self.widget1 = GUIToolkit.TextLabel()
    def ok_button_click(self):
        self.controller.save_data() # controller bekommt eine konkrete Aufgabe

class Controller:
    def save_data(self):
        self.model.save() # Daten speichern
        self.status_widget.text("Daten gespeichert") # Erfolg anzeigen,

Ich gebe ja der Gui die logic mit, oder sollte man das andersherum machen?

Die Antwort ist also: beides. bzw. die GUI besteht aus zwei Teilen