Najlepszy sposób na ustrukturyzowanie aplikacji tkinter?

Poniżej przedstawiono ogólną strukturę mojego typowego programu tkinter w języku 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 funBi funCprzywoła innyToplevel okno z widżetami, gdy użytkownik kliknie przycisk 1, 2, 3.

Zastanawiam się, czy to jest właściwy sposób na napisanie programu tkinter w Pythonie? Jasne, zadziała, nawet jeśli napiszę w ten sposób, ale czy to najlepszy sposób? Brzmi głupio, ale kiedy widzę kody napisane przez innych ludzi, ich kod nie jest pomieszany z wieloma funkcjami i przeważnie mają klasy.

Czy jest jakaś konkretna struktura, której powinniśmy przestrzegać jako dobrej praktyki? Jak powinienem zaplanować przed rozpoczęciem pisania programu w Pythonie?

Wiem, że nie ma czegoś takiego jak najlepsze praktyki w programowaniu i też o to nie proszę. Chcę tylko kilku rad i wyjaśnień, które utrzymają mnie we właściwym kierunku, gdy sam uczę się Pythona.

Jestem zwolennikiem podejścia obiektowego. Oto szablon, od którego zaczynam:

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

Ważne rzeczy, na które należy zwrócić uwagę, to:

• Nie używam importu symboli wieloznacznych. Importuję pakiet jako „tk”, co wymaga poprzedzenia wszystkich poleceń przedrostkiem tk.. Zapobiega to zanieczyszczaniu globalnej przestrzeni nazw, a ponadto sprawia, że ​​kod jest całkowicie oczywisty, gdy używasz klas Tkinter, klas ttk lub niektórych własnych.

• Głównym zastosowaniem jest klasa . Daje to prywatną przestrzeń nazw dla wszystkich wywołań zwrotnych i funkcji prywatnych i po prostu ogólnie ułatwia organizowanie kodu. W stylu proceduralnym musisz kodować od góry do dołu, definiując funkcje przed ich użyciem itp. W przypadku tej metody nie jest to możliwe, ponieważ w rzeczywistości nie tworzy się głównego okna aż do ostatniego kroku. Wolę dziedziczyć tk.Frametylko dlatego, że zazwyczaj zaczynam od stworzenia ramki, ale nie jest to wcale konieczne.

Jeśli twoja aplikacja ma dodatkowe okna najwyższego poziomu, polecam uczynić każde z nich osobną klasą, dziedzicząc po tk.Toplevel . Zapewnia to wszystkie wymienione powyżej zalety - okna są atomowe, mają własną przestrzeń nazw, a kod jest dobrze zorganizowany. Ponadto ułatwia umieszczenie każdego z nich we własnym module, gdy kod zacznie się rozrastać.

Na koniec możesz rozważyć użycie klas dla każdej większej części interfejsu. Na przykład, jeśli tworzysz aplikację z paskiem narzędzi, okienkiem nawigacji, paskiem stanu i obszarem głównym, możesz utworzyć każdą z tych klas. To sprawia, że ​​twój główny kod jest dość mały i łatwy do zrozumienia:

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)

Ponieważ wszystkie te instancje mają wspólnego rodzica, rodzic faktycznie staje się częścią „kontrolera” architektury model-widok-kontroler. Na przykład główne okno może umieścić coś na pasku stanu, wywołując self.parent.statusbar.set("Hello, world"). Pozwala to na zdefiniowanie prostego interfejsu między komponentami, pomagając utrzymać połączenie z minimun.

Umieszczenie każdego z okien najwyższego poziomu w osobnej klasie zapewnia ponowne użycie kodu i lepszą organizację kodu. Wszelkie przyciski i odpowiednie metody, które są obecne w oknie, powinny być zdefiniowane w tej klasie. Oto przykład (zaczerpnięty stąd ):

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

Zobacz także:

• prosty witaj świecie od tkinter Docs
• Przykładowy kod Tkinter dla wielu okien, dlaczego przyciski nie ładują się poprawnie?
• Tkinter: Jak pokazać / ukryć okno

Mam nadzieję, że to pomoże.

To nie jest zła konstrukcja; będzie działać dobrze. Jednak musisz mieć funkcje w funkcji, aby wykonywać polecenia, gdy ktoś kliknie przycisk lub coś

