Before I picked up this book I knew nothing about GUI programming, but a good bit about Python. This book let me jump right into writing useful GUI's. Typical programming text books build on concepts sequentially, which is great for classrooms but not for learning on the fly. This book just jumps right into applications and teaches through examples. I was so impressed by this method that I plan on buying more books from the in action series whenever I need to learn another programming language. This book has been my #2 resource right behind Google, which is saying a lot.

This book is hard to use as a reference but it is better than nothing.

I bought this book when I needed to write a wxpython app at work. I'd done a lot of programming in python before, but had very little experience writing gui apps and non using wx. This book got me up and running very quickly and I was using wxpython productivly almost imidiatly. This book gives a solid introduction to the basics on wxpython and how to test and develop wxpython apps.

However the book doesn't cover a lot of more advanced or complex topics. If you need to to anything that isn't the most common and obvious approach you'll be on your own. I quite quickly found myself running into problems that wheren't covered in this book.

So on the whole this is a great book for quickly getting you up and running, and will have you writing simple wxpython apps in no time. However for anything more complicated you need to consult other sources.
An Advanced WxPython in Action book would be most welcome.

Simply awesome. Awesome cubed:

(i) wxWidgets is a wonderful thing - a cross-platform windowing
toolkit that uses native widgets to give extremely pretty
cross-platform GUI applications.

(ii) wxPython is a fabulous implementation of wxWidgets in Python,
taking advantage of various Python fabulousities to make using
wxWidgets much easier than in C++. (If you do any programming
but you've never heard of Python run, don't walk, to
[..].)

(iii) The book is an excellent introduction to wxPython. I
had a little emergency, caused by the fact that my PC had
died and my Delphi programs didn't seem to work on the MAC
I was migrating to. Starting with no knowledge of wxPython
(but with some familiarity with Python) in one three-day
weekend I was able to write a rudimentary spreadsheet application -
at the end of those three days it already worked better than
the Delphi application it was replacing (just because writing
Python is so easy I added a few features that I'd never got
around to adding to the Delphi version).

If you've been looking for something that does this sort of
thing then wxPython is what you want, and you want this book
to go with it.

(If you're a Python person who's been using tkinter: wxWidgets
is not much harder, it includes _much_ more builtin functionality,
and it gives _much_ nicer results, since it uses native widgets.)

David C. Ullrich

This book covers all of WxPython's principles and 90% of all components. The book consists of three parts: one and two for covering the basics and the third covering advanced topics.
The author assumes you understand the basics of Python before you start.
Still, even if you only just started Python, the code is easy to read.

The text is systematic and in a logical order. Each new subject is marked clearly in the examples and explained in the text. The subjects are in order of importance, easing a good start.

Subjects of part one are: event model, use of PyCrust for editting, a bit about refactoring GUI code and the basic building blocks.
Part two contains a most of the widgets, menus, sizers and images.
Part three covers advanced topics: list control, grid control, tree control, showing HTML, the printing framework and one chapter about drag and drop, timer and multi-threading.
What I missed in part three is the notebook controls. Well, you can't have it all.

I found the book as a whole easy to read and complete. If you have just started Python, make sure you understand lists and dictionaries and list comprehension. I.e. the basics. Anyone with some experience in Python will have no problem digesting the contents. The order of subjects makes sense if you are just starting to create a WxPython application.

As far as I can see now, the book is also a good reference. It covers most of WxPython and does so in a very steady, logical way. The subjects are easy to find when consulting the book afterwards.

An excellent choice for learning WxPython.

I've probably been spoiled by the excellently written tutorial for Java's Swing. wxPython in Action just barely covers the necessities. It has slightly more content than what's available online, but the structure of it makes it highly unsuitable as a reference.



The book boasts numerous tables that list most commonly used methods or classes for each topic, but the list is not exhaustive. Coupled with the rapidly changing API, the lists are nearly useless. There are also no screenshots with the various widgets all shown for comparison purposes or just to figure out which one you want.



Sections are constructed around questions, such as "How can I use file picker?", or "What color names are predefined?" Which is fine usually, except sometimes, the authors merely cover a very specific question instead of properly introducing a new widget and its functionality.



