Product Description

Product Details

• Amazon Sales Rank: #57209 in Books
• Published on: 2005-03-18
• Original language: English
• Number of items: 1
• Binding: Paperback
• 844 pages

Features

• ISBN13: 9780596007973
• Condition: NEW
• Notes: Brand New from Publisher. No Remainder Mark.
• Click here to view our Condition Guide and Shipping Prices

Review
"I have no reservations recommending this book." - Tim Penhey, Cvu, February 2003

About the Author

Customer Reviews

Half-cooked
Good:

As other reviewers have pointed out, this book offers solutions for a broad range of programming problems. There is something for every level from beginner to expert (the most advanced examples were well over my head). The recipes are enhanced by discussions that are mostly very well and clearly written, giving insight into the design and logic of the presented recipes. They thus guide the way to adapting the recipes to your own programs.
So, most of the content of this book is good. 4-5 stars for that.

Bad / Production:

The recipes (so I gather) are mostly edited versions of what is available at ActiveState's online cookbook. However, the edited versions seem not to be available online (at least there is no pointer, and O'Reilly's website does not provide one either). Nor does the book include a CD. For all the hype in the book about this being a book by the Python community for the Python community, this is disappointing. Not even pointers are provided to on-line cookbook recipes that were used as starting points for those printed in this book. This is just bad craftsmanship on the part of O'Reilly. (On a similar note, the back cover promises a foreword by Guido but there isn't one.)

Bad / Content:

Sugar is sweet but bad for your health. So it is with this book - too many recipes add only (syntactic) sugar but no minerals and vitamins. Several 'shortcuts' are just wasted ink and breath - they will save you 1-2 lines of code when writing a function but then you have to import the shortcut implementation and get to make the extra function calls... Where these 'shortcuts' help to avoid some Python gotchas, it would have been more useful to just document the gotcha in question and show how to avoid it in straight Python code without any sugaring. Case in point: The once-only initialization of function default arguments. If you write:

def foo(bar=[])
bar.append(quux)

then previous quuxes will be lurking in the bars of every subsequent foo call that does not pass bar itself. So, you must write:

def foo(bar=None):
if not bar: bar=[]

to get an empty [] for every call. Now does this 'problem' merit a more elaborate, sugary 'solution'? I don't think so.

Some recipes are recipes for disaster. We are told how to automatically call the __init__ routines of every superclass... what we are not told is how to automatically call them in the appropriate order or with the respective arguments for making things work. How often do you write an __init__ that takes only the 'self' argument? Sure, it occurs, but... The omission of implicit superclass calls was a conscious design choice in Python and a wise one at that. Too many recipes like this one just want to show you how to subvert Python's conscious design choices. The sweet taste won't last but give way to heartburn.

For a book of this scope and design it is of course impossible to avoid criticism of the kind 'why did you include A but not B...'
Still, here goes:

XML: There are excellent libraries such as ElementTree and now cElementTree that offer fast, clean and 'Pythonic' alternatives to the standard library modules for XML parsing. More than just a URL pointer should have been provided.

Web programming: Only Jython and Twisted are mentioned as alternatives to CGI. Now Twisted may be the greatest thing since sliced bread, but ordinary mortals will never know, because it has about the the most confusing and unfathomable documentation of anything on the web (ooh I forgot Zope...). Presenting Twisted 'recipes' (or rather, plugs) with 'discussions' that drone about its power but are again just the same handwaving stuff as in the on-line docs is useless.

(If you just want to get your web stuff done with minimal pain: For simple PHP-like embedded scripting but with the advantages of Python, look at Spyce, and for an easy application server, look at Cherrypy or Webware).

So, altogether, a good book but not quite on par with e.g. Python in a Nutshell.

Valuable tricks&tips from _real_ Python experts
Of the many successes of Python, this is the least known but one of the most impressive: it has gained the affection and the respect of a hard guy like Alex Martelli. That is not an easy task for a small, interpreted programming language like Python.

When I first met Alex Martelli, at Think3, he was one of the oldest and most experienced programmers of the company, a programmer who had already used most of the existing languages and had used these languages for the development of large and complex applications, the kind of projects that took months or years to complete. He knew Perl very, _very_ well and was used to rely on a robust, elegant and sophisticated language like C++ for the development of his applications (like Think3's Thinkdesign, a very complex 3D CAD program). He was writing a _lot_ of software, using a large array of different languages and tools. He was a well respected internal consultant at Think3, charged to solve difficult problems related to the software architecture of the program being developed. He was not an easy guy to impress with "yet another small language".

Despite this, Python has gained some room in his heart. I consider this fact as one of the most significant success of this elegant and powerfull language. To be completely honest, I'm not completely surprised by this ending.

Alex Martelli is the kind of scientist and professional that appreciate elegance, wherever he can see it. The taste for elegance, the ability to take pleasure in elegance, is an important part of the scientist and engineer personality. It is hard to be a really good software professional without having any kind of interest for elegance. When you need a simple tool that can face complex problems, you are asking for elegance. When you need a language that leave you with maintenable code, you are asking for elegance. When you want a single language for a wide array of applications, you are asking for elegance. Python can supply you with all the elegance you can ever ask for.

Alex's and David's book is a collection of good techniques that you can use to face a large set of problems with Python, from text transformation to GUI building to OpenGL grahics. You will not find here an introductory book, rather you will find a good second-reading book, the kind of book that can take you from the beginner level to the advanced. It is also the kind of book that can widen your knowledge of the Python world, showing you how this modern language can easily deal with problems that you usually face with C++ or the like.

If you are looking for an introductory book, buy "Learning Python" by Mark Lutz and David Ascher: it is the best one for this task. If you already know Python, buy this book and see how much you still do not know about it.

Perfect
This is one of those rare books that is all meat and no fat. It is a wonderful collection of relevant and useful solutions for many programming problems that you will face, and many that you probably just figured were too hard to solve. It is clearly laid out, so finding a needed solution is easy.

One of the most powerful benefits of owning this book is astonishing amount of knowledge you can pick up by browsing it. With almost every recipe I discovered either a new approach to doing something with Python, that was far more elegant than what I would have thought of, or something that I didn't even consider was possible. It covers a vast array of important topics, from text processing, threads, object-oriented programming, and much more.

In short buy this book, grab a drink, and have a nice long sit-down session with it. You'll love every page of it.