Il modo migliore per strutturare un'applicazione tkinter?

Quella che segue è la struttura generale del mio tipico programma tkinter python.

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 funBe funCfarà apparire un'altra Toplevelfinestra con i widget quando l'utente fa clic sul pulsante 1, 2, 3.

Mi chiedo se questo è il modo giusto di scrivere un programma python tkinter? Certo, funzionerà anche se scrivo in questo modo, ma è il modo migliore? Sembra stupido ma quando vedo i codici scritti da altre persone, il loro codice non è incasinato con un sacco di funzioni e per lo più hanno classi.

Esiste una struttura specifica che dovremmo seguire come buona pratica? Come devo pianificare prima di iniziare a scrivere un programma Python?

So che non esiste una buona pratica in programmazione e non lo sto chiedendo neanche. Voglio solo alcuni consigli e spiegazioni per tenermi nella giusta direzione mentre sto imparando Python da solo.

Sostengo un approccio orientato agli oggetti. Questo è il modello con cui inizio:

# 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()

Le cose importanti da notare sono:

• Non utilizzo un'importazione con caratteri jolly. Importo il pacchetto come "tk", che richiede il prefisso di tutti i comandi tk.. Ciò previene l'inquinamento dello spazio dei nomi globale, inoltre rende il codice completamente ovvio quando si utilizzano classi Tkinter, classi tk o alcune delle proprie.

• L'applicazione principale è una classe . Questo ti dà uno spazio dei nomi privato per tutti i tuoi callback e funzioni private, e in generale semplifica l'organizzazione del tuo codice. In uno stile procedurale devi scrivere il codice dall'alto verso il basso, definire le funzioni prima di usarle, ecc. Con questo metodo non lo fai poiché non crei effettivamente la finestra principale fino all'ultimo passaggio. Preferisco ereditare tk.Framesolo perché in genere inizio creando un frame, ma non è assolutamente necessario.

Se la tua app ha finestre di livello superiore aggiuntive, ti consiglio di rendere ciascuna di queste una classe separata, ereditando da tk.Toplevel. Questo ti dà tutti gli stessi vantaggi sopra menzionati: le finestre sono atomiche, hanno il loro spazio dei nomi e il codice è ben organizzato. Inoltre, semplifica l'inserimento di ciascuno nel proprio modulo una volta che il codice inizia a diventare grande.

Infine, potresti prendere in considerazione l'utilizzo delle classi per ogni parte principale della tua interfaccia. Ad esempio, se stai creando un'app con una barra degli strumenti, un riquadro di navigazione, una barra di stato e un'area principale, puoi creare ognuna di quelle classi. Questo rende il tuo codice principale abbastanza piccolo e facile da capire:

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)

Dato che tutte queste istanze condividono un genitore comune, il genitore diventa effettivamente la parte "controller" di un'architettura modello-view-controller. Quindi, ad esempio, la finestra principale potrebbe posizionare qualcosa sulla barra di stato chiamando self.parent.statusbar.set("Hello, world"). Ciò consente di definire una semplice interfaccia tra i componenti, contribuendo a mantenere l'accoppiamento con un minimo.

Mettere ciascuna delle finestre di livello superiore nella propria classe separata ti consente di riutilizzare il codice e una migliore organizzazione del codice. Eventuali pulsanti e metodi pertinenti presenti nella finestra devono essere definiti all'interno di questa classe. Ecco un esempio (preso da qui ):

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()

Vedi anche:

• ciao mondo semplice da documenti di Tkinter
• Codice di esempio di Tkinter per più finestre, perché i pulsanti non vengono caricati correttamente?
• Tkinter: come mostrare / nascondere una finestra

Spero che aiuti.

Questa non è una cattiva struttura; funzionerà bene. Tuttavia, devi avere funzioni in una funzione per eseguire comandi quando qualcuno fa clic su un pulsante o qualcosa del genere

Quindi quello che potresti fare è scrivere classi per questi quindi avere metodi nella classe che gestiscono i comandi per i clic sui pulsanti e così via.

Ecco un esempio:

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()

Di solito i programmi tk con più finestre sono più classi grandi e in __init__tutte le voci, le etichette ecc. Vengono create e quindi ogni metodo è quello di gestire gli eventi clic sui pulsanti

Non c'è davvero un modo giusto per farlo, qualunque cosa funzioni per te e svolga il lavoro finché è leggibile e puoi spiegarlo facilmente perché se non riesci a spiegare facilmente il tuo programma, probabilmente c'è un modo migliore per farlo .

Dai un'occhiata a Thinking in Tkinter .

OOP dovrebbe essere l'approccio e framedovrebbe essere una variabile di classe anziché una variabile di istanza .

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()

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

Organizzare la tua applicazione usando class rendi facile a te e agli altri che lavorano con te il debug dei problemi e migliorare facilmente l'app.

Puoi organizzare facilmente la tua applicazione in questo modo:

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()

Probabilmente il modo migliore per imparare a strutturare il tuo programma è leggere il codice di altre persone, specialmente se si tratta di un grande programma a cui molte persone hanno contribuito. Dopo aver esaminato il codice di molti progetti, dovresti avere un'idea di come dovrebbe essere lo stile di consenso.

Python, come lingua, è speciale in quanto vi sono alcune linee guida su come formattare il codice. Il primo è il cosiddetto "Zen of Python":

• Bello è meglio che brutto.
• Esplicito è meglio che implicito.
• Semplice è meglio di complesso.
• Complesso è meglio che complicato.
• Flat è meglio di nidificato.
• Sparse è meglio che denso.
• La leggibilità conta.
• I casi speciali non sono abbastanza speciali da infrangere le regole.
• Sebbene la praticità superi la purezza.
• Gli errori non dovrebbero mai passare silenziosamente.
• A meno che non sia esplicitamente messo a tacere.
• Di fronte all'ambiguità, rifiuta la tentazione di indovinare.
• Dovrebbe esserci uno - e preferibilmente solo un - modo obsoleto di farlo.
• Anche se in quel modo all'inizio potrebbe non essere ovvio a meno che tu non sia olandese.
• Adesso è meglio che mai.
• Anche se non è spesso meglio di destra ora.
• Se l'implementazione è difficile da spiegare, è una cattiva idea.
• Se l'implementazione è facile da spiegare, potrebbe essere una buona idea.
• Gli spazi dei nomi sono un'ottima idea per suonare il clacson: facciamo di più!

A un livello più pratico, c'è PEP8 , la guida di stile per Python.

Con quelli in mente, direi che il tuo stile di codice non si adatta davvero, in particolare le funzioni nidificate. Trova un modo per appiattire quelli, usando le classi o spostandole in moduli separati. Ciò renderà la struttura del tuo programma molto più facile da capire.

Personalmente non uso l'approccio orientato agli oggetti, soprattutto perché a) mi intrometto; b) non lo riutilizzerai mai come modulo.

ma qualcosa che non è discusso qui, è che è necessario utilizzare il threading o il multiprocessing. Sempre. altrimenti la tua applicazione sarà terribile.

fai un semplice test: avvia una finestra, quindi recupera un po 'di URL o qualsiasi altra cosa. le modifiche apportate all'interfaccia utente non verranno aggiornate durante la richiesta di rete. Ciò significa che la finestra dell'applicazione verrà rotta. dipende dal sistema operativo in cui ti trovi, ma la maggior parte delle volte non verrà ridisegnato, tutto ciò che trascini sulla finestra verrà intonacato su di esso, fino a quando il processo non tornerà al mainloop TK.