在tkinter中制作窗口的哪种方式更好？

Question

I have seen two different tutorials on making a basic window using Tkinter. One of the tutorials uses a class with functions to initialize and assemble the window. In the other tutorial, they just made a window without using classes or functions.

Just to be clear, I'm NOT talking about what the windows do per se . I'm just wondering which method is better to implement Tkinter.

Here's the code for both if that explanation doesn't make sense.

Here's the code for both if that explanation doesn't make sense.

CODE #1 uses classes

from tkinter import *

class Window(Frame):

    def __init__(self, master=NONE):

        Frame.__init__(self, master)
        self.master = master

        self.init_window()

    def init_window(self):

        self.master.title("GUI")  #

        self.pack(fill = BOTH, expand=1)

        # We created a button below to see how to do it but commented it out for now.
        '''closeButton = Button(self, text='Close', command=self.client_exit)  # Making a new button called closeButton.

        closeButton.place(x=0, y=0)  # Places the button at given co-ordinates. (0,0) is top left. This isn't cartesian.'''

        menuBar = Menu(self.master)
        self.master.config(menu=menuBar)

        file = Menu(menuBar)
        file.add_command(label = 'Exit', command = self.client_exit)
        menuBar.add_cascade(label = 'File', menu=file)

        edit = Menu(menuBar)
        edit.add_command(label = 'Show Image', command = self.showImg)
        edit.add_command(label = 'Show Text', command = self.showTxt)
        menuBar.add_cascade(label = 'Edit', menu=edit)

    def showImg(self):
        load = Image.open('CatPic.jpg')
        render = ImageTk.PhotoImage(load)
        catImage = Label(self, image=render)
        catImage.image = render
        catImage.place(x=250, y=250)

    def showTxt(self):
        writeText = Label(self, text = "Hi I'm Temmie")
        writeText.pack()



root = Tk()  # Tk() is a function within Tkinter. 'root' is the name of our Frame.
root.geometry("500x500")  # Defines size of 'root'.
root.mainloop()

app = Window(root)  # Finally, we use the Window class to make a window under the name 'app'.

CODE #2 uses no such concept

from tkinter import *
root=Tk()


topFrame = Frame(root)
topFrame.pack()
bottomFrame = Frame(root)
bottomFrame.pack(side=BOTTOM)

button1=Button(topFrame, text="Button 1", fg="red") #fg foreground is optional
button2=Button(topFrame, text="Button 2", fg="blue") #fg is optional
button3=Button(topFrame, text="Button 3", fg="green") #fg is optional
button4=Button(bottomFrame, text="Button 4", fg="black") #fg is optional

button1.pack(side=LEFT,fill=X)
button2.pack(side=LEFT)
button3.pack(side=LEFT)
button4.pack(side=BOTTOM)

root.mainloop()

Answer 1

It depends only on you.

---

For small examples I use mostly only functions - it is faster to write.
And beginners will understand it - they mostly don't know classes.

For something bigger I use classes - it makes code cleaner for me.

But I do this way not only in Tkinter but also in other modules - like PyGame.

Answer 2

Both pieces of code are doing basically the same stuff under the hood. The first piece takes the Frame as a base class and extends it with the default parameters and methods so that it can be used multiple times for a window that you like. So the first piece of code is how a normal OOP project would use tKinter so that one can basically modify everything and plug their own code whereever they feel that tKinter is lacking or misguided. At the same time all the modifications are easily usable for other projects (or other windows) and if you start working on another project that has all the same prerequisites, then you can just take your Window class and get cracking.

On the other hand the simpler solution takes advantage of all that tTkinter offers out of the box which means you can generate lots of customizable content with a few lines of code, using all tKinter settings, parameters and so on. The second solution is not so easily reusable and if you want certain parts of it, you can't just take the whole class definition, but have to pick out the lines that modify your window. Also when you get into a situation where you have to override tKinter stuff, you need to create your own Window class anyways. But then again, in most simpler projects that doesn't happen (I've written to projects using tKinter, both of them about 1500 lines, and neither of them required overriding the Frame class).

So TL;DR:
If you're an experienced OOP developer that has used all kinds of frameworks etc. beforehand, I would go for the first solution that overrides the Frame class.
If - as it seems from the question - you're a beginner who wants to get going and see a result instead of hassling with OOP quirks and other arguably unnecessary stuff for a simple project, I'd go for the second and lighter version.

PS! One should never use from somepackage import * because of name clashes, tracking imports in files and so on. Instead it is recommended to use just import tkinter and then you can access all of tKinter's stuff as tkinter.Frame , tkinter.Button etc. Also a good way is to import tKinter as import tkinter as tk , then you can use it as tk.Frame , tk.Button etc and all in all you have to write less. If you only want to use, say one or two components from a package, then you'd usually import them as from tkinter import Button, Frame and then use them just as Button and Frame . Hope this helps.