Więc to, co możesz zrobić, to napisać dla nich klasy, a następnie mieć w klasie metody, które obsługują polecenia dla kliknięć przycisku i tym podobne.

Oto przykład:

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

Zazwyczaj programy tk z wieloma oknami są wieloma dużymi klasami i we __init__wszystkich wpisach tworzone są etykiety itp., A następnie każda metoda obsługuje zdarzenia kliknięcia przycisku

Naprawdę nie ma właściwego sposobu, aby to zrobić, cokolwiek działa dla ciebie i wykonuje zadanie, o ile jest czytelne i możesz to łatwo wyjaśnić, ponieważ jeśli nie możesz łatwo wyjaśnić swojego programu, prawdopodobnie jest lepszy sposób, aby to zrobić .

Spójrz na Thinking in Tkinter .

OOP powinno być podejściem i framepowinno być zmienną klasy, a nie zmienną instancji .

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

Źródła: http://www.python-course.eu/tkinter_buttons.php

Organizowanie aplikacji przy użyciu klas ułatwia Tobie i innym współpracownikom łatwe debugowanie problemów i ulepszanie aplikacji.

Możesz łatwo zorganizować swoją aplikację w ten sposób:

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

Prawdopodobnie najlepszym sposobem nauczenia się struktury programu jest czytanie kodu innych osób, zwłaszcza jeśli jest to duży program, w którego tworzeniu uczestniczyło wiele osób. Po przyjrzeniu się kodowi wielu projektów powinieneś zorientować się, jaki powinien być styl konsensusu.

Python jako język wyróżnia się tym, że istnieją pewne silne wytyczne dotyczące formatowania kodu. Pierwszy to tak zwany „Zen Pythona”:

• Piękne jest lepsze niż brzydkie.
• Jawne jest lepsze niż niejawne.
• Proste jest lepsze niż złożone.
• Złożoność jest lepsza niż skomplikowana.
• Płaskie jest lepsze niż zagnieżdżone.
• Rzadkie jest lepsze niż gęste.
• Liczy się czytelność.
• Specjalne przypadki nie są na tyle wyjątkowe, aby łamać zasady.
• Chociaż praktyczność przewyższa czystość.
• Błędy nigdy nie powinny przejść bezgłośnie.
• Chyba że wyraźnie uciszono.
• W obliczu niejasności odrzuć pokusę zgadywania.
• Powinien być jeden - a najlepiej tylko jeden - oczywisty sposób na zrobienie tego.
• Chociaż na początku może to nie być oczywiste, chyba że jesteś Holendrem.
• Teraz jest lepiej niż nigdy.
• Chociaż nigdy nie jest często lepsze niż prawo teraz.
• Jeśli implementacja jest trudna do wyjaśnienia, to zły pomysł.
• Jeśli implementacja jest łatwa do wyjaśnienia, może to być dobry pomysł.
• Przestrzenie nazw to świetny pomysł - zróbmy ich więcej!

Na bardziej praktycznym poziomie jest PEP8 , przewodnik po stylu dla Pythona.

Mając to na uwadze, powiedziałbym, że twój styl kodu nie pasuje, szczególnie funkcje zagnieżdżone. Znajdź sposób na ich spłaszczenie, używając klas lub przenosząc je do oddzielnych modułów. Dzięki temu struktura programu będzie znacznie łatwiejsza do zrozumienia.

Osobiście nie stosuję podejścia zorientowanego obiektowo, głównie dlatego, że a) tylko przeszkadza; b) nigdy nie użyjesz tego ponownie jako modułu.

ale coś, co nie jest tutaj omawiane, to fakt, że musisz używać wątków lub przetwarzania wieloprocesowego. Zawsze. inaczej twoja aplikacja będzie okropna.

po prostu zrób prosty test: uruchom okno, a następnie pobierz jakiś adres URL lub cokolwiek innego. zmiany to twój interfejs użytkownika nie zostanie zaktualizowany, gdy trwa żądanie sieciowe. Oznacza to, że okno aplikacji zostanie zepsute. zależy od używanego systemu operacyjnego, ale w większości przypadków nie będzie przerysowywany, wszystko, co przeciągniesz przez okno, zostanie na nim otynkowane, dopóki proces nie powróci do głównej pętli TK.