There are numerous other examples of where the book falls short. Sizers, similar to Swing's LayoutManagers, get a very brief treatment, focusing mostly on the, in my opinion, rather useless GridSizer. Compare this with the Swing Tutorial's in-depth treatment of each individual LayoutManager.



Want to know how to handle mouse events like the scroll wheel? Tough luck, because there's absolutely nothing in the book about it. Instead, the book gives you the basics of event handling and probably expects you to look up the details of scroll wheel handling in the API docs online (which do not have example code).



Overall, this book may be fine for getting you started on a basic application, say, a GUI front-end to a database. Anything more advanced and you had better be ready to get down and dirty with the online API docs.

I've probably been spoiled by the excellently written tutorial for Java's Swing. wxPython in Action just barely covers the necessities. It has slightly more content than what's available online, but the structure of it makes it highly unsuitable as a reference.

The book boasts numerous tables that list most commonly used methods or classes for each topic, but the list is not exhaustive. Coupled with the rapidly changing API, the lists are nearly useless. There are also no screenshots with the various widgets all shown for comparison purposes or just to figure out which one you want.

Sections are constructed around questions, such as "How can I use file picker?", or "What color names are predefined?" Which is fine usually, except sometimes, the authors merely cover a very specific question instead of properly introducing a new widget and its functionality.

There are numerous other examples of where the book falls short. Sizers, similar to Swing's LayoutManagers, get a very brief treatment, focusing mostly on the, in my opinion, rather useless GridSizer. Compare this with the Swing Tutorial's in-depth treatment of each individual LayoutManager.

Want to know how to handle mouse events like the scroll wheel? Tough luck, because there's absolutely nothing in the book about it. Instead, the book gives you the basics of event handling and probably expects you to look up the details of scroll wheel handling in the API docs online (which do not have example code).

Overall, this book may be fine for getting you started on a basic application, say, a GUI front-end to a database. Anything more advanced and you had better be ready to get down and dirty with the online API docs.

wxPython is a great application, that helps python programmer create professional GUI's. Especially compared to other toolkits, like Tkinter.
Unfortunately, the book is not written well, despite the fact that the wxPython author Robin Dunn collaborated in writing it. It has a feel of a better manual, with no gems sprinkled in to make you want to read more and try some code. It is repetitious in listing the properties of inherited objects over and over, but lacking the meat when you need the one functionality.
On the other hand I like stylistics - good selection of font, proportion of white space to text and images, and my favorite - the code annotation with arrows and numbers, to explain the functionality chunk by chunk.
Overall the book is bland, but due to lack of other book on the subject, this is a case of one eyed king - you will still be doing lot of 'googling'.

This book is very useful for wx.Python programmers, all examples work. Excellent book! Help me to build my application and save my time.

This book is very useful for wx.Python programmers, all examples work. Excellent book! Help me to build my application and save my time.

I've been using Python for several years, and prior to buying this book had messed around a little with wxGlade. I heard an interview with the authors on the Python411 podcast and became intrigued by the idea that it's possible to handcode a GUI app in wxPython (particularly by the suggestion one of the authors made that it's best to understand how to code manually before moving to a GUI builder like wxGlade). Imagine a GUI toolkit that can be handcoded in practice!

Well, I've been reading the book and have found that it's improved immeasurably my understanding of the details of the toolkit, and has also provided more general background and patterns for following MVC with wxPython.

Great job, Noel and Robin. You've produced a book that's clear enough for those just getting started with wxPython but also manage to include examples and discussion of more advanced topics and approaches. You took time away from coding to write the book, but the result is a product that's valuable to current users of wxPython and will likely expand the userbase (hey, this isn't harder than Tkinter!).

If you are interested in doing wxPython programming this is a great resource and reference. Excellent book! (In fact probably the only one so far at Jan 2007).

An excellent book for those needing to use wxPython - a cross platform GUI framework.

This book enabled me to build a complex cross platform application in very quick time indeed. Explains all the details of creating windows, forms, dialogs, menus and using events. The book is also supported by an excellent forum where the author answers questions on the book and code.

Contains enough information on all of the wxPython framework to allow anyone to be up and running, building cross platform apps, very quickly.

This book, together with O'Reilly's "Programming Python" is all you'll need to write great Python programs.

Kudos to the author for a book well done! Highly Recommended

An excellent book for those needing to use wxPython - a cross platform GUI framework.

