| | |  | Software Engineering | Home » » » Rapid GUI Programming with Python and Qt (Prentice Hall Open Source Software Development) | | | | | | | Product Promotions: | | | | | Description: | | The Insider's Best-Practice Guide to Rapid PyQt 4 GUI Development
Whether you're building GUI prototypes or full-fledged cross-platform GUI applications with native look-and-feel, PyQt 4 is your fastest, easiest, most powerful solution. Qt expert Mark Summerfield has written the definitive best-practice guide to PyQt 4 development. With Rapid GUI Programming with Python and Qt you'll learn how to build efficient GUI applications that run on all major operating systems, including Windows, Mac OS X, Linux, and many versions of Unix, using the same source code for all of them. Summerfield systematically introduces every core GUI development technique: from dialogs and windows to data handling; from events to printing; and more. Through the book's realistic examples you'll discover a completely new PyQt 4-based programming approach, as well as coverage of many new topics, from PyQt 4's rich text engine to advanced model/view and graphics/view programming. Every key concept is illuminated with realistic, downloadable examples—all tested on Windows, Mac OS X, and Linux with Python 2.5, Qt 4.2, and PyQt 4.2, and on Windows and Linux with Qt 4.3 and PyQt 4.3. Coverge includes - Python basics for every PyQt developer: data types, data structures, control structures, classes, modules, and more
- Core PyQt GUI programming techniques: dialogs, main windows, and custom file formats
- Using Qt Designer to design user interfaces, and to implement and test dialogs, events, the Clipboard, and drag-and-drop
- Building custom widgets: Widget Style Sheets, composite widgets, subclassing, and more
- Making the most of Qt 4.2's new graphics/view architecture
- Connecting to databases, executing SQL queries, and using form and table views
- Advanced model/view programming: custom views, generic delegates, and more
- Implementing online help, internationalizing applications, and using PyQt's networking and multithreading facilities
| | | Product Details: | | | Author:
| Mark Summerfield | | Hardcover:
| 648 pages | | Publisher:
| Prentice Hall | | Publication Date:
| October 28, 2007 | | Language:
| English | | ISBN:
| 0132354187 | | Product Length:
| 6.96 inches | | Product Width:
| 1.55 inches | | Product Height:
| 9.32 inches | | Product Weight:
| 2.34 pounds | | Package Length:
| 9.2 inches | | Package Width:
| 7.0 inches | | Package Height:
| 1.4 inches | | Package Weight:
| 2.3 pounds | | Average Customer Rating:
|  based on 21 reviews |
| | | | Customer Reviews: | |
Average Customer Review:
 ( 21 customer reviews )
Write an online review and share your thoughts with other customers.
Most Helpful Customer Reviews
93 of 94 found the following review helpful:
 Worth having when time is moneyDec 07, 2007
By The Conductor
For any open source programming tool, there are always those who are quick to point out that free online documentation is of excellent quality and that a commercially published book adds questionable value. Indeed, the open process by which open source tools are made, which reveals the why's & wherefore's of the internal workings to anyone who looks, leads directly to the production of excellent online documentation; this is one of the great strengths of open source software. But everyone's needs are different. A college student or free software volunteer often has looser deadlines, less budget, and a more perfectionist attitude than, for example, a non-expert programmer, working in industry, trying to expeditiously solve a specific problem. A book of this genre is intended mainly for the latter audience, whereas the former may be disappointed at spending $50 when a web browser could have done the job. Cash-strapped college students, I know your pain; I used to be one. This book is not a particularly cost-effective study aid. If you live and breathe GUI progamming and can type out GTK2 and wxwidget classes by heart, then this book is probably a waste of time for you.
Having said that, I review this book with a view toward its value to its intended audience: Does buying this book and using it get the job done $50 cheaper, including the value of your own professional time, compared to the best available alternative? My experience is yes.
I am an electrical engineer, but not a programming expert. I have, at various times in my career, flipped bits in assembly language, suffered the rigors of Fortran, and slapped together contraptions in Matlab, VEE, Labview, etc. I have also had the misfortune of programming production test automation in Visual Basic, because that is what commercial instruments natively support. It is the shortcomings of VB that bring me to PyQT. I need to write test code that is portable, maintainable, and reliable. To give just one example, I don't want to fly across the Pacific Ocean to program workarounds for bugs in VB, because machines in the Chinese factory run Win98, and my development system in the US runs Win2k, and VB doesn't behave the same. But this is a book review, not a place to extol the virtues of PyQT nor criticize VB.
I have programmed in Python before, though for me Python has always been a language for one-off numerical or string processing tasks, where a spreadsheet is too limited and my bash script-fu is short of the task. I found the first three chapters on Python a helpful review, though it is not a complete instruction in Python. Compete beginners to Python will probably want to buy a separate book or work through the python.org tutorials. The author glosses over things that could trip up beginners; tellingly, he uses the term 'pythonic' without introduction. He is, however, careful to point out pitfalls that can waylay real-world production code, or would be of interest to experienced Perl/Ruby/VB programmers, like how Python handles the distinctions regarding {im}mutable types and {deep|shallow} copying.
I have never programmed QT before, and this book is indeed a complete introduction to QT. You don't need to know anything about QT nor how to program in C++ (QT's native language). Being able to read C++ syntax helps, though, because this book is not a QT reference, so you will probably have to look things up in the online QT references, which are written in C++.
It is something of a truism that the best way to learn a language is to read & understand someone else's well-written code, and then use that to write a program of your own. That is the approach used here, and the printed book format permits interleaving fragments of code with explanatory material in a way that doesn't work well on a computer screen. As such the text complements rather than duplicates the online documentation.
Regarding the book as a physical object, the quality is good but some extra features would have been nice. No CD is included, which I consider an oversight for a book at this price. Even the shortest examples lack source code listings, except as snippets woven into the text. You have to download the example code from a URL buried in the introduction, which is odd considering how important the example code is to this style of instruction. Occasional sidebar topics, icons, and cross-references help to organize the material, though not to the spoon-feeding level of "For {Dummies|Idiots}" books. The index is a bit above average for a book of this type, better than pure machine-generated grep output that sometimes passes for an index these days, but not as good as the best manual indices of decades past. The cover, binding, & paper stock are of decent quality. The book will stay open to just about any page when laid on a table, and the glue looks like it will, well probably, hold the sheaves in for many years. No color is used, nor edge printing to help find the chapters, which would have been helpful for a book this long.
18 of 18 found the following review helpful:
Great text bookOct 03, 2008
By Brian H. Wilson
I needed a book to help me through connecting Python and QT together so that I could write GUI programs in Python. This book definitely did that for me so I am satisfied.
This book is written as a classroom textbook, not as a reference. Part I is on Python programming (the first 100 of 500+ pages). I did not need that but in the context of a textbook it's good to have everything between two covers.
I like the fact that it covers a broad range of material beyond GUI programming including database access and model/view programming. I think I will be digging into it for quite some time.
11 of 12 found the following review helpful:
Well-articulated, consistently informative introduction to Python and QtOct 11, 2009
By Hugo M. M. Rabson
I bought "Rapid GUI Programming with Python and Qt" (Summerfield) and "Programming Python" (Lutz) in order to help me write my first Python software application, a program whose development would require an understanding of Python, Qt, PyQt, and relational databases. I found Summerfield's book very useful.
The first few chapters brought me up to speed on Python itself. The chapters which dealt with PyQt were of course the most detailed and the most useful. I found myself getting frustrated with the "Dance of the Seven Veils": the book would touch on a topic briefly, explain how important it was, give an example, then hurry away to cover something else. By the time we got to the meaty, more thoroughly-explored examples, I was confused and slightly lost. Google filled in the gaps, so in the end it was all worth it.
In defense of this book's "A little bit of everything" style, I must point out that a toolkit of Qt's size and complexity cannot be covered thoroughly by a single text, in my opinion anyway. Summerfield took on an impossible task and did a good job.
All things considered, I think that Summerfield's book was worth the money. It rarely leaves my desk and never sits on my bookshelf. That's how useful it is to me.
8 of 9 found the following review helpful:
 best PyQt bookApr 24, 2009
