It's actually not being an interactive interpreter that matters here, but waiting for input on a TTY. You can get the same behavior from a script like this:
import tkinter
t = tkinter.Tk()
input()
(On Windows, you may have to run the script in pythonw.exe instead of python.exe, but otherwise, you don't have to do anything special.)
So, how does it work? Ultimately, the trick comes down to PyOS_InputHook
—the same way the readline
module works.
If stdin is a TTY, then, each time it tries to fetch a line with input()
, various bits of the code
module, the built-in REPL, etc., Python calls any installed PyOS_InputHook
instead of just reading from stdin.
It's probably easier to understand what readline
does: it tries to select
on stdin or similar, looping for each new character of input, or every 0.1 seconds, or every signal.
What Tkinter
does is similar. It's more complicated because it has to deal with Windows, but on *nix it's doing something pretty similar to readline
. Except that it's calling Tcl_DoOneEvent
each time through the loop.
And that's the key. Calling Tcl_DoOneEvent
repeatedly is exactly the same thing that mainloop
does.
(Threads make everything more complicated, of course, but let's assume you haven't created any background threads. In your real code, if you want to create background threads, you'll just have a thread for all the Tkinter
stuff that blocks on mainloop
anyway, right?)
So, as long as your Python code is spending most of its time blocked on TTY input (as the interactive interpreter usually is), the Tcl interpreter is chugging along and your GUI is responding. If you make the Python interpreter block on something other than TTY input, the Tcl interpreter is not running and the your GUI is not responding.
What if you wanted to do the same thing manually in pure Python code? You'd of need to do that if you want to, e.g., integrate a Tkinter GUI and a select
-based network client into a single-threaded app, right?
That's easy: Drive one loop from the other.
You can select
with a timeout of 0.02s (the same timeout the default input hook uses), and call t.dooneevent(Tkinter.DONT_WAIT)
each time through the loop.
Or, alternatively, you can let Tk drive by calling mainloop
, but use after
and friends to make sure you call select
often enough.