Customer Reviews

The Quick Python Book, Second Edition

5 star:		(10)
4 star:		(1)
3 star:		(1)
2 star:		(0)
1 star:		(0)

 

 

"The Quick Python Book, Second Edition" is Vernon Ceder's reworking of the well-received volume "The Quick Python Book" by Daryl Harms and Kenneth McDonald. Ceder has removed a number of specialized chapters on COM, C & C++ extensions, JPython, HTMLgen & Zope and, more important, he has brought the text completely up to date, covering Python 3.1.

Most Python texts out there describe Python 2.x, so this book's main competition is: a) Mark Summerfield's "Programming in Python 3: A complete introduction to the Python Language, Second Edition", and b) Mark Pilgrim's "Dive into Python 3", while two other major books have incorporated material on Python 3, namely c) James Payne's "Beginning Python: Using Python 2.6 and Python 3.1" and d) Mark Lutz's "Learning Python: Powerful Object-Oriented Programming, 4th Edition".

The Good: this book is nice and short. It assumes a certain level of competence/background, so it does not waste space introducing the language-independent basics of flow control, object orientation, exception handling, and so on. It is example-based, and unlike in Pilgrim's volume the first few examples are short and thus readable. Chapter 3 ("The Quick Python overview") can be used as a compact reference when you're done reading the book, and various tables throughout the book help it function as a reference. Unlike its competition, it doesn't spend chapter upon chapter on databases, networking, or web applications. Instead, such topics are covered in only one (short) chapter at the end of the book. Ceder offers useful advice on the interrelation between older and newer Python features, whether discussing how to be more idiomatic (e.g. in chapter 6 on the format method vs % formatting, and in chapter 14 when introducing the "with" statement) or how to migrate from Python 2 to Python 3 (he devotes chapter 22 to this topic). On the publisher's website you can find a list of errata as well as the complete source code for the book. There you will see a link to an "Author online" forum in which you can interact with Ceder; perhaps more important, everyone who buys a paper copy of the book may also download a free PDF version. It is to be hoped that other publishers will follow Manning's example.

The Bad: the author is very clear that the book is aimed at those with experience in another programming language. Even so, in a few cases the assumptions are Python-specific (and hence unwarranted): one example is in chapter 5, where he lets us know that if x is a list then y=x[:] makes a copy of x, though this does not really explain why we cannot simply say y=x to accomplish the same goal. Another example: in chapter 12 Ceder uses character ranges expressed with [], though these are introduced much later (in chapter 17). Similarly, chapter 3 is quite good if you've already come into contact with Python before (even fleetingly). If you haven't, it may be obfuscating (though you could always just skip it on the first read). On a different note, this book does not contain exercises, though Summerfield's, Payne's, and Lutz's volumes do (along with answers). As mentioned in the previous paragraph, Ceder does not include too much extraneous stuff something which in my opinion is definitely a plus. However, he does not say absolutely anything on threading while Summerfield has a chapter on the subject and Payne a section. Similarly, Ceder does not mention function annotations at all, while Summerfield and Lutz each have a section on them. Finally, Ceder keeps referring the reader to the Python documentation for more details, and this can get frustrating. On the other hand, I suppose it would have been impossible for the book to stay at its current 320 pages otherwise.

Ceder's writing is concise, but this does not imply that he covers only the bare minimum of material. To pick a relatively advanced topic as an example, Ceder spends 2 pages on metaclasses, Summerfield 4.5 pages, Pilgrim and Payne devote half a page each only in the context of the changes from Python 2 to 3, while Lutz, in keeping with the mammoth size of his book, spends more than 30 pages on the topic. This (arbitrarily chosen) example is in some ways indicative of the wider approaches taken by the various Python 3 book authors.

In a nutshell, the fact that this book is considerably shorter than its competitors does not mean that it is shallow. The compactness is due partly to the author's succinct style of writing (which is not opaque, however) and partly to the fact that it does not contain too much on database programming, web services, and so on. All in all, if you're looking for a solid book on Python 3 that you stand a reasonable chance of reading cover-to-cover, then this is the volume you should buy. Four and a half stars.

Alex Gezerlis

This is the *best* book to learn Python for professional programmers or people that already know how to program on a different language.

If you're interested in learning Python but want to quickly get up to speed not only on the language itself but its real essence, its elegant syntax and effective coding style, this is really the book for you. It has all the basic stuff without the "fluff". You don't have to put up with basic tutorials for non-programmers or super advanced topics for language experts, Just what you need to start effectively writing Python code that is up to the standards of the Python community.

This won't be your only Python book, but it definitely has to be your first!!!

On the last few chapters it'll scratch the surface of more advanced topics and effectively point you to a wealth of online resources, where you'd be able to learn more and then decide if you want to continue on your own or pick a more advanced book focused on a specific topic.

It's a great book not only to learn the syntax and features, but grasp the "Zen" of Python which makes it such an elegant and "sexy" language.

