Acquista usato
EUR 39,30
+ EUR 2,90 spedizione in Italia
Usato: Ottime condizioni | Dettagli
Venduto da worldofbooksit
Condizione: Usato: Ottime condizioni
Commento: The book has been read, but is in excellent condition. Pages are intact and not marred by notes or highlighting. The spine remains undamaged.
Ne hai uno da vendere?
Passa al retro Passa al fronte
Ascolta Riproduzione in corso... In pausa   Stai ascoltando un campione dell'edizione audio udibile.
Maggiori informazioni
Visualizza tutte le 3 immagini

Rapid GUI Programming With Python and Qt: The Definitive Guide to Pyqt Programming (Inglese) Copertina rigida – 29 ott 2007

5.0 su 5 stelle 4 recensioni clienti

Visualizza tutti i 4 formati e le edizioni Nascondi altri formati ed edizioni
Prezzo Amazon
Nuovo a partire da Usato da
Formato Kindle
"Ti preghiamo di riprovare"
Copertina rigida
"Ti preghiamo di riprovare"
EUR 81,18 EUR 39,30
click to open popover

Descrizione prodotto

Dalla quarta di copertina

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

L'autore

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.

Non è necessario possedere un dispositivo Kindle. Scarica una delle app Kindle gratuite per iniziare a leggere i libri Kindle sul tuo smartphone, tablet e computer.

  • Apple
  • Android
  • Windows Phone

Per scaricare una app gratuita, inserisci il numero di cellulare.



Dettagli prodotto

  • Copertina rigida: 625 pagine
  • Editore: Prentice Hall; 1 edizione (29 ottobre 2007)
  • Collana: Prentice Hall Open Source Software Development
  • Lingua: Inglese
  • ISBN-10: 0132354187
  • ISBN-13: 978-0132354189
  • Peso di spedizione: 1,2 Kg
  • Media recensioni: 5.0 su 5 stelle  Visualizza tutte le recensioni (4 recensioni clienti)
  • Posizione nella classifica Bestseller di Amazon: n. 125.816 in Libri in altre lingue (Visualizza i Top 100 nella categoria Libri in altre lingue)
  • Visualizza indice completo
  • Garanzia e recesso: Se vuoi restituire un prodotto entro 30 giorni dal ricevimento perché hai cambiato idea, consulta la nostra pagina d'aiuto sul Diritto di Recesso. Se hai ricevuto un prodotto difettoso o danneggiato consulta la nostra pagina d'aiuto sulla Garanzia Legale. Per informazioni specifiche sugli acquisti effettuati su Marketplace consultaMaggiori informazioni la nostra pagina d'aiuto su Resi e rimborsi per articoli Marketplace.

    Se sei un venditore per questo prodotto, desideri suggerire aggiornamenti tramite il supporto venditore?

Recensioni clienti

5.0 su 5 stelle
5 stelle
4
4 stelle
0
3 stelle
0
2 stelle
0
1 stella
0
Vedi tutte le 4 recensioni cliente
Condividi la tua opinione con altri clienti

Principali recensioni dei clienti

Formato: Copertina rigida Acquisto verificato
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!
Commento Una persona l'ha trovato utile. Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso
Formato: Copertina rigida Acquisto verificato
Sto studiando il python ed in particolare la realizzazione di interfacce grafiche con Qt.
Il libro è completo e semplice, ricco di esempi. I primi tre capitoli spiegano le basi del linguaggio python, i successivi illustrano la realizzazione di intterfacce grafiche anche complesse.
Molto utile.
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso
Formato: Copertina rigida Acquisto verificato
Ottimo libro, un paio di capitoli di riepilogo su Python; il resto con esempi che funzionano, esaurienti e ben spiegati. Consigliatissimo !
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso
Formato: Copertina rigida Acquisto verificato
it's the bible for pyqt, a must have!
the source code and errata are on the author's site and contain other info
Commento Questa recensione ti è stata utile? No Invio feedback...
Grazie del feedback.
Spiacenti, non siamo stati in grado di registrare il voto. Provare di nuovo.
Segnala un abuso

