Python Algorithms: Mastering Basic Algorithms in the Python Language (Expert's Voice in Open Source) [Englisch] [Taschenbuch]

Pros:
- Very clear explanation of a complex subject.
- Each chapter builds upon the previous chapters so that this is more like a class than a reference manual.
- More approachable that the Sedgewick and Cormen.

Cons:
- The almost constant parenthetical phrases distract from the text and quickly become irritating. After page 20 I just skipped them and found that I understood the concepts more quickly.
- The use of single letter variables in the code examples makes it more difficult to understand the structure of a new concept. When there are several of them, it can become confusing. (See page 207.) Why not just use descriptive variable names?

There are sections that make note of how to implement certain algorithms using Python specific features, and this is very helpful, but this is first and foremost a book on algorithmic theory that happens to use Python for code examples.

This book presents a quite broad range of fundamental computer science
algorithms, with all illustrative code written in Python. There is a
strong emphasis on graph algorithms, perhaps reflecting a predilection
of the author. Since I like graphs too I cannot complain about that.

Beyond the actual implementations, the book aims for extra Python
relevance by including asides on Python internals (CPython, to be
precise). I was pleasantly surprised by the ones included, as they go
beyond the trivial. Given the prevalence of graph algorithms heaps (or
priority queues) had to play a central role, and the aside on Python's
heapq module is perhaps the most important of them. I wish there were
more of the Pythonic asides, though.

Even so, the book makes clear how Python's carefully balanced design
enables beautiful, concise implementations. There is almost no low
level busy-work code, the algorithms practically read themselves. And
they are commented too just in case you find a piece difficult to
understand.

There's more to algorithms then the implementations, though: one has to
address correctness proofs and efficiency properties. The book
certainly doesn't neglect these, but if there's one clear downside (for
this reader) it is this: too much English, too few symbols. The author
goes to great lengths to use informal language instead of "math" when
discussing correctness and efficiency, and in the end I think he
overdoes it. Here's an example from Chapter 7, on greedy algorithms,
discussing the scheduling problem with hard deadlines, discrete time
and tasks of equal length:

"The last question then becomes, does S' have the same profit as S?
And indeed it does, because the T' cannot have a greater profit than T!
We can prove this by contradiction, based on our greed: if T' has a
greater profit, we would have considered it before T, necessarily
scheduling it somewhere else. (It would have been scheduled, because
there was at least one free slot before its deadline.) But we assumed
that we could extend P to S, and if it has a task in a different
position, we have a contradiction."

Perhaps it's just me (I have a math background) but if I were writing
code to run a nuclear power station I would not be comfortable with
proofs in this style.

I also think this might be a consequence of a more general attribute of
the book, namely its tendency to banter. Phrases like "Cool, no?" or
"This might hurt your brain" are numerous to the point of distracting -
again, for this reader, perhaps not so much for someone younger or with
a different background.

There are many exercises, with hints for solutions in an appendix. Each
chapter ends with an "If You're Curious" section which points you to the
relevant reference items in the bibliography and to some topics related
to, but deeper than, those discussed in the chapter. Some parts of the
text are set in a slightly larger and bolder font, with white titles on
black background. The purpose of this typographic device is not clear.
Maybe they are intended as general asides, but in some cases there are
back references to them later in the main text. In a technical book
this kind of thing is usually explained in the introduction, but not
here. Finally, as a fan I greatly appreciated the xkcd comic strips
included when relevant.

All in all, the book does a large part of what I expected of it. I
would recommend it most of all to someone already familiar with most of
the algorithms but not very familiar with Python, as a very good example
of Python's power. It can also work as a general introduction to the
algorithms, just be prepared to reach for the references in some cases
to clarify and expand your view.

I found Python Algorithms not only extremely helpful but an enjoyable read as well, not an easy task for an algorithm book. The text is conversational and well-organized, with numerous side notes that allow the reader to make insightful connections. The author's use of humor is not overwhelming, nor is it so sparse as to confuse novice readers to his intent. His use of sidebars can bog down the topics at times, but this has the advantage of making this text appropriate for readers of all skill levels.

The author also takes great pains to explain Python code within the book, which not only models well-written code to the reader but also takes advantage of eliminating pseudo-code with concrete examples of the Python language. The use of citations and notes on external sources within the book made it possible for me to independently research topics on the web. For more hands-on learners, there are exercises at the end of each chapter. This text could easily be the basis for a college-level class on Python and algorithm theory/development. All in all, a great text and a must-have for the Python programmer!