Review: Teach Yourself Python in 24 Hours
A.M. Kuchling
amk at 207-172-111-58.s58.tnt1.ann.va.dialup.rcn.com
Mon Oct 30 21:33:09 EST 2000
>From now on, whenever I complete a Python book review, I'll post it to
c.l.p. Book reviews are archived at my home page:
http://www.kuchling.com/python/books/ (note new URL!)
--amk
Review: Teach Yourself Python in 24 Hours
Ivan van Laningham
SAMS, 484 pages
ISBN: 0-672-31735-4
Summary: An introductory book on Python that's reasonably good on
the basics, though I'm doubtful of whether beginners will find the
book's explanation of object-oriented programming to be readily
understandable. The author's personality is entertainingly apparent
throughout, something sadly all too rare in computer books.
Unfortunately the book's production is poor, with hard-to-read
screenshots and many typos, knocking its ranking down by one. 3
coils out of five: a decent introduction, but definitely flawed.
The mere title of the SAMS "Teach Yourself X in 24 Hours" series
raises people's hackles at the presumptuous idea of learning a
significant new tool or skill in a single day's effort. (See Peter
Norvig's counterblast "Teach Yourself Programming in 10 Years" for a
stately example of the usual reaction.) The "24 Hours" of the titles
is a bit deceptive, though, actually meaning that the books are broken
into 24 chapters, each a one-hour lesson, that could be read over
several days. Completing them all within a single calendar day,
however, isn't really possible, despite the title implying that.
I've previously read another book in this series, "Teach Yourself GIMP
in 24 Hours", and found it quite useful in getting a broad overview of
the GIMP's features. "Teach Yourself Python" is similar, providing an
overview of Python that's fairly broad, not very rigorous or deep, and
doesn't attempt to be a reference. van Laningham's writing style is
conversational and fluid, with entertaining digressions into side
topics such as computing history or calendrical computations. One of
the delights in this book is the "Exercises" section at the end of
each chapter, containing open-ended suggestions for future projects
and links to related Web pages. van Laningham is clearly aware that
programming skill has a slippery definition and is gained as a craft
rather than a science, and tries to impress these points upon the
reader, something rare in introductory texts. I'd love to see this
writing style applied to broader topics of programming technique and
structuring, rather than the fiddly details of syntax and data types;
it would produce something similar to Richard P. Gabriel's Patterns of
Software or The Pragmatic Programmer by Hunt/Thomas.
The first 8 chapters of the book go over the well-trodden ground of
Python basics: the basic data types such as numbers, strings, lists,
and dictionaries; operators and variable assignment; flow control
statements; functions and modules. This section is solid and
straightforward.
I'm not sure chapters 9 through 13 on object-oriented programming
would be at all clear to a beginning programmer. It's difficult for me
to judge this, of course, and certainly when reviewing an introductory
book experienced programmers tend to attribute supernatural feebleness
to the intended audience and to underestimate their ability. Still, it
seems to me that the OOP chapters get pretty murky at times. While the
text is technically accurate, at times I had to read and parse
sentences very carefully to compare my understanding of Python
semantics with the book's explanation, and a beginning programmer
would find it difficult to follow the text, especially given that
there are no helpful diagrams. In particular the explanation of
namespaces seems particularly dense and confusing. Finally, the now
and today classes used for examples throughout these chapter are small
toy classes, meaning there's no particular motivation for making one
class inherit from the other. A more realistic example would have been
better.
Chapters 14 and 15 are quite good, following a simple file-munging
script from initial conception to development through to documentation
and modularization. While these chapters are the tail end of the
second part of the book, covering OO, the script doesn't use OOP at
all, and these chapters could have come earlier in the book and been
included in Part I. This would definitely be a better organization,
since these two chapters very good demonstrations of modifying a
program and of the importance of proper style, and show a small but
realistic motivating example.
The final eight chapters contain a brief introduction to Tkinter
that's reasonably good, though of course it's not possible to cover
Tkinter programming, or even every Tk widget, in 150 pages. It
probably provides enough information to learn more about Tkinter using
other resources.
My major gripe about the book, besides my concerns about the clarity
of the OO chapters, is its sloppy production; typos and formatting
errors are frequent, sometimes including misindented Python code in
the program listings. Interpreter interactions and the output of
Python code are shown using screen grabs of a Windows DOS shell,
resulting in tiny characters that are low-contrast and very difficult
to read, and wastes much space when the output is just a few lines.
More information about the Python-list
mailing list