community well since the first edition was published in 1999. Now, at its fourth edition, this book by
Mark Lutz continues to arguably be Python's bible. This article reviews this edition of the book by
discussing the target audience, scope, content, and pedagogical features. It concludes by a
This book is addressed as an introductory text to programmers new to Python. Although people with no
programming experience are not discouraged from reading it, they are warned that time is mostly spent
teaching Python, not programming fundamentals. I agree with this picture, though from my own
experience and those of others, the book is equally valuable to more experienced Python programmers
both as a pseudo-reference and as an introduction to more advanced topics. The critical point here is
that the book does not make assumptions about educational or vocational experiences and provides many examples; this renders the book approachable by a large audience.
Both Python 2.6 and 3.x are covered in this edition. However, the latest 3.x line is considered the
reference from which variations in 2.6 are discussed when appropriate. This approach is logical; the
new Python 3.x presents a major change to the language, but is not sufficiently dominant to warrant
This book discusses the Python language and excludes the
Python standard and non-standard libraries. The latter are discussed in other places including Lutz's
own Programming Python which stands at its third edition at the time of writing of this article. I
find this division necessary because of size considerations and, in fact, this division did not exist
in the first edition of the book! However, there is one topic that does not seem to fit the
language/libraries divide, and that topic is packaging and deployment.
I will argue that there are not many (if any) books that discuss packaging and deployment of Python
programs well. I will also argue that this topic should be included in the book being reviewed here
since it is so essential to real Python programming. Since Lutz discusses the Python runtime
environment, I do not think it detracts from the book's coherence to include a chapter on packaging.
It is possible that the proliferation of various packaging and deployment options such as distutils,
setuptools, pip, buildout, virtualenv, paver, fabric and others, is the reason for this exclusion. Or
it could be that these tools are in a state of major flux that any text will become quickly outdated.
If size is the reason for this exclusion, maybe Lutz or someone else can publish "Packaing and
Deploying Python" as a separate volume.
The book starts by building a case for the use of Python. Both the features of the language and its
prominent users are discussed to build credibility. Then, the runtime environment is discussed: how to
run programs in various ways on various operating systems and language interpreters.
Types and statements, which are at the core of any language, are discussed next. Notably, there is an
excellent discussion of the topic of iterators and generators (also discussed in a later chapter).
Functions, modules and classes are then introduced. The text also includes a discussion of general
object-oriented programming (OOP) principles which I find to be invaluable as it brings the topic of
classes to life.
Exceptions are introduced and discussed in detail. The placement here is appropriate since exceptions
are now objects in Python so classes had to be discussed first. This chapter should prove to be
especially useful for people migrating from other languages that do not have simple, yet effective,
Finally, four advanced topics are covered: decorators, Unicode, managed attributes, meta-classes. I
find the first two to be absolutely necessary for almost any system nowadays, even small ones! The
latter two are not as ubiquitous, but should be useful to more experienced programmers.
I should mention here that the discussion of the topics discussed above does not stop at the basics
but provides comprehensive coverage. This is evident in the discussion of concepts such as dynamic
typing, inheritance order, iterators, generators, comprehensions, and functional programming, among
many others. There is even an interlude on documentation and the pydoc library.
Like many programming texts, the book uses small programming examples (appropriately executed in the Python interactive shell). The small examples hope to capture the essence of the topic at hand, and
that, it does well within the limitations of a small-scale context. But this fourth edition adds a new
chapter on classes (Chapter 27) that contains a more realistic code example presented in a tutorial
In addition to examples, each chapter ends with a summary of the chapter's content as well as a quiz
on that content. The quiz is immediately followed by its answers for easy reference. I have to admit
that I do not use any of these two features, so I will not be able to comment on their efficacy.
Like many O'Reilly books, this is a well-written, coherent, and beautifully type-set book. I highly
recommend it to anyone who wants to, or already does, program using python. It should help the novice in the transition to an excellent programming language or, otherwise, make an already familiar environment more powerful in the hands of veterans.
About the author: Ahmed Al-Saadi is a Software Analyst who works for a Montreal Python house. He wrote his first lines of code on a Sinclair ZX Spectrum+, though unfortunately not in Python at the time.