Der beste Weg, um eine tkinter-Anwendung zu strukturieren?

Das Folgende ist die Gesamtstruktur meines typischen Python-Tkinter-Programms.

def funA():
    def funA1():
        def funA12():
            # stuff

    def funA2():
        # stuff

def funB():
    def funB1():
        # stuff

    def funB2():
        # stuff

def funC():
    def funC1():
        # stuff

    def funC2():
        # stuff


root = tk.Tk()

button1 = tk.Button(root, command=funA)
button1.pack()
button2 = tk.Button(root, command=funB)
button2.pack()
button3 = tk.Button(root, command=funC)
button3.pack()

funA funBund funCöffnet ein weiteres ToplevelFenster mit Widgets, wenn der Benutzer auf die Schaltflächen 1, 2, 3 klickt.

Ich frage mich, ob dies der richtige Weg ist, um ein Python-Tkinter-Programm zu schreiben. Sicher, es wird funktionieren, auch wenn ich so schreibe, aber ist es der beste Weg? Es klingt dumm, aber wenn ich die Codes sehe, die andere Leute geschrieben haben, ist ihr Code nicht mit einer Reihe von Funktionen durcheinander und meistens haben sie Klassen.

Gibt es eine bestimmte Struktur, der wir als bewährte Praxis folgen sollten? Wie soll ich planen, bevor ich mit dem Schreiben eines Python-Programms beginne?

Ich weiß, dass es keine bewährten Methoden für die Programmierung gibt, und ich frage auch nicht danach. Ich möchte nur einige Ratschläge und Erklärungen, um mich auf dem richtigen Weg zu halten, während ich Python selbst lerne.

Ich befürworte einen objektorientierten Ansatz. Dies ist die Vorlage, mit der ich beginne:

# Use Tkinter for python 2, tkinter for python 3
import tkinter as tk

class MainApplication(tk.Frame):
    def __init__(self, parent, *args, **kwargs):
        tk.Frame.__init__(self, parent, *args, **kwargs)
        self.parent = parent

        <create the rest of your GUI here>

if __name__ == "__main__":
    root = tk.Tk()
    MainApplication(root).pack(side="top", fill="both", expand=True)
    root.mainloop()

Die wichtigsten Dinge zu beachten sind:

• Ich verwende keinen Platzhalterimport. Ich importiere das Paket als "tk", was erfordert, dass ich allen Befehlen ein Präfix vorstelle tk.. Dies verhindert eine globale Verschmutzung des Namespace und macht den Code vollständig offensichtlich, wenn Sie Tkinter-Klassen, ttk-Klassen oder einige Ihrer eigenen verwenden.

• Die Hauptanwendung ist eine Klasse . Dies gibt Ihnen einen privaten Namespace für alle Ihre Rückrufe und privaten Funktionen und erleichtert im Allgemeinen die Organisation Ihres Codes. In einem prozeduralen Stil müssen Sie von oben nach unten codieren, Funktionen definieren, bevor Sie sie verwenden usw. Mit dieser Methode tun Sie dies nicht, da Sie das Hauptfenster erst im letzten Schritt erstellen. Ich bevorzuge es zu erben, tk.Framenur weil ich normalerweise mit dem Erstellen eines Rahmens beginne, aber es ist keineswegs notwendig.

Wenn Ihre App über zusätzliche Fenster auf oberster Ebene verfügt, empfehle ich, jede dieser Fenster zu einer separaten Klasse zu machen, von der geerbt wird tk.Toplevel. Dies bietet Ihnen alle oben genannten Vorteile: Die Fenster sind atomar, sie haben einen eigenen Namespace und der Code ist gut organisiert. Außerdem ist es einfach, jedes Modul in ein eigenes Modul zu integrieren, sobald der Code groß wird.

Schließlich möchten Sie möglicherweise Klassen für jeden Hauptteil Ihrer Benutzeroberfläche verwenden. Wenn Sie beispielsweise eine App mit einer Symbolleiste, einem Navigationsbereich, einer Statusleiste und einem Hauptbereich erstellen, können Sie jede dieser Klassen erstellen. Dies macht Ihren Hauptcode ziemlich klein und leicht verständlich:

class Navbar(tk.Frame): ...
class Toolbar(tk.Frame): ...
class Statusbar(tk.Frame): ...
class Main(tk.Frame): ...