This book enabled me to build a complex cross platform application in very quick time indeed. Explains all the details of creating windows, forms, dialogs, menus and using events. The book is also supported by an excellent forum where the author answers questions on the book and code.

Contains enough information on all of the wxPython framework to allow anyone to be up and running, building cross platform apps, very quickly.

This book, together with O'Reilly's "Programming Python" is all you'll need to write great Python programs.

Kudos to the author for a book well done! Highly Recommended

There is only one book on wxPython. If you have any serious interest, there are not a lot of choices. You have to get this book (Rappin and Dunn). The same is true of the wxWidgets by Smart, et. al.

This book contains lots of great samples of what you can do with wxPython. Great. If your problem looks like the sample, you can use the sample code.

If you want to go beyond the sample code, you are handicapped in two ways:

1) When flags, events, methods, etc. are discussed, the discussion introduces only the most often used. The tables which discuss the resources available to you start off incomplete.

2) The index is not strong. I count 544 pages covered by 1200 index entry lines. By contrast, the wxWidgets book is 662 pages, covered by 3240 index entry lines. When I need to look something up, I often find that neither book has an index entry for what I am looking for.

In contrast, Python Essential Reference by Beazley invariably has an entry for what I want to know. I hardly ever turn to the electronic documentation for Python itself as Beazley answers my Python questions in a single reference.

With wxPython and wxWidgets, I often need to turn to the electronic documentation because these two books need supplementation to serve as references.

This book got me started on WxPython and got me finishing a (very) small program within a week. It's an excellent reference, and even though it's the only book on wxpython, it is the best, and I think it will continue to be for a long time.
It does skimp in a couple of areas, and you do need to know (or learn) some Python to be able to use it, but it is, easily, one of the best programming books I've ever used.

I have dabbled in python some and played with 3 GUI toolkits for it: Tkinter, wxPython, and PyQT, but never had a good comprehensive manual to learn from. Scattered tutorials on the web of varying quality didn't help much.

Because of the 5-Star reviews for this book here on Amazon I purchased it and after having it 1 week I will add my 5-Star rating. This book is fantastic.

The writing is straightforward, the examples are clear, everything is explained concisely but comprehensively. I started at the first chapter and was very pleased that it started immediately with several simple GUI examples called bare.py and spare.py, for example.

Far too many programming books spend 1/3 of the book doing a basic tutorial of the language before you get to anything useful. Not this book. It states you should be somewhat familiar with Python and recommends another book if you need to learn it. So if you are beyond the basics and worried about getting another dumbed-down textbook, you can stop worrying; This book is ALL useful content.

I am immensely pleased with this book. Internet tutorials are useful for many things, so do not imagine I consider them useless for learning. But this book is superior and it is worth every penny.

Finnaly got me going with wxPython. Without this book I was lost.

Even though I am relatively new to Python, let alone wxPython, this book made it possible to put together a usable GUI application in a short amount of time. It was the breakthrough needed to get productive. The chapters on sizers and events were particularly helpful and the book is a pleasure to read.

I love Python but never cared much for Tk interface tools. Used to code MFC/C++ quite a bit, before I upgraded to Linux. Anyways, I was looking for a good GUI toolkit and found it in wxPython/wxWidgets.

I have a new programming project I'm working on and decided to use wxPython. I purchased this book and read it end-to-end - and I enjoyed it. (Can't say that about every programming book I've read!)

Highly recommended.

-Gerald Quakenbush
Author of Web Hacker Boot Camp

If, like me, you've been living under a rock (inasmuch as one can in the world of cross-platform GUI toolkits), you might not have heard much about wxPython. And if, like me, you were excited by the idea of quickly developing modern, robust GUI-driven applications that can run, without changes, on Windows, Mac OS X, and various UNIX-like systems, but turned off by the downright spartan and unforgiving online documentation, you can get happy again--with the publication of Noel Rappin and wxPython co-creator Robin Dunn's wxPython in Action, there is finally a cogent, coherent hybrid of tutorial and reference for wxPython that will get you out from under all that clunky Tkinter code and doing cool stuff.

