Cách tốt nhất để cấu trúc một ứng dụng tkinter?

Sau đây là cấu trúc tổng thể của chương trình tkinter python điển hình của tôi.

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 funBvà funCsẽ hiển thị một Toplevelcửa sổ khác với các widget khi người dùng nhấp vào nút 1, 2, 3.

Tôi tự hỏi nếu đây là cách đúng để viết một chương trình tkinter python? Chắc chắn, nó sẽ hoạt động ngay cả khi tôi viết theo cách này, nhưng nó có phải là cách tốt nhất? Nghe có vẻ ngu ngốc nhưng khi tôi nhìn thấy mã người khác viết, mã của họ không bị rối với hàng loạt hàm và chủ yếu là họ có các lớp.

Có bất kỳ cấu trúc cụ thể mà chúng ta nên làm theo như thực hành tốt? Làm thế nào tôi nên lập kế hoạch trước khi bắt đầu viết một chương trình python?

Tôi biết không có thứ gì là thực hành tốt nhất trong lập trình và tôi cũng không yêu cầu nó. Tôi chỉ muốn một số lời khuyên và giải thích để giữ cho tôi đi đúng hướng khi tôi đang học Python một mình.

Tôi ủng hộ một cách tiếp cận hướng đối tượng. Đây là mẫu mà tôi bắt đầu với:

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

Những điều quan trọng cần chú ý là:

• Tôi không sử dụng nhập ký tự đại diện. Tôi nhập gói dưới dạng "tk", yêu cầu tôi phải thêm tiền tố vào tất cả các lệnh tk.. Điều này ngăn ngừa ô nhiễm không gian tên toàn cầu, cộng với nó làm cho mã hoàn toàn rõ ràng khi bạn đang sử dụng các lớp Tkinter, các lớp ttk hoặc một số của riêng bạn.

• Ứng dụng chính là một lớp học . Điều này cung cấp cho bạn một không gian tên riêng cho tất cả các cuộc gọi lại và các chức năng riêng tư của bạn và nói chung chỉ giúp việc tổ chức mã của bạn dễ dàng hơn. Trong một kiểu thủ tục, bạn phải viết mã từ trên xuống, xác định các hàm trước khi sử dụng chúng, v.v. Với phương pháp này, bạn không thực sự tạo ra cửa sổ chính cho đến bước cuối cùng. Tôi thích kế thừa từ tk.Framechỉ vì tôi thường bắt đầu bằng cách tạo khung, nhưng nó không có nghĩa là cần thiết.

Nếu ứng dụng của bạn có thêm các cửa sổ toplevel, tôi khuyên bạn nên tạo cho mỗi lớp một lớp riêng biệt, kế thừa từ đó tk.Toplevel. Điều này cung cấp cho bạn tất cả các lợi thế tương tự được đề cập ở trên - các cửa sổ là nguyên tử, chúng có không gian tên riêng và mã được tổ chức tốt. Thêm vào đó, nó giúp bạn dễ dàng đặt từng cái vào mô-đun của riêng mình một khi mã bắt đầu lớn.

Cuối cùng, bạn có thể muốn xem xét sử dụng các lớp cho mọi phần chính của giao diện của bạn. Ví dụ: nếu bạn đang tạo một ứng dụng bằng thanh công cụ, ngăn điều hướng, thanh trạng thái và khu vực chính, bạn có thể tạo từng ứng dụng trong số các lớp đó. Điều này làm cho mã chính của bạn khá nhỏ và dễ hiểu:

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)

Vì tất cả các trường hợp đó có chung một cha mẹ, nên cha mẹ thực sự trở thành một phần "bộ điều khiển" của kiến ​​trúc mô hình-khung nhìn-bộ điều khiển. Vì vậy, ví dụ, cửa sổ chính có thể đặt một cái gì đó trên thanh trạng thái bằng cách gọi self.parent.statusbar.set("Hello, world"). Điều này cho phép bạn xác định một giao diện đơn giản giữa các thành phần, giúp duy trì khớp nối đến mức tối thiểu.

Việc đặt từng cửa sổ cấp cao nhất của bạn vào lớp riêng của nó sẽ giúp bạn sử dụng lại mã và tổ chức mã tốt hơn. Bất kỳ nút và phương thức liên quan nào có trong cửa sổ nên được xác định bên trong lớp này. Đây là một ví dụ (lấy từ đây ):

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

Cũng thấy:

• thế giới xin chào đơn giản từ tài liệu tkinter
• Mã ví dụ Tkinter cho nhiều cửa sổ, tại sao các nút không tải chính xác?
• Tkinter: Cách hiển thị / Ẩn cửa sổ

Mong rằng sẽ giúp.

Đây không phải là một cấu trúc xấu; Nó sẽ chỉ làm việc tốt. Tuy nhiên, bạn phải có chức năng trong một chức năng để thực hiện các lệnh khi ai đó nhấp vào nút hoặc một cái gì đó