class MainApplication(tk.Frame):
    def __init__(self, parent, *args, **kwargs):
        tk.Frame.__init__(self, parent, *args, **kwargs)
        self.statusbar = Statusbar(self, ...)
        self.toolbar = Toolbar(self, ...)
        self.navbar = Navbar(self, ...)
        self.main = Main(self, ...)

        self.statusbar.pack(side="bottom", fill="x")
        self.toolbar.pack(side="top", fill="x")
        self.navbar.pack(side="left", fill="y")
        self.main.pack(side="right", fill="both", expand=True)

Da alle diese Instanzen ein gemeinsames übergeordnetes Element haben, wird das übergeordnete Element effektiv zum "Controller" -Teil einer Model-View-Controller-Architektur. So könnte beispielsweise das Hauptfenster durch Aufrufen etwas in der Statusleiste platzieren self.parent.statusbar.set("Hello, world"). Auf diese Weise können Sie eine einfache Schnittstelle zwischen den Komponenten definieren und so die Kopplung auf ein Minimum beschränken.

Wenn Sie jedes Fenster der obersten Ebene in eine eigene Klasse einordnen, können Sie den Code wiederverwenden und den Code besser organisieren. Alle im Fenster vorhandenen Schaltflächen und relevanten Methoden sollten in dieser Klasse definiert werden. Hier ist ein Beispiel (von hier genommen ):

import tkinter as tk

class Demo1:
    def __init__(self, master):
        self.master = master
        self.frame = tk.Frame(self.master)
        self.button1 = tk.Button(self.frame, text = 'New Window', width = 25, command = self.new_window)
        self.button1.pack()
        self.frame.pack()
    def new_window(self):
        self.newWindow = tk.Toplevel(self.master)
        self.app = Demo2(self.newWindow)

class Demo2:
    def __init__(self, master):
        self.master = master
        self.frame = tk.Frame(self.master)
        self.quitButton = tk.Button(self.frame, text = 'Quit', width = 25, command = self.close_windows)
        self.quitButton.pack()
        self.frame.pack()
    def close_windows(self):
        self.master.destroy()

def main(): 
    root = tk.Tk()
    app = Demo1(root)
    root.mainloop()

if __name__ == '__main__':
    main()

Siehe auch:

• einfache hallo welt von tkinter docs
• Tkinter-Beispielcode für mehrere Fenster, warum werden Schaltflächen nicht richtig geladen?
• Tkinter: Ein- / Ausblenden eines Fensters

Hoffentlich hilft das.

Dies ist keine schlechte Struktur; es wird gut funktionieren. Sie müssen jedoch Funktionen in einer Funktion haben, um Befehle ausführen zu können, wenn jemand auf eine Schaltfläche oder etwas klickt

Sie können also Klassen für diese schreiben und dann Methoden in der Klasse haben, die Befehle für die Schaltflächenklicks und dergleichen verarbeiten.

Hier ist ein Beispiel:

import tkinter as tk

class Window1:
    def __init__(self, master):
        pass
        # Create labels, entries,buttons
    def button_click(self):
        pass
        # If button is clicked, run this method and open window 2


class Window2:
    def __init__(self, master):
        #create buttons,entries,etc

    def button_method(self):
        #run this when button click to close window
        self.master.destroy()

def main(): #run mianloop 
    root = tk.Tk()
    app = Window1(root)
    root.mainloop()

if __name__ == '__main__':
    main()

Normalerweise sind tk-Programme mit mehreren Fenstern mehrere große Klassen und in der __init__ allen Einträgen werden Beschriftungen usw. erstellt. Anschließend werden bei jeder Methode Schaltflächenklickereignisse verarbeitet

Es gibt nicht wirklich einen richtigen Weg, was auch immer für Sie funktioniert und die Arbeit erledigt, solange es lesbar ist und Sie es leicht erklären können, denn wenn Sie Ihr Programm nicht einfach erklären können, gibt es wahrscheinlich einen besseren Weg, es zu tun .

Schauen Sie sich Thinking in Tkinter an .

OOP sollte der Ansatz sein und frameeine Klassenvariable anstelle einer Instanzvariablen sein .

