python - 构建 tkinter 应用程序的最佳方式？

Question

以下是我典型的python tkinter程序的整体结构。

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 funB当用户单击按钮 1、2、3 时，将弹出另一个带有小部件的 窗口funC。Toplevel

我想知道这是否是编写 python tkinter 程序的正确方法？当然，即使我这样写也可以，但这是最好的方式吗？这听起来很愚蠢，但是当我看到其他人编写的代码时，他们的代码并没有被一堆函数弄乱，而且他们大多都有类。

有没有我们应该遵循的特定结构作为良好实践？在开始编写 python 程序之前我应该​​如何计划？

我知道编程中没有最佳实践这样的东西，我也没有要求它。我只是想要一些建议和解释，以使我在自己学习 Python 时保持正确的方向。

Answer 1

我提倡一种面向对象的方法。这是我开始使用的模板：

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

需要注意的重要事项是：

• 我不使用通配符导入。我将包导入为“tk”，这要求我在所有命令前加上tk.. 这可以防止全局命名空间污染，此外，当您使用 Tkinter 类、ttk 类或您自己的某些类时，它会使代码完全显而易见。

• 主要应用程序是一个类。这为您的所有回调和私有函数提供了一个私有命名空间，并且通常使您更容易组织您的代码。在程序样式中，您必须自上而下编写代码，在使用函数之前定义函数等。使用这种方法，您不需要，因为直到最后一步您才真正创建主窗口。我更喜欢继承 fromtk.Frame只是因为我通常从创建一个框架开始，但这绝不是必要的。

如果您的应用程序有额外的顶级窗口，我建议将它们中的每一个都设为一个单独的类，继承自tk.Toplevel. 这为您提供了上面提到的所有相同优势——窗口是原子的，它们有自己的命名空间，并且代码组织良好。此外，一旦代码开始变大，就可以轻松地将每个模块放入自己的模块中。

最后，您可能需要考虑为界面的每个主要部分使用类。例如，如果您正在创建一个带有工具栏、导航窗格、状态栏和主区域的应用程序，您可以创建这些类中的每一个。这使您的主要代码非常小且易于理解：

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)

由于所有这些实例共享一个共同的父级，因此父级实际上成为模型-视图-控制器架构的“控制器”部分。因此，例如，主窗口可以通过调用self.parent.statusbar.set("Hello, world"). 这允许您在组件之间定义一个简单的接口，有助于保持最小的耦合。

Answer 2

将每个顶级窗口放入它自己的单独类中，可以让您重用代码并更好地组织代码。窗口中存在的任何按钮和相关方法都应在此类中定义。这是一个示例（取自此处）：

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

另见：

• 来自 tkinter 文档的简单的 hello world
• 用于多个窗口的 Tkinter 示例代码，为什么按钮无法正确加载？
• Tkinter：如何显示/隐藏窗口

希望有帮助。

Answer 3

这不是一个糟糕的结构。它会工作得很好。但是，当有人单击按钮或其他东西时，您必须在函数中具有执行命令的函数

因此，您可以做的是为这些编写类，然后在类中具有处理按钮单击等命令的方法。

这是一个例子：

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

通常具有多个窗口的 tk 程序是多个大类，并且在__init__所有条目中创建标签等，然后每个方法都是处理按钮单击事件

没有真正正确的方法可以做到这一点，只要它可读并且您可以轻松解释它，无论对您有用并完成工作，因为如果您不能轻松解释您的程序，可能有更好的方法来做到这一点.

看看Thinking in Tkinter。

Answer 4

OOP 应该是方法，frame应该是类变量而不是实例变量。

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

参考： http: //www.python-course.eu/tkinter_buttons.php

Answer 5

我喜欢的做法就像 Bryan Oakley 的回答。这是一个由 Sentdex 在 Youtube 上制作的示例，请查看他的“GUIs with Tkinter”播放列表。

我认为把它放在这里真的很重要，因为它是 OP 的一个很好的例子，所以它也回答了这个被 35 人提出但没有得到回答的答案；

@Bryan Oakley 你知道互联网上有什么好的示例代码可以研究它们的结构吗？– Chris Aung 2013 年 7 月 5 日在 8:35

import tkinter as tk

LARGE_FONT= ("Verdana", 12)

