Credit: Fredrik Lundh, SecretLabs AB (PythonWare), author of Python Standard Library
Back in the early days of interactive computing, most computers offered terminals that looked and behaved pretty much like clunky typewriters. The main difference from an ordinary typewriter was that the computer was in the loop. It could read what the user typed and print hardcopy output on a roll of paper.
So when you found yourself in front of a 1960s Teletype ASR-33, the only reasonable way to communicate with the computer was to type a line of text, press the send key, hope that the computer would manage to figure out what you meant, and wait for the response to appear on the paper roll. This line-oriented way of communicating with your computer is known as a command-line interface (CLI).
Some 40 years later, the paper roll has been replaced with high-resolution video displays, which can display text in multiple typefaces, color photographs, and even animated 3D graphics. The keyboard is still around, but we also have pointing devices such as the mouse, trackballs, game controls, touchpads, and other input devices.
The combination of a graphics display and the mouse made it possible to create a new kind of user interface: the graphical user interface (GUI). When done right, a GUI can give the user a better overview of what a program can do (and what it is doing), and make it easier to carry out many kinds of tasks.
However, most programming languages, including Python, make it easy
to write programs using teletype-style output and input. In Python,
you use the
raw_input functions to read expressions and text
strings from the keyboard.
Creating graphical user interfaces takes more work. You need access to functions to draw text and graphics on the screen, select typefaces and styles, and read information from the keyboard and other input devices. You need to write code to interact with other applications (via a window manager), keep your windows updated when the user moves them around, and respond to key presses and mouse actions.
To make this a bit easier, programmers have developed
graphical user interface toolkits, which provide standard solutions
to these problems. A typical GUI toolkit provides a number of
ready-made GUI building blocks, usually called
Common standard widgets include text and image labels, buttons, and
text-entry fields. Many toolkits also provide more advanced widgets,
such as Tkinter’s
which is a rather competent text editor/display component.
All major toolkits are event-based. This means that your program hands control over to the toolkit (usually by calling a main loop function or method). The toolkit then calls back into your application when certain events occur—for example, when the user clicks OK in a dialog, when a window needs to be redrawn, and so on. Most toolkits also provide ways to position widgets on the screen automatically (e.g., in tables, rows, or columns) and to modify widget behavior and appearance.
is the de-facto standard toolkit for
and comes with most Python distributions. Tkinter provides an
object-oriented layer on top of the Tcl/Tk GUI library and runs on
Windows, Unix, and Macintosh systems. Tkinter is easy to use but
provides a relatively small number of standard widgets. Tkinter
extension libraries, such as
Tix, supply many
components missing from plain Tkinter, and you can use
Canvas widgets to
create custom widgets. The Widget Construction Kit lets you write all
sorts of new widgets in pure Python and is available as part of the
and also as part of Tkinter 3000 (http://effbot.org/tkinter/), which is
currently in the alpha stage.
wxPython (http://www.wxPython.org) is another popular toolkit; it is based on the wxWindows C++ library (http://www.wxWindows.org). wxPython is modeled somewhat after the Windows MFC library but is available for multiple platforms. wxPython provides a rich set of widgets, and it’s relatively easy to create custom widgets.
PyGTK (http://www.daa.com.au/~james/pygtk) is an object-oriented Python interface to the GTK toolkit, used in projects such as Gnome and the Gimp. This is a good choice for Linux applications, especially if you want them to run in the Gnome environment.
PyQt (http://www.riverbankcomputing.co.uk/pyqt/index.php) is a Python wrapper for TrollTech’s Qt library (http://www.trolltech.com), which is the basis of the popular KDE environment, as well as the Qtopia environment for handheld computers; it also runs on Windows and Mac OS/X. Qt requires license fees for commercial (non-free software) use but is free for free software development; PyQt itself is always free.
You can also use many other toolkits from Python. Mark Hammond’s PythonWin gives access to Windows MFC. There are also interfaces to Motif/X11 and MacIntosh native toolboxes, and many other toolkits. Cameron Laird maintains a list of toolkits at http://starbase.neosoft.com/~claird/comp.lang.python/python_GUI.html. It currently lists about 20 toolkits.
Finally, the anygui project (http://www.anygui.org) is working on a unified
Python API for the above toolkits (and others, including
Java’s Swing toolkit, which is used with the Jython
version of Python, and text screens driven with, or even without, the
curses library). The new unified API is
implemented by a shared front-end layer and small, specific backends
sitting on top of the many existing libraries.