Customer Reviews

Python Programming Patterns

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

 

 

I'm a Python programmer who bought this book hoping for something that would describe how to implement object-oriented design patterns in Python. I was very disappointed.

First of all, I think the title of the book is misleading. This book is mostly an introduction to the Python language, not an introduction to design patterns in Python. It really doesn't have much discussion about design patterns outside of Chapter 5, which is devoted to the topic. And frankly, as an introduction to Python, it doesn't look that impressive.

Second, I think the writing is just poor. The author simply doesn't explain things very clearly. I tried to read chapter 5 on design patterns and came away with the impression that I was just reading gobbledy-gook.

So take this as one person's opinion, and nothing more. My background may be different from yours, and what looked like gobbledy-gook to me may be crystal-clear to you. But my advice is this: Do NOT buy this book sight unseen. If you're thinking of purchasing it, find a copy somewhere and look at it carefully before you buy it.

If you're looking for books to learn Python from, I recommend "The Quick Python Book" by Harms & McDonald, and "Python Essential Reference" by David Beazley. The best introductory book on design patterns is "Design Patterns Explained" by Shalloway & Trott. The best URL for information about design patterns and Python is:
* http://www.thinkware.se/cgi-bin/thinki.cgi/PythonPatterns
especially the links for:
* Design Patterns in Python
* Design Patterns mit Python (German, but the code is Python)

Gordon Macmillan, one of the technical editors of the book, gives a good description of the book in a thread on comp.lang.python:
http://groups.google.com/groups?hl=en&threadm=Xns917F8DF4EC2C3gmcmhypernetcom%40199.171.54.215&prev=/groups%3Fhl%3Den%26group%3Dcomp.lang.python

Many of the reviewers here seem rightly disappointed that Python Programming Patterns is not a Design Patterns book rewritten with Python source examples. When I bought this I was expecting something similar, and was at first dismayed that PPP wasn't that book. But as I started to read through it, I realized that this was the first book I'd seen which actually focused on *Engineering* solid and comprehensive solutions in Python. If you want to know how to write a 'Hello Python' application, look elsewhere. For all the rest of us needing some insight into how best to apply Python to problems of any complexity, there is no more appropriate book out there.

This book definitely could use a different title as it sets an expectation level that is, admittedly, different from what readers familiar with programming patterns would mean by the term "patterns". This is moreso a book on techniques for programming Python effectively and less so a book on patterns per se. That said, there are many good things about this book, and those who actually *look* at the programming examples will see that patterns and the vocabulary of patterns (as defined in the "Gang of Four" book) are clearly evident throughout the book.

Here are a few positive points about the book:

1. It is one of the few books where a good number of the patterns are used in non-trivial examples instead of the abstract examples found in other patterns-related books, including the "Gang of Four" book.

2. It is one of the few books that addresses concurrency patterns, including excellent discussions on threading techniques and transactions.

3. It provides real details on how to address data structuring needs not supported directly by Python's intrinsic support for lists and dictionaries.

In conclusion, there is no doubt that this is not the "Hello, World" book and could benefit from a different title. However, if you are looking for real code examples that actually use patterns, this book might be one of the few places where you'll actually find what you are looking for.

Alot of discussion has focused on the title of the book. So, it's not a classic "design patterns" book but if you take a second to look at the table of contents you'll figure that out pretty fast. The introduction even states the following in a section titled, "What the Book is Not" - "... this book cannot be a hard-core object-oriented design patterns book." I don't think that's a problem with this book.

What I think this book does well is cover alot of ground on writing python with some pretty good examples that go beyond the usual intro book stuff. There is talk of threads, regular expressions, abstract data types, modules etc... stuff you need to do real work but that usually gets left out. To me this is really a kind of python for programmers type book with some very good examples. If that's what you're looking for then check out the table of contents. I liked it.

It is interesting to note that the Mar. 1 review is by the author of the book, who fails to identify himself in the review and gives himself a 5 star rating.

I bought this book and The Complete Python Reference at the same time, and read this book second. Some of my impressions are tainted by this order, since The Complete Python Reference is so well constructed and written.

Python Programming Patterns seemed like a title looking for a book, when you get inside of it. I was hoping for an more advanced/coherent treatment of the subject, but got a jumbled-up collection of the obligatory OO discusions found everywhere, basic Python coding treated better elsewhere, and examples from fringe applications that were tedious to follow without specific knowledge of that application.

I scanned it and put it on the bookshelf for one of those days when I've exhausted all other resources and have to open it again.

Even though the book is light on true examination of the 20 object oriented patterns it contains, it is a great python book. I use the book as a reference and I must tell you that I feel that you get your moneys worth with this book, thus it gets 5 stars...

There is a need for a decent book on Python OOP and patterns, but this is not it. This book is simply a poor intro text with a some buzzwords slapped on the front cover. I have not found any of it useful. Try a google search instead.

I was disappointed in this book for essentially the same reasons as Stephen Ferg (see his review dated Dec. 19/2001). I find that the book does not do justice to the 'Patterns' buzzword.

I suggest you read Stephen's review before you buy this book. I will not rewrite the same comments here. The reason I am writing this review is to say that I find unacceptable that the author would review his own book here, not clearly identify himself as the author, give it 5 stars, and be so vain in his review. I believe in modesty and letting the readers decide for themselves (isn't this what Amazon's review system is for?) as opposed to what the author has done here. Also, as of this writing there is only one person who voted Stephen's review to be 'not helpful' -- and I would not be surprised in the least if it was the author himself put in that vote..!

I keep Python Programming Patterns close so I can look up details of the Python language and the functions, objects, and methods in modules I use frequently. I also use objects whose code is presented in the book: DEQueue (double-ended queue), Set, and RunQueue especially. I wrote the kind of book I want to use myself.
The goal of PPP is to teach you the Python language emphasizing the facilities that you will use to build larger programs, i.e. programs of several thousand lines.
Of particular interest is the section on abstract data types. I use ADT's, especially container ADTs, all the time. ADTs are new data types implemented in the language itself. To implement an ADT, you create a class, use other data structures for the "encapsulated" representation of the data, and write methods to provide operations on these types. You use "special methods" to implement unary operators, binary operators, subscripting, slicing, and attribute access, but these special methods have intricacies that you will need to know to use them. PPP explains them.
The section on concurrency are also noteworthy: it provides what I consider the best explanation of Python's threading module of all I have seen published. As an author of "High-Performance Java Platform[TM] Computing," I am an expert on threading.
PPP takes a broad definition of "patterns," including more than object-oriented design patterns. It presents concurrent programming patterns such as monitors, deadlock, producer-consumer and transactions, and it considers higher-level approaches to programming such as structured programming, modular programming, and functional programming.
Someone who knows object-oriented programming in another language will find useful information on how dynamically typed Python differs from statically typed languages such as Java or C++. Object-oriented design patterns (OODPs) are presented from a data-structures point of view, a "here's how the objects are linked together and what they do" presentation. The OODPs are used in examples throughout, but OODPs are only a part of the book.
I hope you like it as much as I do.