class SeaofBTCapp(tk.Tk):
    """
    tkinter example app with OOP
    """

    def __init__(self, *args, **kwargs):
        
        tk.Tk.__init__(self, *args, **kwargs)
        container = tk.Frame(self)

        container.pack(side="top", fill="both", expand = True)

        container.grid_rowconfigure(0, weight=1)
        container.grid_columnconfigure(0, weight=1)

        self.frames = {}

        for frame_class in (StartPage,PageOne, PageTwo):

            frame = frame_class(container, self)

            self.frames[frame_class] = frame

            frame.grid(row=0, column=0, sticky="nsew")
    

        self.show_frame(StartPage)

    def show_frame(self, cont):
        """
        Put specific frame on top
        """

        frame = self.frames[cont]
        frame.tkraise()

        
class StartPage(tk.Frame):
    """
    Starting frame for app
    """

    def __init__(self, parent, controller):
        tk.Frame.__init__(self,parent,bg='grey')
        label = tk.Label(self, text="Start Page", font=LARGE_FONT)
        label.pack(pady=10,padx=10)

        button_page1 = tk.Button(self, text = 'Visit Page 1', command= lambda: controller.show_frame(PageOne))
        button_page1.pack()

        button_page2 = tk.Button(self, text = 'Visit Page 2', command= lambda: controller.show_frame(PageTwo))
        button_page2.pack()

class PageOne(tk.Frame):
    """
    First page of program
    """

    def __init__(self,parent,controller):
        tk.Frame.__init__(self,parent,bg='light blue')
        label = tk.Label(self, text="Page one", font=LARGE_FONT)
        label.pack(pady=10,padx=10)

        button_home = tk.Button(self, text = 'Back to Home', command= lambda: controller.show_frame(StartPage))
        button_home.pack()

        button_home = tk.Button(self, text = 'Go to page2', command= lambda: controller.show_frame(PageTwo))
        button_home.pack()

class PageTwo(tk.Frame):
    """
    First page of program
    """

    def __init__(self,parent,controller):
        tk.Frame.__init__(self,parent,bg='light green')
        label = tk.Label(self, text="Page two", font=LARGE_FONT)
        label.pack(pady=10,padx=10)

        button_home = tk.Button(self, text = 'Back to Home', command= lambda: controller.show_frame(StartPage))
        button_home.pack()

        button_home = tk.Button(self, text = 'Go to page1', command= lambda: controller.show_frame(PageOne))
        button_home.pack()




app = SeaofBTCapp()
app.mainloop()

在这里也可以找到代码：[https://pythonprogramming.net/change-show-new-frame-tkinter/]

Answer 6

使用类组织您的应用程序使您和与您一起工作的其他人可以轻松地调试问题并轻松改进应用程序。

您可以像这样轻松地组织您的应用程序：

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

Answer 7

可能学习如何构建程序的最好方法是阅读其他人的代码，尤其是当它是一个有很多人贡献的大型程序时。看了很多项目的代码后，你应该对共识风格应该有一个概念。

Python 作为一门语言的特殊之处在于，对于如何格式化代码有一些强有力的指导方针。首先是所谓的“Python之禅”：

• 美丽总比丑陋好。
• 显式优于隐式。
• 简单胜于复杂。
• 复杂胜于复杂。
• 平面优于嵌套。
• 稀疏比密集好。
• 可读性很重要。
• 特殊情况不足以打破规则。
• 虽然实用胜过纯洁。
• 错误永远不应该悄无声息地过去。
• 除非明确沉默。
• 面对模棱两可，拒绝猜测的诱惑。
• 应该有一种——最好只有一种——明显的方法来做到这一点。
• 虽然这种方式一开始可能并不明显，除非你是荷兰人。
• 现在总比没有好。
• 虽然从来没有比现在更好。
• 如果实现很难解释，那是个坏主意。
• 如果实现很容易解释，那可能是个好主意。
• 命名空间是一个很棒的想法——让我们做更多的事情！

在更实用的层面上，有PEP8，Python 的样式指南。

考虑到这些，我会说您的代码风格并不真正适合，尤其是嵌套函数。通过使用类或将它们移动到单独的模块中，找到一种将它们展平的方法。这将使您的程序结构更容易理解。

Answer 8

我个人不使用面向对象的方法，主要是因为它 a) 只会碍事；b）您永远不会将其作为模块重用。

但这里没有讨论的是，您必须使用线程或多处理。总是。否则你的应用程序会很糟糕。

只需做一个简单的测试：启动一个窗口，然后获取一些 URL 或其他任何内容。更改是您的 UI 在网络请求发生时不会更新。这意味着，您的应用程序窗口将被破坏。取决于您所在的操作系统，但大多数情况下，它不会重绘，您在窗口上拖动的任何东西都会贴在上面，直到该过程返回到 TK 主循环。