Review: Effective Python
Review: Effective Python, by Brett Slatkin
| Publisher: | Addison-Wesley |
| Copyright: | 2015 |
| ISBN: | 0-13-403428-7 |
| Format: | Trade paperback |
| Pages: | 216 |
I'm still looking for a programming language book that's as good as Joshua Bloch's Effective Java, which goes beyond its surface mission to provide valuable and deep advice about how to think about software construction and interface design. Effective Python is, sadly, not that book. It settles for being a more pedestrian guide to useful or tricky corners of Python, with a bit of style guide attached (although not as much as I wanted).
Usually I read books like this as part of learning a language, but in this case I'd done some early experimenting with Python and have been using it extensively for my job for about the past four years. I was therefore already familiar with the basics and with some coding style rules, which made this book less useful. This is more of an intermediate than a beginner's book, but if you're familiar with list and hash comprehensions, closures, standard method decorators, context managers, and the global interpreter lock (about my level of experience when I started reading), at least half of this book will be obvious and familiar material.
The most useful part of the book for me was a deep look at Python's object system, including some fully-worked examples of mix-ins, metaclasses, and descriptors. This material was new to me and a bit different than the approach to similar problems in other programming languages I know. I think this is one of the most complex and hard-to-understand parts of Python and will probably use this as a reference the next time I have to deal with complex class machinery. (That said, this is also the part of Python that I think is the hardest to read and understand, so most programs are better off avoiding it.) The description of generators and coroutines was also excellent, and although the basic concepts will be familiar to most people who have done parallelism in other languages, Slatkin's treatment of parallelism and its (severe) limitations in Python was valuable.
But there were also a lot of things that I was surprised weren't covered.
Some of these are due to the author deciding to limit the scope to the
standard library, so testing only covers unittest and not the (IMO
far more useful) pytest third-party module. Some are gaps in the
language that the author can't fix (Python's documentation situation for
user-written modules is sad). But there was essentially nothing here
about distutils or how to publish modules properly, almost nothing
about good namespace design and when to put code into __init__.py
(a topic crying out for some opinionated recommendations), and an odd lack
of mention of any static analysis or linting tools. Most books of this
type I've read are noticeably more comprehensive and have a larger focus on
how to share your code with others.
Slatkin doesn't even offer much of a style guide, which is usually
standard in a book of this sort. He does steer the reader away from a few
features (such as else with for loops) and preaches the
merits of decomposition and small functions, among other useful tidbits.
But it falls well short of Damian Conway's excellent guide for Perl,
Perl Best Practices.
Anyone who already knows Python will be wondering how Slatkin handles the conflict between Python 2 and Python 3. The answer is that it mostly doesn't matter, since Slatkin spends little time on the parts of the language that differ. In the few places it matters, Effective Python discusses Python 3 first and then mentions the differences or gaps in Python 2. But there's no general discussion about differences between Python 2 and 3, nor is there any guide to updating your own programs or attempting to be compatible with both versions. That's one of the more common real-world problems in Python at the moment, and was even more so when this book was originally written, so it's an odd omission.
Addison-Wesley did a good job on the printing, including a nice, subtle use of color that made the physical book enjoyable to read. But the downside is that this book has a surprisingly expensive retail ($40 USD) for a fairly thin trade paperback. At the time of this writing, Amazon has it on sale at 64% off, which takes the cost down to about the right territory for what you get.
I'm not sorry I read this, and I learned a few things from it despite having used Python fairly steadily for the last few years. But it's nowhere near good enough to recommend to every Python programmer, and with a bit of willingness to search out on-line articles and study high-quality code bases, you can skip this book entirely and never miss it. I found it oddly unopinionated and unsatisfying in the places where I wish Python had more structure or stronger conventions. This is particularly strange given that it was written by a Google staff engineer and Google has a quite comprehensive and far more opinionated coding style guide for Python.
If you want to dig into some of Python's class and object features or see a detailed example of how to effectively use coroutines, Effective Python is a useful guide. Otherwise, you'll probably learn some things from this book, but it's not going to significantly change how you approach the language.
Rating: 6 out of 10
My monthly report covers a large part of what I have been doing in the free software world. I write it for 
This might not be as good as you think
Master moved, the pull request is not up to date though it's still marked as passing integration.
If the pull request has not been updated with the latest version of its target branch, it might break your integration.
![[RSS 1.0 Feed]](common/rss10.png){kind=small}
![[RSS 2.0 Feed]](common/rss20.png){kind=small}
![[Atom Feed]](common/atom.png){kind=small}
![[FOAF Subscriptions]](common/foaf.png){kind=small}
![[OPML Subscriptions]](common/opml.png){kind=small}
![[Hacker]](common/hacker.png){kind=small}
![[Planet]](common/planet.png){kind=small}