Like other volumes in Manning's In Action series, wxPython presents a comfortable combination of introduction, overview, and example that encourages exploration and experimentation. The text is clear and concise, offering a no-nonsense explanation of the most relevant portions of the wxPython libraries and the best practices for their use, delivered at a measured pace that never manages to overwhelm, and uncannily launches into explanations of your questions just as they arise. Numerous reference tables provide a handy guide to the details (object properties, method signatures, events, etc.) that you'll be coming back to in your own future development. The expanded table of contents, listing each of the "how do I..." subsections of each chapter, is also a nice feature that will help make this a valuable reference. Code examples are functional, clean, and on-topic, just the right size to illustrate the concept at hand, and nearly always accompanied by illustrations of the resulting behavior. All the code is available online, and it's worth your time to either download it and give it a spin, or key it yourself and see how it behaves on your OS of choice. An especially nice feature of the example code in the book is that it's well annotated, either with a brief note or a bulleted number that will be referenced in an in-depth explanation immediately following the code listing; this helps the reader quickly zero in on the essential elements of the example, and it's surprising that such a useful technique is not more frequently encountered in programming books. A few errors seem to have snuck through the editing process, though, so deeply involved readers will want the errata nearby when monkeying with example code. Manning's "Author Online" forums are also a great resource if you get stumped along the way.

The book is divided into three major sections, each six chapters long. The first, "Introduction to wxPython," is primarily a tutorial that walks the reader through the foundations of coding in wxPython-land. Newcomers to GUI programming might find certain portions a bit dense and mildly daunting--specifically chapters 2 and 3--but patience here will be rewarded with a good understanding of critically important concepts, such as wxPython's event handling model, that will be leveraged over and over again throughout the rest of the book. Chapter 4 introduces PyCrust and other tools from Patrick O'Brien's Py library that you can use for interactive debugging or even reuse within your own wxPython applications. Chapter 5 is a real gem, providing an excellent discussion and practical walkthrough of the refactoring process, an exploration of the benefits of the Model-View-Controller pattern and how to do MVC in wxPython, and illustrates how to unit test your wxPython app; these are non-glamourous topics that help aspiring developers grow into good professionals, and this is a perfect place to see these topics. Chapter 6 presents the construction of a simple but fairly polished toy sketch application, a satisfying achievement that nicely rounds out the introductory section.

The second section, "Essential wxPython," begins the more reference-oriented material, covering (unsurprisingly) the essential widgets of the wxPython toolkit: text labels, text entry, buttons, checkboxes, and the like in Chapter 7; frames (what most of us think of when they think of "windows") in Chapter 8; dialogs in Chapter 9; various flavors of menus in Chapter 10; the ins and outs of sizers in Chapter 11; and basic graphics manipulation (putting images on the screen, customizing the cursor, etc.) in Chapter 12. Each subsection builds logically on the one that came before it, and likewise each chapter follows from its predecessor, introducing new widgets just as you're ready for them. The text here is significantly lighter than in the first few chapters, so this reads fairly quickly.

The third section, "Advanced wxPython," covers some more complicated widgets and topics that probably won't be day-to-day concerns but which are important enough that, when you need to know about them, they're covered in the book: list controls (think Windows Explorer or Macintosh Finder) in Chapter 13; grid controls (think spreadsheet applications) in Chapter 14; the tree control (think file system trees, or registry editors) in Chapter 15; HTML widgets (a great idea for a help facility in your applications) in Chapter 16; the wxPython printing framework in Chapter 17. Finally, Chapter 18 rounds things out with a grab-bag of other topics that didn't merit their own chapters but which are good to know about anyway: using the clipboard, managing drag and drop operations, timers, and threading issues.

To be fair, there are a few imperfections here, but they mostly amount to personal nit-picking. While it's probably not essential, there's no discussion of sound or other multimedia functionality; and from a structural standpoint, the book would have benefitted from a brief afterword to launch the reader into further reading or development activity. Finally, and this might be slightly unfair as I'd just finished reading one of O'Reilly's Head First books when I picked up wxPython in Action, this book could probably use a little more personality; when the occasional editorial comment sneaks through, it's a welcome break from the readable but positively arid expanses of text and examples.

That said, there's obviously still a lot here to love. wxPython is clearly the way to build cross-platform GUI apps in Python; even Guido van Rossum, Python's creator and benevolent dictator, advocates it, saying, "wxPython is the best and most mature cross-platform GUI toolkit... the only reason wxPython isn't the standard Python GUI toolkit is that Tkinter was there first." wxPython in Action is clearly the authoritative resource on the subject, a great introduction that will also serve as an excellent reference for years to come. Recommended for wxPython n00bs and gurus alike.