I've been using Python for years on occasional scripting jobs and I must say there were gaps in my knowledge.
I found this book is filling in a lot of them: I'm learning dozens of things about Python I didnt know.
For me the style, which is concise and clear is pretty much perfect.

I have noticed things it doesnt cover, like Template strings, but dont expect it to cover all Python in the short space.

A very enjoyable book you can dip into!

Having read the wordy and heavy Learning Python 4th edition, this book is a welcome change for programmers new to Python who want a gentle but quick learning experience. Python versions have changed significantly in the last couple of years, and it is good to have a fresh book published in 2010 and based on Python 3.1, the latest and recommended edition. At only a little over 300 pages, this book does not intend to cover advanced topics, but is sufficient to get one up to speed on Python. The greatest strength is the author's style of writing and clarify in conveying concepts in succinct wording and appropriate code examples. With this book, I found great explanation and code examples for the difference between shallow and deep copy on page 56, and for decorator function on page 113. The organization and sequence of content makes sense, and the content is technically correct, except for some sloppy factual errors that are easy to spot, which fortunately don't reduce the value of the book much. (For example, on page 93, the range(10000000) function generates a sequence of integers from 0 up to 9999999, not 10000000 as stated in the book.) The typesetting of Manning books is first-rate as usual. I definitely recommend this book as the first book for learning Python. 4.5 stars out of 5 for the minor errors and the occasional lack of detailed explanation on a topic (such as the optparse module on page 132).

Vernon Cedar, an experienced teacher of Python at the Canterbury School in Fort Wayne, Indiana and a vociferous proponent of the Python Language has done a superb job of updating an excellent text for the Python 3.0 Language and Programming Environment. Many texts slowly handhold a beginner to establish proficiency in their first programming language, others provide an exhaustive (and EXHAUSTING) reference for all the features of a language definition. This excellent and efficient text provides a rapid path to Python 3.0 proficiency for the programmer who has had exposure to at least one other modern programming language.
It gives a rapid overview of the basic language features and programming environment to access its integration with the operating system, graphics libraries, regular expressions and other needed tools, all of this while respecting the needs talents and time limitations of the experienced programmer. It provides the most efficient path to the current version of Python for a Professional Programmer or Experienced Amateur while avoiding unnecessary details and laborious tutorials directed at the neophyte.

I would recommend this book highly to anyone who like myself has had exposure to several programming languages and who wishes to rapidly come up to speed with this batteries-included latest programming environment.

--Ira Laefsky
MSE/MBA IT Consultant
Formerly Senior Consultant with Arthur D. Little and DIGITAL Equipment Corporation

I've done some programming in a few other languages (Assembly, Basic, C, C#, C++, Java, Erlang, Matlab, GAMS, CUDA, Alloy, etc.), and out of the several dozen programming books on my shelf, this one is my second favorite (1st being K&R's ANSI C).

I'm not sure if an absolute beginner (i.e. no other programming exposure) would find the book as enjoyable as I did, and the more advanced users will probably be disappointed with lack of coverage of topics related to networking, parallel extensions (i.e., PyCUDA, etc.), scientific / engineering computing (SciPy, NumPy), but each of those topics can take up a whole tome and 1000+ page programming books are so tl;dr.

Of the topics that were covered, some are necessarily shallow (GUI development, parsing & regular expressions, data structures, etc.). But again, that's how K&R taught many generations C programming: Keep it simple enough to get started, and you can always learn how to overflow the stack later.

I have been coding for 15 years and am new to Python. After some research I decided to order this book and have loved it ever since. My reasons include:

* Clear organization
* Concise writing style
* An inviting design that makes me want to read this book
* Small, to-the-point chapters that tell you the most important things to know on a topic and do not bother you with unnecessary details.
* Comprehensive coverage of topics.

Highly recommend this book to Python nubes. Reading this book is so effortless that you will actually do it.

To paraphrase Einstein, a technical book should be as simple as possible, but not too simple. With the exception of a few typos (which should be corrected by the 3rd printing), I found this book to be thorough, clearly written, and enjoyable to read. As with most high level languages, a previous familiarity with other program languages is helpful for deeper comprehension, but not necessary. Now that I'm using python, I often find myself going back to this book to look up stuff rather than the mightier tomes sitting on my bookshelf. My only real quibble (communicated to the author) is reprinted below.

Ch. 14 and 15 should probably be in reverse order, since the Exception chapter (14) depends somewhat on the concept of Classes (e.g. inheritance), while the definition of Classes (15) is completely independent from the concept of Exceptions. Further, Classes and OO are central to Python, so by covering classes first, the Exceptions chapter becomes "now that you know about the core of python programming, here's how you handle exceptions" for better narrative flow.

This is exactly what is say it is, a quick primer to Python. For an experienced programmer like myself I was using Python in a few days after reading this short book.

The book does a good job of reviewing basic concepts of python. This is a good starter book. The only thing I didn't like about the book was that there was no exercises at the end of each chapter to practice writing python.