By halwass
Good clear exposition of Qt as used with Python. Qt, a GUI toolkit, seems fairly easy to use (particularly with Python), but is quite large (as needed to provide various convenient features for a broad variety of GUI widgets): hence it's good that this book goes through the numerous features clearly and in detail.
As a bonus, the author assumes no prior knowledge of Python, and spends the first hundred pages on a swift Python tutorial. Of course one can't learn all of Python in a hundred pages, but the author covers the features needed to follow the rest of this book. Moreover, I think it's actually a good introduction to Python, which you will appreciate if either (a) you've used Python but are rusty and need some quick reminders, or (b) you've never used Python (but know another object-oriented language), in which case this should get you nicely started on Python.
Also I should mention that, when I had problems getting Qt and PyQt to install, the author wrote back instantly with useful information. Oh, yeah, I should warn you that, if you're installing on Mac, do not use Python 2.6 or later; PyQt currently has trouble with it. The combination I finally got to work was: Python 2.5.4; Qt 4.4.3; SIP 4.7.9; PyQt 4.4.4. (Of course this information will change over time. Refer to the author's website for updates.)
6 of 7 found the following review helpful:
 Good, but...Apr 20, 2011
By Bastian Bechtold
In general, this book gives a great overview of PyQt and Python 2.x.
However, having read of few of these books to learn a few different languages and frameworks, I find this one lacking quite a bit in several areas.
For example, you would not be able to recreate the example applications by reading the book alone. Most examples really only made sense to me with the actual source code at hand. If you ask me, a good text book should be self-sufficient and should not require a computer to be usable.
Also, It would be great if the code examples were set in some monospaced font in the Kindle edition. As it is right now, code is set the same way normal text is. I'm sure the print version was formatted way better. Why must Kindle books be so ugly?
The author should really *really* read up on user interface design. The author claims that "some people" prefer 'save'/'discard'/'cancel' style dialogue boxes to 'yes'/'no'/'cancel' boxes. Both the UI guidelines of Windows and OSX actively forbid the latter. There is even a whole chapter on dialogue boxes. Again, most style guides say that dialogue boxes should be used sparingly, if at all. Good designs do not need them very often.
In some places, the author describes how some default formattings are different in Windows, Gnome or OSX and you really should use some generic auto-correct facilities provided by the framework. This is great! But why only mention it for button placement, but not for, say, form layouts? PyQt has facilities for that, too!
There are some issues which are up to the users preference. Say, whether you want to hand-code your UI or use Qt Designer. At one point the author says "Other approaches [to interface design using Qt Designer] are possible and they are covered in the online documentation. None of them is quite as convenient as the approach shown here, though". Well, I beg to differ on both cases. One, I don't think that the shown approach is as convenient as loading the UI files directly and Two, I don't feel that the online documentation is complete in any way. It would have been nice if the author had just shown me the different approaches and let me decide for myself.
And lastly, the book is a bit outdated (as of early 2011). PyQt 4.8's New-Style Signals and Slots simplify a lot of things. Python 2.7 and Python 3.x make some differences.
The book is still very helpful and I can recommend it if you are new to PyQt. Just be aware that it is a bit outdated, a few glances at the source code are necessary and UI design is not its strong suite.
See all 21 customer reviews on Amazon.com
| | |
|
