Review: Effective Python, by Brett Slatkin

Russ Allbery eagle at eyrie.org
Sun Jul 15 18:28:24 PDT 2018


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 co-routines 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 odd 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

Reviewed: 2018-07-15

-- 
Russ Allbery (eagle at eyrie.org)              <http://www.eyrie.org/~eagle/>


More information about the book-reviews mailing list