Vì vậy, những gì bạn có thể làm là viết các lớp cho những cái này sau đó có các phương thức trong lớp xử lý các lệnh cho các lần nhấp nút và như vậy.

Đây là một ví dụ:

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

Thông thường các chương trình tk có nhiều cửa sổ là nhiều lớp lớn và trong __init__ tất cả các mục, nhãn, v.v ... được tạo và sau đó mỗi phương thức là xử lý các sự kiện nhấn nút

Thực sự không phải là một cách đúng đắn để làm điều đó, bất cứ điều gì phù hợp với bạn và hoàn thành công việc miễn là nó có thể đọc được và bạn có thể dễ dàng giải thích nó bởi vì nếu bạn không thể dễ dàng giải thích chương trình của mình, có lẽ có cách tốt hơn để làm điều đó .

Hãy xem Thinking in Tkinter .

OOP nên là cách tiếp cận và framenên là một biến lớp thay vì biến thể hiện .

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

Tham khảo: http://www.python-cference.eu/tkinter_buttons.php

Tổ chức ứng dụng của bạn bằng cách sử dụng lớp giúp bạn và những người khác làm việc với bạn dễ dàng gỡ lỗi và cải thiện ứng dụng một cách dễ dàng.

Bạn có thể dễ dàng sắp xếp ứng dụng của mình như thế này:

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

Có lẽ cách tốt nhất để tìm hiểu cách cấu trúc chương trình của bạn là đọc mã của người khác, đặc biệt nếu đó là một chương trình lớn mà nhiều người đã đóng góp. Sau khi xem mã của nhiều dự án, bạn sẽ có được một ý tưởng về phong cách đồng thuận nên là gì.

Python, như một ngôn ngữ, đặc biệt ở chỗ có một số hướng dẫn mạnh mẽ về cách bạn nên định dạng mã của mình. Đầu tiên là cái gọi là "Zen of Python":

• Đẹp thì tốt hơn xấu.
• Rõ ràng là tốt hơn so với ngầm.
• Đơn giản là tốt hơn phức tạp.
• Phức tạp tốt hơn phức tạp.
• Bằng phẳng là tốt hơn so với lồng nhau.
• Thưa thì tốt hơn dày đặc.
• Tính dễ đọc.
• Trường hợp đặc biệt không đủ đặc biệt để phá vỡ các quy tắc.
• Mặc dù thực tế đánh bại sự tinh khiết.
• Lỗi không bao giờ nên âm thầm vượt qua.
• Trừ khi im lặng rõ ràng.
• Trước sự mơ hồ, hãy từ chối sự cám dỗ để đoán.
• Nên có một-- và tốt nhất là chỉ có một cách rõ ràng để làm điều đó.
• Mặc dù cách đó ban đầu có thể không rõ ràng trừ khi bạn là người Hà Lan.
• Bây giờ tốt hơn bao giờ hết.
• Mặc dù không bao giờ thường tốt hơn đúng bây giờ.
• Nếu việc thực hiện khó giải thích, đó là một ý tưởng tồi.
• Nếu việc thực hiện dễ giải thích, nó có thể là một ý tưởng tốt.
• Không gian tên là một ý tưởng tuyệt vời - hãy làm nhiều hơn nữa!

Ở cấp độ thực tế hơn, có PEP8 , hướng dẫn phong cách cho Python.

Với những người trong tâm trí, tôi sẽ nói rằng kiểu mã của bạn không thực sự phù hợp, đặc biệt là các hàm lồng nhau. Tìm cách làm phẳng chúng ra, bằng cách sử dụng các lớp hoặc chuyển chúng thành các mô-đun riêng biệt. Điều này sẽ làm cho cấu trúc chương trình của bạn dễ hiểu hơn nhiều.

Cá nhân tôi không sử dụng cách tiếp cận hướng đối tượng, chủ yếu là vì nó a) chỉ cản trở; b) bạn sẽ không bao giờ sử dụng lại như là một mô-đun.

nhưng một điều không được thảo luận ở đây, là bạn phải sử dụng luồng hoặc đa xử lý. Luôn luôn. nếu không ứng dụng của bạn sẽ là khủng khiếp.

chỉ cần làm một bài kiểm tra đơn giản: bắt đầu một cửa sổ, sau đó tìm nạp một số URL hoặc bất cứ thứ gì khác. thay đổi là UI của bạn sẽ không được cập nhật trong khi yêu cầu mạng đang diễn ra. Có nghĩa, cửa sổ ứng dụng của bạn sẽ bị hỏng. phụ thuộc vào hệ điều hành bạn đang sử dụng, nhưng hầu hết các lần, nó sẽ không vẽ lại, bất cứ thứ gì bạn kéo qua cửa sổ sẽ được dán trên nó, cho đến khi quá trình quay trở lại mainloop TK.