Le recensioni clienti più utili su Amazon.com (beta) (Potrebbero essere presenti recensioni del programma "Early Reviewer Rewards")

Amazon.com: 4.5 su 5 stelle 39 recensioni
127 di 131 persone hanno trovato utile la seguente recensione
4.0 su 5 stelle Worth having when time is money 7 dicembre 2007
Di The Conductor - Pubblicato su Amazon.com
Formato: Copertina rigida Acquisto verificato
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.
3 di 3 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle An absolute must-have for PyQt users 8 marzo 2011
Di Stephen Terry - Pubblicato su Amazon.com
Formato: Copertina rigida Acquisto verificato
I 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.
1 di 2 persone hanno trovato utile la seguente recensione
5.0 su 5 stelle Americium Dream help 13 maggio 2012
Di Americium Dream Documents - Pubblicato su Amazon.com
Formato: Copertina rigida Acquisto verificato
. this is an excellent gui-programming tutorial;
and, don't underestimate the importance of
the downloadable code samples;
because, the style of this book
is explaining each chunk of the code;
and, it's easy to lose sight of the big picture
without having both the book and code in front of you .
. if you don't already know Python,
pay attention to part I, a great beginner's tutorial
(this part is quite instructive without the code samples);
only then it will be obvious
how the object-oriented parts fit together;
so that the explanation of code chunks can fall into place .

. the author carefully explains all of the example code,
and the examples are strategically chosen to be
representative of everything pyqt is capable of doing;
but towards the middle of the book,
you realize the author definitely intends that you
read the pyqt documentation because otherwise
knowing how the authors code works
isn't going to help you with
implementing every design you might have in mind .
. this is in contrast to the front of the book,
where the tutorial on command-line python
may indeed give you a working a knowledge of python
without having to merge his work with the library documentation .
qubes recommended:
. this book is also recommended by an author of Qubes OS,
a xen-based, python scripted, high-security openware .
. they also recommend another of Summerfield's books
Programming in Python 3: A Complete Introduction to the Python Language (2nd Edition)
16 di 18 persone hanno trovato utile la seguente recensione
4.0 su 5 stelle Well-articulated, consistently informative introduction to Python and Qt 11 ottobre 2009
Di Harold Ramsbottom - Pubblicato su Amazon.com
Formato: Copertina rigida Acquisto verificato
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 di 10 persone hanno trovato utile la seguente recensione
3.0 su 5 stelle I find it amazing that he uses 3 chapters of the book to ... 26 marzo 2015
Di Alexander Smith - Pubblicato su Amazon.com
Formato: Copertina rigida Acquisto verificato
I'm a bit surprised with all these 5 star ratings. If you are familiar with Qt (written in C++) and you want to see examples of GUIs written in Python, and you want them to be fairly complicated, then this is your book. I find it amazing that he uses 3 chapters of the book to go over Python, yet not one chapter goes over Qt. In order to make sense of the examples you need to understand the classes that come from Qt. If you go to the qt documentation website, you'll find that there are hundreds of classes with thousands of methods. 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. He doesn't mention this at all. If you're familiar with Qt and many of those classes, you shouldn't have a problem with this book. I knew Python and knew nothing about Qt, so it was confusing and challenging to read until I found the qt documentation and read classes related to his example code, then and only then did the examples made sense. What would have appropriate is a chapter or two going over Qt, it's history, architecture and forewarn the readers that they should reference the documentation in order to understand the examples.
Another complaint is that he doesn't provide enough of the higher level picture before delving into the examples, as well as pointing out nuances you need to understand at points in time. He very curtly describes what the code does, which I applaud in that you don't have a 1000+ page book, it's very easy to misunderstand what's going on. 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.