Question

So I can do a little C++ console stuff with classes (nothing too fancy I think) and just started with Python (awesome language, it’s like C++ without worries) and Tkinter.

The thing is that I don’t really have a clue how in general a program with a GUI is structured. I know you have to separate the interface from the internal workings, but that’s about it. As an example I am working on a small app that converts Excel tables to LaTeX tables and so far I have this:

from Tkinter import *

class ExcelToLateX:
    def __init__(self,master):
        self.convert = Button(master,text="Convert",command=self.Conversion)
        self.convert.pack(side=BOTTOM,fill=X)
        self.input=Input(master,40)
        self.output=Output(master,40)
    def Conversion(self):
        self.output.Write(self.input.Read())


class Input:
    def __init__(self,master,x):
        self.u=Text(master,width=x)
        self.u.pack(side=LEFT)
        self.u.insert(1.0,"Paste Excel data here...")

    def Read(self):
        return self.u.get(1.0,END)


class Output:
    def __init__(self,master,x):
        self.v=Text(master,width=x)
        self.v.pack(side=RIGHT)
        self.v.insert(1.0,"LaTeX code")
    def Write (self,input):
        self.input=input
        if self.v.get(1.0,END)=="":
            self.v.insert(1.0,self.input)
        else:
            self.v.delete(1.0,END)
            self.v.insert(1.0,self.input)

#Test script
root=Tk()
Window=ExcelToLateX(root)
root.mainloop()

So I have two Text widgets that can read and write stuff and a (for now) empty conversion class that will take Excel tables and spew out LaTeX code. I have no idea if this is the way to go (so any comments/tips are appreciated).

So in short I have two questions:

• Are there any widely acknowledged sources that provide information on how a program with a GUI is structured? (preferably Python and Tkinter because that’s what I’m doing right know, although it may be a bit more general (cross-language))

• Is my current application any good when it comes to structure, and if not, what are some rules of thumb and things I can improve?

Answer 1

I’m just going to throw a couple short comments into the hat. I don’t have experience with Tkinter, so my knowledge derives from PyQt4 experience.

Right now you are using composition for your classes, by making the single widget a member attribute. This can obviously work but a useful pattern is to subclass a GUI widget, and then compose the layout by adding more child widgets and parenting to that class. See the examples on this random Tkinter tutorial link I found: http://zetcode.com/tutorials/tkintertutorial/

class Example(Frame):
    def __init__(self, parent):
        super(Example, self).__init__(parent)
        ...

And just as a general python convention, you should try and stick with capitalization for your class names, and camelCase or under_score for class instance methods and variables. As you have it, you are using capital for instances (Window =) and methods (Write)

Also, if you aren’t going to be subclassing Tkinter widgets, make sure to at least use the new-style classes by subclassing from object: http://realmike.org/blog/2010/07/18/introduction-to-new-style-classes-in-python/

You might also want to nest that last part of your code where you run the event loop inside of the classic python idiom:

if __name__ == "__main__":
    root=Tk()
    window = ExcelToLateX(root)
    root.mainloop()

It prevents your app from immediately being executed if you were to import this module into another application as a library.