If you are familiar with the Python programming language, this book is for you. Authors Noel Rappin and Robin Dunn, have done an outstanding job of writing a book that is more of a useful resource than the existing online documentation.

Rappin and Dunn, begin by introducing wxPython and give some background on the technologies used to create wxPython. Then, they show you how to start a wxPython program, and how to manage its lifecycle. The authors continue by discussing how events are handled, and how you can use them as hooks to drive your functionality. Next, they show you how to make wxPython easier to handle with PyCrust. Then, the authors discuss best practices in three areas that are often difficult for GUI programmers. The authors continue by showing you how to work with the basic building blocks. Next, they cover the API for the basic widget set, including text fields, buttons, list boxes, and the like. Then, the authors cover how frames work, what kind of frames there are, and how to manage widgets within a frame. They also cover how modal dialog boxes work, as well as the standard predefined wxPython dialogs. The authors continue by showing you how to add menus to the menu bar, and menu items to a menu. Next, they show you how to use widgets with sizers, and what kind of layout is best suited to each. They also show you how to manipulate basic graphical images. The authors continue by showing you how to build list controls and managing items. Then, they show you how to coordinate the grid control. Next, they show you how to climb the tree control. Next, they show you how to incorporate HTML into your application. They also explore how all print, print data, and print preview objects work together. Finally, they cover some important features that are not quite long enough to justify a chapter on their own, including cut and paste, drag and drop, and multithreading.

How you use this most excellent book will depend on your wxPython knowledge. The authors designed the book to be useful for both experts and novices, but they expect that different parts of the book will have more or less resonance for users at different levels.

The documentation for wxPython being lacking, I figured I'd buy this book to fill in the gaps. Not ony did this book document things that are obscure or inexistant in the current docs, but it is presented in an easily digestable fashion that makes it really easy to get up and write your own program. The book is split into three main parts, introduction to wxPython, essential wxPython, and advanced wxPython. The intro discusses the origins of wxPython, how to set up an application, add frames (windows), set up events, and work with common dialogs. The second part goes into detail regarding each of the standard widgets. There's a good thirty pages on using sizers, info that I found invaluable. The last part discusses advanced wxPython subjects, including using grids and trees, using the printing framework, threading, and drag and drop.

The format is quite pleasing. For the sections on the various widgets, there is usually a short intro, a few code examples, a table that shows the main API methods for the widget which is more useful than the online docs, and quite a few screenshots throughout. The code itself is usually short, to the point, and at most a page long, so it doesn't try to show 10 things at the same time and it's easy to copy-paste (if you have the ebook version, also available) into your own programs. As the previous reader said, it's easy to see that this was written by one of the authors of wxPython. Despite being written by an expert, it didn't skim over some of the seemingly obvious but confusing for a beginner things in the package. For example, the book will tell you how to redirect "print" output to the console instead of a separate window (answer: use App(false) when instantiating your app), what's the difference between a Frame (window) and a Panel anyway (answer: panel allows tabbing), why you don't need a panel when using a dialog (answer: tabbing is already built in), why there's no 'pack' or 'appendToDisplayList' anywhere (answer: the first argument in a widget gives the parent and the framework automatically adds it to the display list), and a whole bunch of other little things.

There was one thing I thought was missing however, and that is a chapter on maintaining portability across platforms (especially with regards to sizing). Apart from that, the book is flawless, highly recommended!

Robin Dunn, one of the authors of this book is also one of the developers of the wxPython system. He is nothing else if not religiously converted to wxPython. And it is a delight to read a book where the author is so passionately dedicated to the subject. Many books are written by someone who has written 20+ titles on everything from how to use Excel to programming in the latest Microsoft language. When you read one by the developer you know you are not only getting the right scoop, but also you are getting an understanding of why/how the whole thing was developed and some commentary on why this particular package is the greatest thing since sliced bread.

This book is written for the programmer interested in moving to wxPython. It assumes that you have a working knowledge of the Python language and want to move up to the additional features in the wxWidget toolkit. It starts with a friendly tutorial to get your first couple of programs running, then it converts to an extensive reference for the large widget library.

This is THE book on wxPython.