PyGTK, PyQT, Tkinter and wxPython comparison

Guilherme Polo
Python offers a multitude of GUI toolkits, much more than described here, for assisting on
development of graphical applications, and by having so many options available the
chances are you will be unable to make a good decision. A good decision would be one that
fulfill your requirements, and in order to achieve this it is necessary an understanding of
choices available.
If you are ust beginning GUI development, sometime you will need to select a toolkit and a
lot of questions will eventually pop up, so I e!pect this article to help you making a sane
decision. And if you already do GUI development and are considering learning another
toolkit, or maybe you are moving from another language to Python, I, again, e!pect this
te!t to help you choose your ne!t tool.
"riting about every possible point of comparison is not possible #maybe it would fit in a
book, a large one$, so I have chosen to talk about some topics that you may face in your
role as GUI developer. %ptions will be given, and you will balance them according to your
requirements.
&ach toolkit presented here has both strong and weak points, and it is, in fact, up to you to
decide which one fits your needs. All the four maor GUI toolkits available for Python are
discussed on this te!t' PyGtk
(
, Py)t
*
, +kinter, w!Python
,
.
Look and Feel
+he main task of a GUI developer is to build applications that are easy to use and, to
achieve that, they have to be designed to be familiar. -nowing your users is a big step
towards success, and this is not really easy to achieve, it involves research, e!perience,
dedication, effort, and goes on.... .ere follows a good paragraph that will remind you why it
is important to know your users, taken from /0esigning Interfaces, 1y 2enifer +idwell.
3hapter (' "hat Users 0o/'
It starts with an understanding of people: what they're like,
why they use a given piece of software, and how they might
interact with it. The more you know about them, and the more
you empathie with them, the more effectively you can design
for them. !oftware, after all, is merely a means to an end for
the people who use it. The better you satisfy those ends, the
happier those users will be.
As a developer it should be interesting to follow some guidelines to make it easier to
develop pleasant interfaces. 4amely there is the Gnome .IG
5
#.uman Interface Guidelines$
and Apple .IG
6
that are widely used. 1oth describes good design tips that you should use
while developing user interfaces, independent of what platform you are planning to focus
on.
If you are going to use any of the toolkits presented here, it is good to know that your
application will not look the same across platforms and may not feel the same. If you want
this kind of thing, you should be looking for 7ightweight GUI toolkits. +hey provide uniform
behavior on all platforms with the disadvantage of slower e!ecution.
1y now, I believe it is important to show some screen shots. +hey were taken in three
different platforms and should give an idea of how different your applications may look
( PyGtk site: http://www.pygtk.org/
* PyQt site: http://www.riverbankcomputing.co.uk/pyqt/
, wxPython site: http://www.wxpython.org/
5 Gnome HIG documentation: http://deveoper.gnome.org/pro!ects/gup/hig/
6 "ppe HIG documentation:
http://deveoper.appe.com/documentation/#ser$xperience/%onceptua/&'(HIGuideines/(HI
GIntro/chapter)*)section)*.htm
across platforms. +his is too a first chance to select which one is more likely to fit your
users.
Gnome *.*8
-0& 5 "indows 9P
PyGtk
Py)t
+kinter
w!Python
!ource code for shown applications are available at
http:""gpolo.ath.c#:$%"download"gravity&game. This game is a simplified version of 'The
Gravity Game', you can find the original source at book 'Physics for Game Programmers',
(hapter ) *in +ava,.
GUI Customiation
+he word /customi:ation/ can take different meanings according to the conte!t, so, for this
section, it;s meaning will be defined as' /capacity to modify default behavior of the widgets
contained within the toolkit, be these modifications beneficial or even harmful to users./
<aid that, be sure customi:ations are needed before doing them. =emember it is important
to keep your application familiar to the users, so there must be a really strong point to opt
for customi:ed look and feel. 1ut depending on the kind of program you are developing, it
may make sense to choose for this. >or e!ample, music and video players usually uses
custom interfaces, therefore it is possible you could want customi:ed look and feel too.
I classify customi:ations based on what they do' 3ompromising customi:ations, Pleasant
customi:ations and =untime customi:ations.
3ompromising customi:ations
=easoning for this naming' =emoves application;s familiarity.
+ypical changes' <haped widgets, changing widget colors, custom fonts.
Pleasant customi:ations
=easoning for this naming' Any toolkit should provide in order to be useful
and the user probably will feel better with these changes.
+ypical changes' Possibility to change the label position relative to an image
in a button, changing toolbar position, general changes that could be done to
widgets available so they fit better your proect.
=untime customi:ations
=easoning for this naming' 3ustomi:ations are done while the program is
running.
+ypical changes' "idget placement, applications;s appearance.
4ote that =untime customi:ations lists as typical change applications;s appearance, this
would fall in 3ompromising customi:ations. 1ut it was user;s choice to do it, and he
probably feels better with these changes, making it a good thing.
It is not interesting to discuss Pleasant customi:ations here since all toolkits presented
provide them. <ome of them supports more than others, mainly because they contain more
widgets thus allowing more possibilities of customi:ations.
7astly note that 3ompromising customi:ations may be useful too, they can help low vision
users #for e!ample$. <o they are not always dangerous or bad.
PyGtk customiation
3ompromising
+hemes are the way to go for large customi:ations under PyGtk. Users can
choose a new look for your application ust by setting a different theme
#requiring no code changes$.
PyGtk supports creation of shaped widgets.
=untime
It is possible to change themes easily while the application is running.
+here is no support for dock widgets, so the user cannot freely relayout his
applications. If you need this kind of customi:ation, there are wrappers for
G07 library which supports this functionality.
PyQt customiation
3ompromising
Py)t uses <tyles instead of +hemes to achieve large customi:ations.
+his toolkit also supports creation of shaped widgets.
=untime
7ike in PyGtk, it is pretty easy to change styles while the application is
running.
Py)t contains a widget called )0ock"idget allowing your users to freely
move and reposition widgets.
Tkinter cstomiation
3ompromising
+kinter allows widgets fonts and colors to be customi:ed, but not as easily as
using +hemes or <tyles.
<haped widgets are not supported by this toolkit.
=untime
4ot available at all.
wxPython Customiation
3ompromising
7ike +kinter, this toolkit supports changing widgets fonts and colors but not as
easily as using +hemes or <tyles. w!Python may adapt its look and feel based
on changes done on your platform.
<haped widgets are supported.
=untime
w!Python provides a library called AUI #Advanced User Interface$ allowing
dockable floating frames #like Py)t dock widget$ and much more.
!ummary
0esigning good user interfaces requires a decent amount of effort, following some
guidelines may help you and will make your users happier.
3ustomi:ations are not always welcomed by users, make sure you need it and your
applications benefits from this before diving into this area. If you believe they are needed,
both PyGtk and Py)t got more general solutions. If you are not planning changing the entire
interface through themes, w!Python may be good enough to you as well. 7astly, if you do
not need fancy customi:ations, +kinter may be a choice.
"e# Inte$ration
As time passes by, it gets harder to ignore how much the "eb is part of our daily lives, and
if it is not important for you yet, it is possible that in some time it will. It ust keep growing
#only Google inde!es several billions of pages$, all the time.
>or this reason, it may be possible that you will want #or need$ to integrate "eb resources
into your 0esktop applications. <ome programs already do it, be it a small part or even the
largest and most important part of the GUI application.
If you are planning to use "eb resources #.+?7, 3<<, 2avascript, >lash, ...$ in your 0esktop
applications, you need to be more careful when choosing among the toolkits ust in case
frustration, anger, and co. are not your friends. 1ut, be warned' depending on the level of
resources and portability desired, there may be no choices at all.
PyGtk
PyGtk comes with Pango that uses a <G?7@like markup language that allows you specify
attributes with the te!t they are applied to by using a small set of markup tags. +his is
helpful for displaying applications;s documentation or simple .+?7 pages, for e!ample.
"ith Pango it is possible to build a humble .+?7 renderer.
4e!t options are e!ternal libraries.
>or rendering andAor printing simple .+?7 documents, you would need Gtk.tml #python@
gtkhtml bindings
B
$. If you need 3<< (,* andAor 0%? (,* then Gtk.tml* would be more
appropriate, but unfortunately I couldn;t find any documentation for Gtk.tml*. &ven if you
do not need documentation at all to learn how to use it, you should worry about its lifetime.
It looks like both Gtk.tml and Gtk.tml* are not being developed anymore #but it still
works$, so I wouldn;t pick them. Platform supported #Gtk.tml, Gtk.tml*$' 7inu!.
And there is Gtk?o:&mbed that allows you to embed a ?o:illa browser window into your
Gtk application. Its API is severely limited, it doesn;t provide printing or viewing the page
source #as e!amples of the limitation$. 1ut if you do not need this kind of service, I would
opt for using it. +he reason for this choice is the support for all "eb resources your standard
web browser does, and it;s very easy to use. 7astly, it seems to have been used only in
7inu! for now.
PyQt
Py)t;s components )7abel, )Graphics+e!tItem, )+e!t&dit and )+e!t1rowser supports
.+?7 #a subset of .+?7 ,.* and 5$ rendering. It isn;t intended to support all features a
browser does, but at least it is multi@platform.
>urthermore Py)t supports Active9 through )A!3ontainer making it possible to embed
Internet &!plorer Active9 control into your application. Cou get all features you might need
in e!change of being limited to "indows and it is only available for commercial versions of
Py)t.
Tkinter
2ust like you could do in PyGtk #use Pango to build a simple .+?7 renderer$, you can do one
in +kinter using its +e!t widget. 4e!t to this there is the possibility of using Python;s built@in
module webbrowser
D
.
If using e!ternal libraries is not a problem, give +k.tml
E
and its Python wrapper
F
a try. I;ve
B python+gtkhtm bindings site: http://www.,coutant.,reesur,.,r/python+gtkhtm.htm
D Python modue webbrowser documentation: http://docs.python.org/ib/modue+
webbrowser.htm
E -khtm site: http://www.hwaci.com/sw/tkhtm/
F -khtm Python wrapper: http://tix.source,orge.net/-ixapps/src/Python/-kHtm.py
ran a sample that is included but didn;t enoy it all, it doesn;t allow you to select te!t,
among other things. 7astly there is +k.tml,
(8
that gives cooler features, like 3<< support,
but there is no Python wrapper yet.
wxPython
+his toolkit provides some components that supports basic .+?7. +his includes .tml7ist1o!
and .tml"indow that serves as a basic and limited .+?7 render #like Gtk.tml and
)+e!t&dit$. +he good thing is that they are both multi@platform.
It also provides Active9 support, and a component called I&.tml"in that is an Active9 I&
window embedded in a w!"indow.
!ummary
Integrating web in your desktop application using any of these toolkits and e!pecting them
to work everywhere with whatever you desire is ust a hope nowadays. If you ust need plain
and simple .+?7 rendering, w!Python and Py)t will serve you well. If you are targeting
7inu!, PyGtk with Gtk?o:&mbed is your best shot. And if you are focusing on "indows
users, w!Python will provide all features you might need through Active9 #at no charge$.
Future
It seems "eb-it
((
will save you #some time in the future$. +here is support for gtk, qt, w!
and a proect called w!"eb-it
(*
that already provides bindings for w!Python. And hopefully
it will run in all platforms you e!pect to.
Licenses
7icenses affect your work more than you can imagine, if you don;t do already. Cou could
want to hide the source, or keep any derivative works free, or maybe ust put it in the public
domain, or other uses, but to do so, you need to use the correct license. 3hoosing an
appropriate license is not always easy, it may even require a lawyer, but this is out of scope
of this article.
If you are worried about spending money, do not be. All the toolkits give you opportunity to
not need to invest any money on licenses, but depending on your kind of application
distribution and chosen toolkit, there may be some price to pay for.
PyGTK License
PyG+- uses 7GP7 #7esser General Public 7icense$, this license is a middle term between GP7
and permissive licenses such as 1<0 and ?I+ licenses. +he main difference between the
GP7 and the 7GP7 is that the latter can be linked to a non@#7$GP7ed program, which may be
free software or proprietary software. +his means that you may choose to not distribute the
source along with your program. If you are in doubt to use 7GP7, check out
http'AAwww.fsf.orgAlicensingAlicensesAwhy@not@lgpl.html.
PyQt Licenses
Py)+ follows +rolltech;s license model, that means you will use different licenses based on
how you use Py)+.
If your program is GP7 compatible, then you do not need to buy a commercial Py)+ license.
1eing compatible with GP7 means, among other things, that'
(8 -khtm. site: http://tkhtm.tc.tk/index.htm
(( /eb0it site: http://webkit.org/
(* wx/eb0it site: http://wxwebkit.wxcommunity.com/pmwiki/index.php1n23ain.HomePage
Cou will be providing the source code for your application
All modified and e!tended versions of the program will continue being free
Users are allowed to re@use, modify and re@distribute the code
4ote that does not mean you can;t sell copies of the program for money. +here is a GP7 >A)
that you should read in case of doubts' http'AAwww.fsf.orgAlicensingAlicensesAgpl@faq.html.
Previous to Py)t v5, this free version was only available for 7inu! and ?ac %<9.
In case your use of Py)t is not compatible with GP7 then you will need a commercial Py)t
license. 1uying a license for Py)t does not include )t licensing, so you must also purchase
copies of the commercial edition of )t from +rolltech. ?ore informations on buying Py)t
7icense can be found at http'AAwww.riverbankcomputing.co.ukApyqtAbuy.php and for )t at
http'AAtrolltech.comAproductsAqtAlicensesAlicensing.
Tkinter License
+kinter is bundled with Python and also uses the P<>7 #Python <oftware >oundation
7icense$. +his is a permissive free software license which is compatible with the G4U
General Public 7icense #GP7$. Its primary use is for distribution of the Python proect
software. Unlike the GP7 the Python license is not a copyleft license, and allows
modifications to the source code, as well as the construction of derivative works, without
making the code open@source.
wxPython License
w!Python uses the same license as w!"idgets, the w!"indows 7icense. +his license is
essentially the 7@GP7 #7ibrary General Public 7icense$, with an e!ception stating that derived
works in binary form may be distributed on the user;s own terms. +his is a solution that
satisfies those who wish to produce GP7;ed software using w!"idgetsAw!Python, and also
those producing proprietary software.
!ummary
If you don;t even want to think about licenses in your way, +kinter or w!Python would be
the first option. 4e!t to this is PyG+-, its license basically only forbids distribution of static
linked libraries without neither source code nor linkable obect files, so, if you are not
considering this kind of distribution, it;s all good. >inally there is Py)+. If you will be
following GP7, you won;t need to buy any licenses. 1ut if that is not the case, you will need
to invest some money in Py)+ and )+ before you start developing your application.
GUI %esi$ner Tools
As your applications grow, you will notice a lot of lines of code used ust to create window
components and by that time you will probably want to avoid unnecessary clutter in your
code. +hat is where these tools should be used. GUI 0esigner tools also allows you to focus
on the core development of your applications for the reason that GUI development will be a
bree:e.
+ools available for each toolkit will be rapidly described below. 1ut you should familiari:e
yourself with them, or at least with the ones used by your chosen toolkit.
PyGtk tools
Glade
(,
#>irst release' April (E, (FFE G 7atest release' 0ecember (E, *88D$
Ga:pacho
(5
#>irst release' 2une ,8, *885G 7atest release' 2uly *F, *88D$
Glade and Ga:pacho are very similar from user perspective. +hey both requires you to
understand how G+- containers work in order to construct interfaces. Using Glade there is a
possibility of using a widget called />i!ed/ that lets you drag and drop components into
(, Gade site: http://gade.gnome.org/
(5 Ga4pacho site: http://ga4pacho.sicem.bi4/
+oplevel widgets without caring about containers. Using this /technique/ leads to a very
problematic application, setting specific si:e and position for all widgets is a good recipe for
headache. It is very likely your interface will not appear as correct in someone;s else
computer as it appeared on yours. >or these reasons, you should learn how to use
containers, it is not hard and your programs will achieve better results.
+hese tools generates .glade files that are then used by your application. Ga:pacho also
supports saving in gtkbuilder and ga:pacho formats. Gtk1uilder is said to take over glade
format, making it the new format to use #it has been added in GtkH *.(* and is available for
PyGtk *.(*$.
+here are some reasons to pick Ga:pacho over Glade, like the presence of a set of -iwi
(6
widgets and the possibility to use GtkUI?anager
(B
.
And the reasons to pick Glade over Ga:pacho are its development time and amount of
users.
PyQt tool
)t 0esigner
(D
#>irst release' <eptember 8D, *888 G 7atest release' %ctober 8,, *88D$
)t 0esigner 5 is a very easy GUI designer to use, and very powerful as well. It is a tool that
makes most people happy, you can ust start dragging and dropping widgets and leave it
like that or ask it to layout the widgets for you, or, you may choose to create
IerticalA.ori:ontalAGrid 7ayout and drop widgets there.
=arely you will need to change the tab order, but if you want to do it for the right reason, it
provides a very attractive visual editor for that. %ther nice visual features are edition of
<ignalA<lots and 1uddies. +he former provides a visual representation of the signal and slot
connections in the form that can help other developers understand how the final component
will behave. +he later, associates a widget to its buddy. +his association allows you to
connect a )7abel to a )7ine&dit #its buddy$ and then focus the buddy widget by pressing
)7abel;s shortcut key combination.
+his tool generates an .ui file, that you can choose to use through Py)+5.uic module or use
the pyuic tool that will convert the .ui file to a .py file. It may also generate a .qrc file if you
are using e!ternal resources, like images. +o use the resources file, you need to use pyrcc
tool so it converts to a python module with the e!ternal resources embedded into it.
Tkinter tool
GUI 1uilder
(E
#=eleased into open source in 4ovember, *88B$
GUI 1uilder is a ne!t@generation <pec+cl alternative, as its page says, but I didn;t see much
difference e!cept that GUI 1uilder menu creation is more straightforward to use than
<pec+cl;s one.
It is pretty simple and somewhat intuitive, and enforces the use of Grid geometry manager
which is good because it makes you write applications with a consistent layout, that is, you
will not be hand positioning the widgets.
+his tools generates two files, a Jui.py file and other .py file based on the name you gave
when you saved the your .ui file.
wxPython tools
w!Glade
(F
#>irst release' 2uly ,(, *88* G 7atest release' >ebruary 8*, *88E$
9=3ed
*8
#>irst release' K August ,(, *88( G 7atest release' ?arch (8, *88D$
1efore moving on let me say that there are more GUI builders available for w!Python, like'
1oa 3onstructor
*(
#I0& and GUI 1uilder$, Iisual"!
**
#"indows only$, w!0esigner
*,
(6 0iwi site: http://www.async.com.br/pro!ects/kiwi/
(B Gtk#I3anager re,erence: http://www.pygtk.org/pygtk5re,erence/cass+gtkuimanager.htm
(D Qt 6esigner site: http://trotech.com/products/qt/,eatures/designer
(E G#I 7uider site: http://spectc.source,orge.net/
(F wxGade site: http://wxgade.source,orge.net/
*8 (8%ed site: http://xrced.source,orge.net/
*( 7oa %onstructor site: http://boa+constructor.source,orge.net/
** 9isua/x site: http://visuawx.atervista.org/
*, wx6esigner site: http://www.roebing.de/
#3ommercial$. 1ut I have chosen to talk only about w!Glade and 9=3ed because they are
under active development, both works cross@platform, and they are open source proects.
4ow we may continue.
w!Python uses <i:ers, and for the same reasons you should understand containers if you
are using PyGtk, you should invest some time understanding si:ers. <i:ers are a bit harder
and you will probably need to read some tutorial in order to use them perfectly. As
suggestion, read this page' http'AAwiki.w!python.orgAUsing<i:ers.
w!Glade looks like Glade@*, it is not as pretty as Glade@, #but works$, e!cept that it is able
to generate 9?7@based resource system #or ust 9=3$ files. 4ote that it is also able to
generate direct Python code, but the advantage of opting for 9=3 format is that they can be
used by 9=3ed as well.
9=3ed is actually a resource editor that supports creating and editing files in 9=3 format,
but I am including it in this section anyway. It will be your preferred tool when you get
accustomed with w!Python, it is the fastest tool to develop an UI if you know enough about
w!. 9=3ed doesn;t involve drag L drop of widgets into a beautiful window, on the other
hand you will drag L drop components into a 9?7 tree, making it a bad choice if you are not
comfortable on w!Python.
If you prefer to separate the UI layout from the code, be sure to use a 9=3 file. "orking with
this file is like working with glade files, but this is w!Python so it has several differences in
use.
1oth w!Glade and 9=3ed misses a lot of widgets included in w!Python, a consequence of
this toolkit having so many widgets.
!ummary
If you know your tool, and if the name of that tool is w!Python then 9=3ed is waiting for
you. If you are considering learning some GUI toolkit and it is important that it has a
powerful and featureful GUI 0esigner application, )+ 0esigner will be your favorite tool.
4e!t to this there is Ga:pacho, followed by Glade and w!Glade. Ga:pacho takes the lead for
supporting action based menus and toolbars #)t 0esigner supports this too$. 7astly, if you
ust want something simple and good looking is not important at all, GUI 1uilder is there for
you.
&uilt'in wid$ets
Unlike other sections this one does not contains subsections dedicated to each toolkit, all
the discussion will take place here.
All toolkits discussed provides a set of basic widgets that can construct any GUI application.
1ut as you start doing more advanced user interfaces the number of used widgets will tend
to increase and it is very likely that you will see yourself creating new widgets, or at least
using some e!ternal libraries, every time you have a different application to build, if you are
using +kinter. +hat is because this toolkit has a very limited set of widgets and the chances
of it growing are rare #+k E.6 has new widgets, meaning they will eventually be available in
+kinter$ because it is part of Python and that means it is stable, which is not bad, but it
stays the same for a long time. +his is also one of the reasons why it is unlikely that some
other GUI toolkit will take +kinter;s place in Python, because they are changing too often
and possibly causing some form of instability.
w!Python has the largest set of widgets between the four toolkits. +his implies that the
chances of needing to construct a new widget are lower than if you were using PyG+-, Py)+
or +kinter. %f course if you need a very specific widget, no toolkit will provide it, so, you can
either check if someone has already done it, or do it yourself. w!Python can save a great
amount of time depending on the application you are planning to do, one of the reasons
being the addition of w!.AUI library #AUI stands for Advanced User Interface$. +his library
instantly adds a huge amount of fle!ibility to your application, like' floatingAdocking frames,
customi:able look and feel, perspective saving and loading, optional transparent window
effects while dragging and docking, and others.
PyG+- and Py)+ provides a similar amount of widgets, but Py)+ leads between the two
because )+e!t&dit supports .+?7 rendering, it also supports %penG7 in Py)+ applications
through )t%penGl #requiring Py%penG7$ and allows docking widgets, for e!ample.
%ocumentation ()aila#le
+his last section points out some documents that you will be visiting while developing a GUI
application. 4ote that there is much more /0ocumentation Available/ than described here,
this was ust an attempt to collect most of the interesting documents e!isting relative to the
toolkits discussed here.
4evertheless, I hope these pointers will answer most of your question.
PyGtk
Document Audience
PyGtk *.8
+utorial
*5
Anyone starting in PyGtk
PyG+- >A)
*6
If you use PyGtk, but don;t know everything about it yet, this >A) will solve
most of your questions that are likely to arise
PyG+k "iki
*B
1oth beginners and more e!perienced users will find this useful. Its main
purpose is to collect links for several other documentations.
%thers
PyG+- *.8 =eference ?anual
*D

Articles and +utorials about PyG+-
*E
1eginning Python, 3hapter (,
*F
PyQt
Document Audience
Introduction to Py)+5
,8
Anyone starting in Py)t
=apid GUI Programming with
Python and )+
,(
Py)t 5 book, one of the best options available for learning
how to program with this toolkit
+he Py)+ and Py-0& community
"iki
,*
Good link collections, anyone interested in Py)t will find
this useful
)t )uarterly
,,
>or those already developing in )tAPy)t interested in
learning more about this toolkit.
%thers
Py)+ v5 @ Python 1indings for )t v5
,5
Py)t;s 3lasses
,6
Tkinter
Document Audience
An Introduction to
+kinter
,B
Anyone starting in +kinter
*5 PyGtk 5 -utoria: http://www.pygtk.org/pygtk5tutoria/index.htm
*6 PyGtk :"Q: http://,aq.pygtk.org/index.py1req2index
*B PyGtk /iki: http://ive.gnome.org/PyG-0
*D PyGtk 5 8e,erence 3anua: http://pygtk.org/docs/pygtk/index.htm
*E "rtices and -utorias about PyGtk: http://pygtk.org/artices.htm
*F 7eginning Python book: http://www.ama4on.com/7eginning+Python+Programmer+Peter+;orton/
dp/<=>?@A>@?.
,8 Introduction to PyQt? site: http://www.rkbog.rk.edu.p/w/p/introduction+pyqt?/
,( 8apid G#I Programming with Python and Q- book: http://www.qtrac.eu/pyqtbook.htm
,* -he PyQ- and Py06$ community /iki: http://www.diotavei.net/PyQt/iki
,, Qt Quartery site: http://doc.trotech.com/qq/
,5 PyQ- v? + Python 7indings ,or Qt v? re,erence: http://www.riverbankcomputing.com/6ocs/
PyQt?/pyqt?re,.htm
,6 PyQtBs %asses re,erence:
http://www.riverbankcomputing.com/6ocs/PyQt?/htm/casses.htm
,B PyQtBs %asses: http://www.pythonware.com/ibrary/tkinter/introduction/index.htm
Python and +kinter
Programming
,D
A good read, in form of a book, for those wanting to learn +kinter
+kinter "iki
,E
3ontains links for some tutorials, reference documentation, and
others. 1etter suited for intermediate users
%thers
+kinter reference' a GUI for Python
,F

+kinter @@ Python interface to +clA+k
58

wxPython
Document Audience
+he w!Python tutorial
5(
Anyone starting in w!Python
w!Python in Action
5*
Iery good book, ust a bit dated but still serves as one of the
best ways, if not the best, to learn w!Python
w!Py"iki
5,
I would say this is the best wiki among the others mentioned
here. 1eginners, intermediate and e!perienced users will find
good and interesting informations here
%thers
w!Python API
55

!ummary
+here is a decent amount of documentation for all the toolkits. 1ut it is important to ask
yourself if you are willing to learn. It does not matter how many books, tutorials, articles,
etc.. may e!ist for a toolkit #or anything else$ if you ust do not take time to learn what you
wantAneed. +he e!cuse of documentation not being good enough, in this case, is hardly a
reason for preventing you from learning any of these toolkits.
,D Python and -kinter Programming book: http://www.manning.com/grayson/
,E -kinter /iki: http://tkinter.unpythonic.net/wiki/
,F -kinter 8e,erence site: http://in,ohost.nmt.edu/tcc/hep/pubs/tkinter/index.htm
58 -kinter Python modue documentation: http://docs.python.org/ib/modue+-kinter.htm
5( wxPython -utoria site: http://www.4etcode.com/wxpython/
5* wxPython in "ction book: http://www.manning.com/rappin/
5, wxPython /iki: http://wiki.wxpython.org/
55 wxPython "PI site: http://www.wxpython.org/docs/api/