Najlepszy sposób na uporządkowanie aplikacji tkinter [zamknięty]

Umieszczenie każdego okna najwyższego poziomu w osobnej klasie daje ponowne użycie kodu i lepszą organizację kodu. Wszystkie przyciski i odpowiednie metody obecne w oknie powinny być zdefiniowane wewnątrz tej klasy. Oto przykład (zaczerpnięty z Tutaj):

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 też:

• simple hello world od tkinter docs
• Tkinter przykładowy kod dla wielu okien, dlaczego przyciski nie ładują się poprawnie?
• Tkinter: jak Pokaż / Ukryj okno

Oto doskonały samouczek na temat projektowania graficznego tkinter, z kilkoma przykładami -- http://python-textbok.readthedocs.org/en/latest/Introduction_to_GUI_Programming.html

Oto kolejny przykład z wzorcem projektowym MVC -- https://sukhbinder.wordpress.com/2014/12/25/an-example-of-model-view-controller-design-pattern-with-tkinter-python/

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

Więc co można zrobić, to napisać klasy dla tych, a następnie mają metody w klasie, które obsługują polecenia dla kliknięć przycisków i takie.

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 = Demo1(root)
    root.mainloop()

if __name__ == '__main__':
    main()

Zwykle programy tk z wieloma oknami to wiele dużych klas i w __init__ tworzone są wszystkie wpisy, etykiety itp., a następnie każda metoda obsługuje zdarzenia kliknięcia przycisku

Tak naprawdę nie ma właściwego sposobu, aby to zrobić, cokolwiek działa dla Ciebie i wykonuje zadanie tak długo, jak jest czytelne i możesz łatwo to wyjaśnić, ponieważ jeśli nie możesz łatwo wyjaśnić swojego programu, prawdopodobnie jest lepszy sposób, aby to zrobić.

Spójrz na myślenie w Tkinter.

OOP powinno być podejściem, a frame powinno być zmienną klasy zamiast zmiennej 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()

Numer referencyjny: http://www.python-course.eu/tkinter_buttons.php

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

Python, jako język, jest wyjątkowy, ponieważ istnieją pewne silne wytyczne, jak sformatować kod. Pierwszy to tzw. "Zen Pythona":

Piękne jest lepsze niż brzydki.
• Explicit jest lepszy niż implicit.
• proste jest lepsze niż złożone.
Kompleks jest lepszy niż skomplikowany.
• Płaskie jest lepsze niż zagnieżdżone.
Sparse jest lepsze niż gęste.
• liczy się czytelność.
• specjalne przypadki nie są wystarczająco specjalne, aby złamać zasady.
Chociaż praktyczność bije czystość.
• błędy nigdy nie powinny mijać po cichu.
• chyba, że wyraźnie wyciszono.
• W obliczu dwuznaczność, Odrzuć pokusę zgadywania.
Powinien być jeden, a najlepiej tylko jeden, oczywisty sposób. Chociaż ten sposób może nie być oczywisty na początku, chyba że jesteś Holendrem. Teraz jest lepiej niż nigdy.
• chociaż nigdy nie jest często lepiej 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 są jedną świetny pomysł. zróbmy więcej takich!

Na bardziej praktycznym poziomie znajduje się PEP8 , przewodnik po stylach dla Pythona.

Mając to na uwadze, powiedziałbym, że Twój styl kodu nie pasuje, szczególnie do zagnieżdżonych funkcji. Znajdź sposób, aby je spłaścić, używając klas lub przenosząc je do oddzielnych modułów. Dzięki temu struktura Twojego programu będzie znacznie łatwiejsza do zrozumienia.

Ja osobiście nie używam podejścia zorientowanego na sprzeciw, głównie dlatego, że a) tylko przeszkadza; b) nigdy nie wykorzystasz tego jako modułu.

Ale coś, co nie jest tutaj omawiane, to to, że Musisz używać wątków lub przetwarzania wieloprocesorowego. Zawsze. w przeciwnym razie Twoja aplikacja będzie okropna.

Po prostu wykonaj prosty test: Uruchom okno, a następnie pobierz jakiś adres URL lub cokolwiek innego. zmiany oznaczają, że interfejs użytkownika nie będzie aktualizowany podczas żądania sieciowego. Oznacza to, że okno aplikacji zostanie złamane. zależy od systemu operacyjnego, na którym się znajdujesz, ale najczęściej nie będzie przerysowywany, wszystko, co przeciągniesz przez okno, będzie na nim tynkowane, dopóki proces nie wróci do mainloop TK.