Question

I know that Python’s Tk interface has some problems when using threads, and I’ve already run into problems with it. My idea is now to use a Queue.Queue to somehow pass events to the Tk mainloop, similarly to the following example.

from Tkinter import *
import Queue
import time

# this queue will be filled by other threads
queue = Queue.Queue()
queue.put("Helloooo!")
queue.put("hi there, everyone!")

class Application(Frame):
    def update(self):
        while True:
            try:
                text = queue.get(False)
                self.hi_there["text"] = text
                time.sleep(3)
            except Queue.Empty:
                self.quit()

    def create_widgets(self):
        self.hi_there = Label(self)
        self.hi_there["text"] = "Hello"

        self.hi_there.pack({"side": "left"})

    def __init__(self, master=None):
        Frame.__init__(self, master)
        self.pack()
        self.create_widgets()

root = Tk()
app = Application(master=root)
app.update()
app.mainloop()

Of course, I must not call update myself (this will execute everything before the UI is even shown) but need Tk to handle that during its mainloop.

Is there any foolproof way to accomplish that with Tk which will not break under certain circumstances? Or should I just resort to Qt for that?

Answer 1

As a general rule of thumb a GUI application should never, ever call sleep, should never have an infinite loop (except for the event loop), and you should never call ‘update’. The only exception to never calling update is that is is ok only when you truly understand why you should not.

Create a method that does two things: check the queue, and then use ‘after’ to call itself after some small period of time. Then, call this method once at the beginning of your program just before starting the event loop, after all other initialization has taken place.

For a working example of such a function, see How to create a timer using tkinter?