from Tkinter import *
class App:
  def __init__(self, master):
    frame = Frame(master)
    frame.pack()
    self.button = Button(frame, 
                         text="QUIT", fg="red",
                         command=frame.quit)
    self.button.pack(side=LEFT)
    self.slogan = Button(frame,
                         text="Hello",
                         command=self.write_slogan)
    self.slogan.pack(side=LEFT)
  def write_slogan(self):
    print "Tkinter is easy to use!"

root = Tk()
app = App(root)
root.mainloop()

Referenz: http://www.python-course.eu/tkinter_buttons.php

Das Organisieren Ihrer Anwendung mithilfe von Klassen erleichtert Ihnen und anderen, die mit Ihnen zusammenarbeiten, das Debuggen von Problemen und das einfache Verbessern der App.

Sie können Ihre Anwendung einfach so organisieren:

class hello(Tk):
    def __init__(self):
        super(hello, self).__init__()
        self.btn = Button(text = "Click me", command=close)
        self.btn.pack()
    def close():
        self.destroy()

app = hello()
app.mainloop()

Der wahrscheinlich beste Weg, um zu lernen, wie Sie Ihr Programm strukturieren, ist das Lesen des Codes anderer Personen, insbesondere wenn es sich um ein großes Programm handelt, zu dem viele Personen beigetragen haben. Nachdem Sie sich den Code vieler Projekte angesehen haben, sollten Sie eine Vorstellung davon bekommen, wie der Konsensstil aussehen sollte.

Python als Sprache ist insofern besonders, als es einige strenge Richtlinien gibt, wie Sie Ihren Code formatieren sollten. Das erste ist das sogenannte "Zen of Python":

• Schön ist besser als hässlich.
• Explizit ist besser als implizit.
• Einfach ist besser als komplex.
• Komplex ist besser als kompliziert.
• Wohnung ist besser als verschachtelt.
• Spärlich ist besser als dicht.
• Lesbarkeit zählt.
• Sonderfälle sind nicht speziell genug, um gegen die Regeln zu verstoßen.
• Obwohl Praktikabilität die Reinheit übertrifft.
• Fehler sollten niemals stillschweigend vergehen.
• Sofern nicht ausdrücklich zum Schweigen gebracht.
• Verweigern Sie angesichts von Zweideutigkeiten die Versuchung zu raten.
• Es sollte einen - und vorzugsweise nur einen - offensichtlichen Weg geben, dies zu tun.
• Obwohl dieser Weg zunächst vielleicht nicht offensichtlich ist, es sei denn, Sie sind Niederländer.
• Jetzt ist besser als nie.
• Obwohl nie ist oft besser als Recht jetzt.
• Wenn die Implementierung schwer zu erklären ist, ist es eine schlechte Idee.
• Wenn die Implementierung leicht zu erklären ist, ist dies möglicherweise eine gute Idee.
• Namespaces sind eine großartige Idee - lasst uns mehr davon machen!

Auf einer praktischeren Ebene gibt es PEP8 , den Styleguide für Python.

Vor diesem Hintergrund würde ich sagen, dass Ihr Codestil nicht wirklich passt, insbesondere die verschachtelten Funktionen. Finden Sie eine Möglichkeit, diese zu reduzieren, indem Sie entweder Klassen verwenden oder sie in separate Module verschieben. Dadurch wird die Struktur Ihres Programms viel einfacher zu verstehen.

Ich persönlich verwende den objektorientierten Ansatz nicht, hauptsächlich, weil er a) nur im Weg steht; b) Sie werden das niemals als Modul wiederverwenden.

sondern etwas , das nicht hier diskutiert wird, ist , dass Sie müssen verwenden Threading oder Multiprocessing. Immer. Andernfalls wird Ihre Bewerbung schrecklich sein.

Führen Sie einfach einen einfachen Test durch: Starten Sie ein Fenster und rufen Sie dann eine URL oder etwas anderes ab. Änderungen sind, dass Ihre Benutzeroberfläche nicht aktualisiert wird, während die Netzwerkanforderung ausgeführt wird. Das heißt, Ihr Anwendungsfenster wird beschädigt. Dies hängt vom Betriebssystem ab, auf dem Sie sich befinden. In den meisten Fällen wird es jedoch nicht neu gezeichnet. Alles, was Sie über das Fenster ziehen, wird darauf verputzt, bis der Vorgang wieder im TK-Mainloop ausgeführt wird.