To some extent, this edition’s structure is a result of this book’s history. The first edition of this book, written in 1995 and 1996, was the first book project to present the Python language. Its focus was broad. It covered the core Python language, and it briefly introduced selected application domains. Over time, the core language and reference material in the first edition evolved into more focused books Learning Python and Python Pocket Reference.
Given that evolution, the second edition of this book, written from 1999 to 2000, was an almost completely new book on advanced Python topics. Its content was an expanded and more complete version of the first edition’s application domain material, designed to be an application-level follow-up to the core language material in Learning Python, and supplemented by the reference material in Python Pocket Reference. The second edition focused on application libraries and tools rather than on the Python language itself, and it was oriented toward the practical needs of real developers and real tasks—GUIs, web sites, databases, text processing, and so on.
This third edition, which I wrote in 2005 and 2006, is exactly like the second in its scope and focus, but it has been updated to reflect Python version 2.4, and to be compatible with the upcoming Python 2.5. It is a minor update, and it retains the second edition’s design and scope as well as much of its original material. However, its code and descriptions have been updated to incorporate both recent changes in the Python language, as well as current best practices in Python programming.
You’ll find that new language features such as string methods,
enclosing-function scope references, list comprehensions, and new
standard library tools, such as the email package, have been integrated
throughout this edition. Smaller code changes—for instance, replacing
apply calls and exc_type usage with the newer func(*args) and exc_info( )—have been applied globally as
well (and show up surprisingly often, because this book is concerned
with building general tools).
All string-based, user-defined exceptions are now class-based,
too; string exceptions appeared half a dozen times in the book’s
examples, but are documented as deprecated today. This is usually just
a matter of changing to class
MyExc(Exception): pass, though, in one case, exception
constructor arguments must be extracted manually with the instance’s
args attribute. 'X' also became repr(X) across all examples, and I’ve
replaced some appearances of while
1: with the newer and more mnemonic while True:, though either form works as
advertised and C programmers often find the former a natural pattern.
Hopefully, these changes will future-proof the examples for as long as
possible; be sure to watch the updates page described later for future
Python changes.
One futurisms note: some purists might notice that I have not
made all classes in this book derive from object to turn on new-style class features
(e.g., class MyClass(object)). This
is partly because the programs here don’t employ the new-style model’s
slightly modified search pattern or advanced extensions. This is also
because Python’s creator, Guido van Rossum, told me that he believes
this derivation will not be required in Python 3.0—standalone classes
will simply be new-style too, automatically (in fact, the new-style
class distinction is really just a temporary regression due to its
incompatible search order in particular rare, multiple-inheritance
trees). This is impossible to predict with certainty, of course, and
Python 3.0 might abandon compatibility in other ways that break some
examples in this book. Be sure to both watch for 3.0 release notes and
keep an eye on this book’s updates page over time.
You’ll also notice that many of the second edition’s larger examples have been upgraded substantially, especially the two larger GUI and CGI email-based examples (which are arguably the implicit goals of much of the book). For instance:
The PyMailGUI email client is a complete rewrite and now supports sending and receiving attachments, offline viewing from mail save files, true transfer thread overlap, header-only fetches and mail caches, auto-open of attachments, detection of server inbox message number synchronization errors, and more.
The PyMailCGI email web site was also augmented to support sending and receiving mail attachments, locate an email’s main text intelligently, minimize mail fetches to run more efficiently, and use the PyCrypto extension for password encryption.
The PyEdit text editor has grown a font dialog; unlimited undo and redo; a configuration module for fonts, colors, and sizes; intelligent modified tests on quit, open, new, and run; and case-insensitive searches.
PyPhoto, a new, major example in Chapter 12, implements an image viewer GUI with Tkinter and the optional PIL extension. It supports cached image thumbnails, image resizing, saving images to files, and a variety of image formats thanks to PIL.
PyClock has incorporated a countdown timer and a custom window icon; PyCalc has various cosmetic and functionality upgrades; and PyDemos now automatically pops up examples’ source files.
In addition to the enhanced and new, major examples, you’ll also find many other examples that demonstrate new and advanced topics such as thread queues.
In addition to example changes, new topics have been added throughout. Among these are the following:
Part II, System Programming , looks at the
struct,mimetools, andStringIOmodules and has been updated for newer tools such as file iterators.Part III, GUI Programming , has fresh coverage of threading and queues, the PIL imaging library, and techniques for linking a separately spawned GUI with pipes and sockets.
Part IV, Internet Programming , now uses the new
emailpackage; covers running a web server on your local machine for CGI scripts; has substantially more on cookies, Zope, and XML parsing; and uses the PyCrypto encryption toolkit.Chapter 19, Databases and Persistence , has new ZODB examples and much-expanded coverage of the SQL API, including dozens of new pages on using MySQL and ZODB.
Chapter 21, Text and Language , has a new, gentler introduction to pattern matching and mentions Python 2.4 templates.
Chapter 22, Extending Python , now introduces
Distutilsand includes overviews of Pyrex, SIP, ctypes, Boost.Python, and CXX, in addition to offering updated SWIG coverage.
Beyond these specific kinds of changes, some material has been reorganized to simplify the overall structure. For example, a few chapters have been split up to make them less challenging; appendixes have been removed to save space (references are available separately); and the PyErrata web site example chapter has been removed (it didn’t present many new concepts, so we’ve made it and its code available in the book’s examples distribution as optional reading).
You’ll also find a new “Sneak Preview” chapter for readers in a hurry—a throwback to the first edition. This chapter takes a single example from command line to GUI to web site, and introduces Python and its libraries along the way.
Fundamentally, though, this edition, like the second, is still focused on ways to use Python rather than on the language itself. Python development concepts are explored along the way—in fact, they really become meaningful only in the context of larger examples like those in this edition. Code structure and reuse, for instance, are put into practice by refactoring and reusing examples throughout the book.
But in general, this text assumes that you already have at least a passing acquaintance with Python language fundamentals, and it moves on to present the rest of the Python story—its application to real tasks. If you find code in this book confusing, I encourage you to read Learning Python as a prelude to this text.
In the remainder of this preface, I’ll explain some of the rationales for this design, describe the structure of this edition in more detail, and give a brief overview of how to use the Python programs shipped in the book examples package.