-30% $41.72$41.72
$5.28 delivery January 30 - February 1
Ships from: Hafa Adai Books LLC Sold by: Hafa Adai Books LLC
$8.98$8.98
FREE delivery January 21 - 24
Ships from: ThriftBooks-Atlanta Sold by: ThriftBooks-Atlanta
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
Rapid GUI Programming with Python and Qt (Prentice Hall Open Source Software Development) 1st Edition
There is a newer edition of this item:
Purchase options and add-ons
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
- ISBN-100132354187
- ISBN-13978-0132354189
- Edition1st
- PublisherPrentice Hall
- Publication dateJanuary 1, 2007
- LanguageEnglish
- Dimensions7.5 x 1.25 x 9.25 inches
- Print length648 pages
Customers who viewed this item also viewed
Editorial Reviews
From the Author
About the Author
Mark Summerfield works as an independent trainer and consultant specializing in C++, Qt, Python, and PyQt. He was Trolltech’s documentation manager from 2000 to 2004, was the founding editor of Qt Quarterly, Trolltech’s customer newsletter, and coauthored C++ GUI Programming with Qt 3 and C++ GUI Programming with Qt 4.
Excerpt. © Reprinted by permission. All rights reserved.
This book teaches how to write GUI applications using the Python programming language and the Qt application development framework. The only essential prior knowledge is that you can program in some object-oriented programming language, such as C++, C#, Java, or of course, Python itself. For the rich text chapter, some familiarity with HTML and with regular expressions is assumed, and the databases and threading chapters assume some basic knowledge of those topics. A knowledge of GUI programming is not required, since all the key concepts are covered.
The book will be useful to people who program professionally as part of their job, whether as full-time software developers, or those from other disciplines, including scientists and engineers, who need to do some programming in support of their work. It is also suitable for undergraduate and post-graduate students, particularly those doing courses or research that includes a substantial computing element. The exercises (with solutions) are provided especially to help students.
Python is probably the easiest to learn and nicest scripting language in widespread use, and Qt is probably the best library for developing GUI applications. The combination of Python and Qt, "PyQt", makes it possible to develop applications on any supported platform and run them unchanged on all the supported platforms--for example, all modern versions of Windows, Linux, Mac OS X, and most Unix-based systems. No compilation is required thanks to Python being interpreted, and no source code changes to adapt to different operating systems are required thanks to Qt abstracting away the platform-specific details. We only have to copy the source file or files to a target machine that has both Python and PyQt installed and the application will run.
If you are new to Python: Welcome! You are about to discover a language that is clear to read and write, and that is concise without being cryptic. Python supports many programming paradigms, but because our focus is on GUI programming, we will take an object-oriented approach everywhere except in the very early chapters.
Python is a very expressive language, which means that we can usually write far fewer lines of Python code than would be required for an equivalent application written in, say, C++ or Java. This makes it possible to show some small but complete examples throughout the text, and makes PyQt an ideal tool for rapidly and easily developing GUI applications, whether for prototyping or for production use.
Since the emphasis of the book is on GUI programming, Part I provides a fast-paced Python tutorial as well as some PyQt coverage. This material is clearly marked to make it easy for experienced Python programmers to skip the Python they already know. Parts II, III, and IV of the book are all PyQt-specific and assume that readers can already program in Python, whether from previous experience or from reading Part I.
Quite often in programming we reach decision points when there are several possible approaches we could take. Reference books and the online documentation identify what classes, methods, and functions are available, and in some cases provide examples, but such documents rarely provide a broader context. This book gives the necessary context, highlighting the key decision points for GUI programming and offering insights into the pros and cons so that you can decide for yourself what the right policy is for your particular circumstances. For example, when you create a dialog, should it be modal or modeless? (See Chapter 5 for an explanation and policy recommendations on this issue.)
PyQt is used to write all kinds of GUI applications, from accounting applications, to visualization tools used by scientists and engineers. Figure 1, for example, shows Eric, a powerful integrated development environment that is written in PyQt. It is possible to write PyQt applications that are just tens of lines long, and medium-size projects of 1000 to 10000 lines are very common. Some commercial companies have built 100,000-line PyQt applications, with programming teams varying in size from just one person to more than a dozen people. Many in-house tools are written using PyQt, but because these are often used to gain competitive advantage, the companies involved generally do not permit their use of PyQt to be made public. PyQt is also widely used in the open source world, with games, utilities, visualization tools, and IDEs all written using it.
This book is specifically about PyQt4, the Python bindings for the Qt 4 C++ application development framework. PyQt4 is provided in the form of ten Python modules which between them contain around 400 classes and about 6000 methods and functions. All the example programs have been tested on Windows, Linux, and Mac OS X, using Python 2.5, Qt 4.2, and PyQt 4.2, and additionally on Windows and Linux using Qt 4.3 and PyQt 4.3. Backporting to earlier versions is possible in some cases, but we recommend using the most up-to-date versions of Python, Qt, and PyQt.
Python, PyQt, and Qt can be used free of charge for noncommercial purposes, but the license used by Python is different from that used by PyQt and Qt. Python is available with a very liberal license that allows it to be used to develop both commercial and noncommercial applications. Both PyQt and Qt are dual-licensed: This essentially allows them to be used to develop noncommercial applications--which must in turn be licensed using an acceptable open source license such as the GNU General Public License (GPL); or to be used to develop commercial applications--in this case, a commercial PyQt license and a commercial Qt license must be purchased.
The Structure of the Book
The book is divided into four parts. Part I is primarily a rapid conversion course aimed at non-Python programmers who are familiar with an object-oriented language, although it also has some (clearly marked) PyQt content. Because the core Python language is mostly simple and is quite small, these chapters can teach the basics of Python to a sufficient extent that real Python applications can be written.
If you think that you can pick up the Python syntax simply through reading it, you might be tempted to skip Part I and dive straight into the GUI programming that begins in Part II. The early chapters in Part II include back-references to the relevant pages in Part I to support readers who choose this approach. However, even for readers familiar with Python, we recommend reading about QString in Chapter 1. If you are unfamiliar with partial function application (currying), it is important to read the subsection that covers this in Chapter 2, since this technique is sometimes used in GUI programming.
There are also Python bindings for the older Qt 3 library, but there is no reason to use that library for new projects, especially since Qt 4 offers far more functionality and is easier to use.
Part II begins by showing three tiny PyQt GUI applications to give an initial impression of what PyQt programming is like. It also explains some of the fundamental concepts involved in GUI programming, including PyQt's high-level signals and slots communication mechanism. Chapter 5 shows how to create dialogs and how to create and lay out widgets ("controls" in Windows-speak--the graphical elements that make up a user interface such as buttons, listboxes,and such) in a dialog. Dialogs are central to GUI programming: Most GUI applications have a single main window, and dozens or scores of dialogs, so this topic is covered in depth.
After the dialogs chapter comes Chapter 6, which covers main windows, including menus, toolbars, dock windows, and keyboard shortcuts, as well as loading and saving application settings. Part II's final chapters show how to create dialogs using Qt Designer, Qt's visual design tool, and how to save data in binary, text, and XML formats.
Part III gives deeper coverage of some of the topics covered in Part II, and introduces many new topics. Chapter 9 shows how to lay out widgets in quite sophisticated ways, and how to handle multiple documents. Chapter 10 covers low-level event handlers, and how to use the clipboard as well as drag and drop, text, HTML, and binary data. Chapter 11 shows how to modify and subclass existing widgets, and how to create entirely new widgets from scratch, with complete control over their appearance and behavior. This chapter also shows how to do basic graphics. Chapter 12 shows how to use Qt 4.2's new graphics/view architecture, which is particularly suited to handling large numbers of independent graphical objects. Qt's HTML-capable rich text engine is covered in Chapter 13. This chapter also covers printing both to paper and to PDF files.
Part III concludes with two chapters on model/view programming: Chapter 14 introduces the subject and shows how to use Qt's built-in views and how to create custom data models and custom delegates, and Chapter 15 shows how to use the model/view architecture to perform database programming.
Part IV continues the model/view theme, with coverage of three different advanced model/view topics in Chapter 16. The first section of Chapter 17 describes the techniques that can be used for providing online help, and the second section explains how to internationalize an application, including how to use Qt's translation tools to create translation files. The Python standard library provides its own classes for networking and for threading, but in the last two chapters of Part IV we show how to do networking and threading using PyQt's classes.
Appendix A explains where Python, PyQt, and Qt can be obtained, and how to install them on Windows, Mac OS X, and Linux. PyQt is much easier to learn if you install it and try out some of the exercises, and if you inspect some of the example code. Appendix B presents screenshots and brief descriptions of selected PyQt widgets; this is helpful for those new to GUI programming. Appendix C presents diagrams of some of PyQt's key class hierarchies; this is useful for getting to know what classes PyQt has to offer and how they are related.
If you have never used Python before, you should begin by reading Chapters 1-6 in order. If you already know Python, at least read the string policy (in bullet points on page 28), and skim the material in Chapter 2 (apart from the first section, which you'll know well). Make sure that you are comfortable with lambda and partial function application, both of which are covered in Chapter 2. It is probably also worth skimming Chapter 3 as well. Then read Chapters 4, 5, and 6 in order.
Once you have covered the first six chapters, you have covered the essentials of Python and the fundamentals of PyQt.
Chapter 7 is useful if you want to know how to create dialogs using a visual design tool rather than purely by hand coding, something that can save a lot of time. For file handling, at least read the first three sections of Chapter 8. If you plan to write and read text files, also read Chapter 8's fourth section, and similarly the fifth section if you are going to use XML files.
For Part III, at the least read Chapter 10's first section, on event handling, and all of Chapter 11. Chapter 12 and the first section of Chapter 13 assume that you have read about PyQt's event handling, and that you have read Chapter 11. Chapters 9 and 14 can be read stand-alone in this part, but Chapter 15 assumes that you have read Chapter 14.
In Part IV, Chapter 16 assumes that you have read Chapters 14 and 15, but the other chapters can be read independently.
If you find errors in the text or in the examples, or have other comments, please write to mark@qtrac.eu quoting "PyQt book" in the subject line. The book's home page, where any corrections will be published, and from where the examples and exercise solutions can be downloaded, is http://www.qtrac.eu/pyqtbook.html.
If you want to participate in the PyQt community, it is worthwhile joining the mailing list. Go to http://www.riverbankcomputing.com/mailman/listinfo/pyqt to find a link to the archive, so that you can see what the mailing list is like, and also for a form for joining. Python also has mailing lists and other community activities. For these, go to http://www.python.org/community.
Product details
- Publisher : Prentice Hall; 1st edition (January 1, 2007)
- Language : English
- Hardcover : 648 pages
- ISBN-10 : 0132354187
- ISBN-13 : 978-0132354189
- Item Weight : 2.4 pounds
- Dimensions : 7.5 x 1.25 x 9.25 inches
- Best Sellers Rank: #1,807,081 in Books (See Top 100 in Books)
- #510 in User Experience & Website Usability
- #1,960 in Python Programming
- #2,346 in Software Development (Books)
- Customer Reviews:
About the author
Mark Summerfield is a computer science graduate and qualified teacher with many years experience working in the software industry, primarily as a programmer and documenter. Mark owns Qtrac Ltd., http://www.qtrac.eu, where he works as a programmer and where he created and now maintains his commercial software --- PDF comparison tools DiffPDF (GUI) and comparepdfcmd (command line). He also created the open source UXF (Uniform eXchange Format), and wrote the first UXF libraries.
All Mark's books are aimed at programmers and others, such as students, scientists, and engineers, who already have some programming experience (how much depends on the individual book). Each solo book has its own page on the Qtrac website from which the source code can be downloaded and that lists the book's errata. All the books are designed to teach technologies that Mark loves and has found to be the best of their kind.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Customers find the book provides a good introduction to Python and GUI programming. They appreciate the clear explanations of the examples and consider it a valuable resource. However, some readers feel the reading time is excessive or boring.
AI-generated from the text of customer reviews
Customers find the book provides a good introduction to Python and GUI programming. They appreciate the clear explanations of example code and the strategic choice of examples. The book covers both the basics and advanced topics, with excellent online documentation. Readers mention it's helpful for newcomers to PyQt and Python 3. They also mention the template-based coverage of GUI development at an introductory level with some deeper coverage.
"...It contains very clear explanations of the basics of PyQt as well as some great examples of advanced techniques...." Read more
"...to anyone who looks, leads directly to the production of excellent online documentation; this is one of the great strengths of open source software...." Read more
"...Also, given the availability of excellent Python 3 references (like Python Essential Reference (4th Edition)) you'll be hopping..." Read more
"...this is an excellent gui-programming tutorial; and, don't underestimate the importance of the downloadable code samples;..." Read more
Customers find the book provides good value for money. They say it's worth the price just for the source code to his tree.
"...The book is almost worth the price just for the source code to his tree model/view example...." Read more
"...The book does have good value in that the examples are all good, and the best way to learn writing GUIs with Qt is by examples." Read more
"...more than I would have liked to pay for an e-book, but so far it seems worth it...." Read more
"Lots of very clear examples. Definately worth getting. Be nice if the binding was lay-flat, but not a terrible problem." Read more
Customers dislike the reading time. They say the book is a waste of time and boring.
"...and wxwidget classes by heart, then this book is probably a waste of time for you...." Read more
"...on the quality of the book, which may be great, but it's no use to me at all...." Read more
"...It's boring reading, but you have to go through that documentation related to the classes used in his example code to make sense of what's going on...." Read more
"...If I cannot obtain the software used, then this book is totally useless." Read more
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
- Reviewed in the United States on March 8, 2011I am an experienced amateur with Python. This is the book I used to learn the basics of GUI programming using PyQt. I had some previous experience with using wxPython, but I needed to learn PyQt specifically for a project. I chose this book based on some reviews and it was a home run. It contains very clear explanations of the basics of PyQt as well as some great examples of advanced techniques. The book is almost worth the price just for the source code to his tree model/view example.
One of my favorite things about this book are the exercises at the end of each chapter. There are only a few, but each one involves extending that chapter's examples in some manner, to better illustrate the concepts. I found these to be a tremendous learning opportunity. You can download the answers to the examples from the author's website, and it was very informative to compare my code to that of a professional programmer.
On a similar note, I expected to skip over the first three chapters introducing you to Python programming. As I skimmed through them, I realized that those chapters were, in fact, very illuminating. I think they are one of the best general introductions to Python out there.
In short, if you are anything other than an expert PyQt programmer, you need this book. I had it open continually at my workstation for months, and I still keep it close and refer to it often.
- Reviewed in the United States on December 7, 2007For 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.
- Reviewed in the United States on September 9, 2010What I like most about this book is that it weaves the theory of Python programming into the practice of writing efficient code. The author has gone to great lengths to keep the reader out of the forests and swamps of Python language features to focus her/him on writing interesting code. The learn-by-doing approach is a really good angle. I am studying this book with Python 3 (reason: the guys at Riverbank Computing (authors of PyQt) decided to support Python 3, I couldn't wait for wxPython to get here).
That said, the hurdle anyone who takes this path must go through is developing GUIs from a Python 3 perspective while referencing Python 2.x(warts and all), given that the book covers only Python 2.x code. That's not as hard as it seems since the author has taken the time to port all of the code examples to Python 3.x. Also, given the availability of excellent Python 3 references (like Python Essential Reference (4th Edition)) you'll be hopping and skipping pretty quickly.
If you are new to Python, don't hurt your brain. First study an introductory book on Python 3(like Programming in Python 3: A Complete Introduction to the Python Language (2nd Edition)). This should make you mentally stable enough to charge down this path without crashing into trees.
Everyone else, get the book as soon as you can and get busy. You won't regret it!
- Reviewed in the United States on April 17, 2011I am a very experienced programmer, I have been writing software since before your parents were born, and I needed a review of Qt development for a job I was interviewing for. I had used Qt a little at the beginnings of linux's popularity in the late 90's, and had taught myself simple python a couple of years ago, when Oracle bought Sun and completed wrecking Java.
This book is very good, my only criticism is too much review of event driven programming, and not enough detail about the magic dust needed to make Qt cross platform. In detailing how to build the usual GUI application one would have on a Mac or PC desktop, the author misses my interest in using Qt on embedded or mobile systems. I recognize most readers would be more interested in the familiar. Perhaps this is the age of the book, it is several years old.
[...]
Top reviews from other countries
- Nguyen Quang ChienReviewed in the United Kingdom on May 31, 2024
5.0 out of 5 stars A definitive guide to GUI programming
Good book to learn GUI programming; there is also a chapter of Python OOP related to GUI development. Written with an academic style, the book includes end-of-chapter exercises. Qt is more than just GUI apprearance and the author showed how to use other extension modules such as networking and multithreading. The book was written for Python 2.x but it is very straightforward to port to Python 3.x.
-
Cecilio RuizReviewed in Spain on October 6, 2015
5.0 out of 5 stars Un libro necesario.
Está muy bien estructurado y toca practicamente todos los temas. Muchas explicaciones que son eseciales conocer. Es fácil de entender.
Para mi lo mejor que he tenido para aprender a usar eficientemente las PyQt.
- ColinReviewed in Canada on November 10, 2013
5.0 out of 5 stars Great book for Python + PySide/PyQt
Have been working on a number of fairly complex projects using PySide. Already had a fair amount of experience before picking this book up, and I still learned a ton. Goes through a lot of Python introductions which is great, as a few small things I picked up. Lots of example projects throughout to show you various features.
If you're doing PySide/PyQt projects, you need this book.
-
Sunny BoyReviewed in France on April 11, 2014
5.0 out of 5 stars Tout simplement pédamagique
Ce livre est une très bonne introduction à pyqt. Les exemples permettent de comprendre de manière progressives comment utiliser les différents widgets de QT.
Ce qui est surtout particulier dans les exemples de ce livre c'est au lieu d'avoir seulement pour objectif d'illustrer les exemples il prenne en compte le fait de ne pas faire prendre aux débutants de mauvaises habitudes de programmation.
Ce que j'ai un peu regretter c'est qu'il n y a pas de partie sur les progressbar qui pose de petits problèmes quand c'est utilisé sans thread.
Je recommande ce livre pour avoir une introduction mais aussi pour avoir de bonne habitudes de programmation.
-
vittorioReviewed in Italy on February 20, 2013
5.0 out of 5 stars Niente di meglio per le Qt in ambito Python
Il libro (del quale sono tuttora a metà) è veramente un'ottima guida alle Qt in ambito Python.
Copre una grande vastità di argomenti con chiarezza e facendo esempi validi di codice.
Ad ogni capitolo è inoltre presente un esercizio (Su internet tutti i codici del libro, sia esercizi sia quelli usati per la spiegazione).
Non credo ci sia un libro altrettanto valido per l'ambiente python.
Consigliato!