In the four years after the first edition of this book was published in late 1998, there have been substantial changes in both the Python language and in the topics presented by the authors in Python training sessions. Although we have attempted to retain as much of the original version as possible, this new edition reflects recent changes in both Python and Python training.

On the language front, this edition has been thoroughly updated to reflect Python 2.2, and all changes to the language since publication of the first edition. In addition, discussion of anticipated changes in the upcoming 2.3 release have been incorporated throughout. Some of the major language topics for which you’ll find new or expanded coverage in this edition are:

Smaller language changes (e.g., long integer promotion, module export lists) appear throughout the book. Besides such language changes, we augmented the core language parts of this edition (Part I-Part VII) with new topics and examples presented in the Python training sessions Mark has held in recent years. For example, you’ll find:

Many core language part additions and changes were made with beginners in mind. You’ll also find that the coverage of many original core language topics has been substantially expanded in this edition, with new discussion and examples. Because this text has largely become the primary resource for learning the core Python language, we’ve taken liberties with making that coverage more complete than before, and added new use cases throughout. Likewise, we updated Part VIII to reflect recent Python application domains, and modern usage patterns.

In addition, this entire edition integrates a new set of Python tips and tricks, gleaned from both teaching classes over the last seven years, and using Python for real work over the last decade. The exercises have been updated and expanded to reflect current Python practice, new language features, and common beginner mistakes we’ve witnessed first-hand in recent years. Overall, this edition is bigger, both because Python is bigger, and because we’ve added context that has proved to be important in practice.

To accommodate the fact that this edition is more complete, we’ve split most of the original chapters into bite-sized chunks. That is, we’ve reorganized the core language section into many multichapter parts, to make the material easier to tackle. Types and statements, for instance, are now two top-level parts, with one chapter for each major type and statement topic. This new structure is designed to allow us to say more, without intimidating readers. In the process, exercises and gotchas were moved from chapter ends to part ends; they now appear at the end of the last chapter in each part.

Despite all the new topics, this book is still oriented toward Python newcomers, and is designed to be a first Python text for programmers.^[1] It retains much of the first edition’s material, structure, and focus. Where appropriate, we have expanded introductions for newcomers, and isolated the more advanced new topics from the main thread of discussion to avoid obscuring the fundamentals. Moreover, because it is largely based on time-tested training experience and materials, this edition, like the first, can still serve as a self-paced introductory Python class.

There are none to speak of, really. This book has been used successfully by both absolute beginners, and crusty programming veterans. In general, though, we have found that any exposure to programming or scripting before this text can be helpful, even if not required for every reader.

This book is designed to be an introductory level Python text for programmers. It may not be an ideal text for someone who has never touched a computer before (for instance, we’re not going to spend any time explaining what a computer is), but we haven’t made many assumptions about your programming background or education.

On the other hand, we won’t insult readers by assuming they are “dummies” either, whatever that means; it’s easy to do useful things in Python, and we hope to show you how. The text occasionally contrasts Python with languages such as C, C++, Java, and Pascal, but you can safely ignore these comparisons if you haven’t used such languages in the past.

One thing we should probably mention up front: Python’s creator, Guido van Rossum, named it after the BBC comedy series Monty Python’s Flying Circus. This legacy has inevitably added a humorous flavor to many Python examples. For instance, the traditional “foo” and “bar” become “spam” and “eggs” in the Python world, and in some of the code you’ll see in this book. The occasional “Brian,” “Ni,” and “shrubbery” likewise owe their appearances to this namesake. You don’t need to be familiar with the series to make sense of such examples (symbols are symbols), but it can’t hurt.

Although this book covers all the essentials of the Python language, we’ve kept its scope narrow in the interest of speed and size. To keep things simple, this book focuses on core concepts, uses small and self-contained examples to illustrate points, and sometimes omits the small details that are readily available in reference manuals. Because of that, this book is probably best described as both an introduction and a stepping stone to more advanced and complete texts.

For example, we won’t say much about Python/C integration—a complex topic, which is nevertheless central to many Python-based systems. We also won’t talk much about Python’s history or development processes. And popular Python applications such as GUIs, system tools, and network scripting get only a short survey, if they are mentioned at all. Naturally, this scope misses some of the big picture.

By and large, Python is about raising the quality bar a few notches in the scripting world. Some of its ideas require more context than can be provided here, and we’d be remiss if we didn’t recommend further study after you finish this book. We hope that most readers of this book will eventually go on to gain a more complete understanding of application-level programming from other texts.

Because of its beginners’ focus, Learning Python is designed to be naturally complimented by O’Reilly’s other Python books. For instance, Programming Python, Second Edition provides larger and more advanced application-level examples, and was explicitly designed to be a follow-up text to the one you are reading now. Roughly, the second editions of Learning Python and Programming Python reflect the two halves of Mark’s training materials—the core language and applications programming. In addition, O’Reilly’s Python Pocket Reference, Second Edition, serves as a quick reference supplement for looking up the fine details we will largely skip here.

Other followup Python books can also help provide additional examples, explore specific Python domains, and serve as references. We recommend O’Reilly’s Python in a Nutshell and New Riders’ Python Essential Reference as references, and O’Reilly’s Python Cookbook as an example library. Regardless of which books you choose, you should keep in mind that the rest of the Python story requires studying examples that are more realistic than there is space for here. There are roughly 40 English language Python books available today, along with a few dozen foreign language texts. Because books are a subjective experience, we invite you to browse all available texts to find one that suits your needs.

But despite its limited scope (and perhaps because of it), we think you’ll find this book to be a good first text on Python. You’ll learn everything you need to get started writing useful standalone Python programs and scripts. By the time you’ve finished this book, you will have learned not only the language itself, but also how to apply it to day-to-day tasks. And you’ll be equipped to tackle more advanced topics and examples as they come your way.

Much of this book is based on training materials developed for a three-day hands-on Python course. You’ll find exercises at the end of the last chapter of the core language parts, with solutions to all exercises in Appendix B. The exercises are designed to get you coding right away, and are usually one of the highlights of the course.

We strongly recommend working through the exercises along the way, not only to gain Python programming experience, but also because some exercises raise issues not covered elsewhere in the book. The solutions in Appendix B should help if you get stuck (and we encourage you to “cheat” as much and as often as you like). Naturally, you’ll need to install Python to run the exercises.

Because this text is designed to introduce language basics quickly, we’ve organized the presentation by major language features, not examples. We’ll take a bottom-up approach here: from built-in object types, to statements, to program units, and so on. Each chapter is fairly self-contained, but later chapters use ideas introduced in earlier ones (e.g., by the time we get to classes, we’ll assume you know how to write functions), so a linear reading makes the most sense. From a broader perspective, this book is divided into the following functional areas, and their corresponding parts.

Improvements happen (and so do mis^H^H^H typos). Updates, supplements, and corrections for this book will be maintained (or referenced) on the Web at one of the following sites:

If we could be more clairvoyant, we would, but the Web changes faster than printed books.

This book uses the following typographical conventions:

In our examples, the % character at the start of a system command line stands for the system’s prompt, whatever that may be on your machine (e.g., C:Python22> in a DOS window). Don’t type the % character yourself! Similarly, in interpreter interaction listings, do not type the >>> and . . . characters shown at the start of lines—these are prompts that Python displays. Type just the text after these prompts. To help you remember this, user inputs are shown in bold font in this book. Also, you normally don’t need to type text that starts with a # in listings; as we’ll explain later, these are comments, not executable code.

This book, and all the program examples in it, are based on Python Version 2.2, and reflect the upcoming 2.3 release. But since we’ll stick to the core language, you can be fairly sure that most of what we have to say won’t change very much in later releases of Python. Most of this book applies to earlier Python versions too, except when it does not; naturally, if you try using extensions added after the release you’ve got, all bets are off. As a rule of thumb, the latest Python is the best Python. Because this book focuses on the core language, most of it also applies to Jython, the Java-based Python language implementation, as well other Python implementations, described in Chapter 2.

Source code for the book’s examples, as well as exercise solutions, can be fetched from the book’s web site at http://www.oreilly.com/catalog/lpython2/. So how do you run the examples? We’ll get into startup details in Chapter 3, so please stay tuned for the details on this front.

This book is here to help you get your job done. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission.

We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: "ActionScript: The Definitive Guide, Second Edition, by Colin Moock. Copyright 2001 O’Reilly & Associates, Inc., 0-596-00369-X.”

If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at [email protected].

Please address comments and questions concerning this book to the publisher:

We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at:

To comment or ask technical questions about this book, send email to:

For more information about our books, conferences, Resource Centers, and the O’Reilly Network, see our web site at:

Mark and David are also both happy to answer book questions from readers, though you’re more likely to get a response by sending “Core Language” questions to Mark, and “Outer Layer” queries to David, the two area’s respective primary authors. You can find both of the authors’ email addresses at the book’s web site.

(Throughout this book, we normally use “we” to refer to both authors, but occasionally slip into a specific author’s name for personal anecdotes—usually Mark in the Core Language parts, and David in the Outer Layers parts, reflecting the primary author of each part. Although this book was a joint effort of many, each author sometimes steps out of the collective.)

We’d like to express our gratitude to all the people who played a part in developing this book. First of all, we’d like to thank the editors that worked on this project: Laura Lewin, Paula Ferguson, and finally Linda Mui. We’d also like to thank O’Reilly in general, for supporting another Python book project. We’re glad to be a part of what is now a full and growing Python product line at O’Reilly.

Thanks also to everyone who took part in the early review of this book—Guido van Rossum, Alex Martelli, Anna Ravenscroft, Sue Giller, and Paul Prescod.

And for creating such an enjoyable and useful language, we owe an especially large debt to Guido, and the rest of the Python community; like most open source systems, Python is the product of many heroic efforts.

We’d also like to give a special thanks to our original editor on this book, the late Frank Willison. Frank had a profound impact on both the Python world, and our own personal careers. It is not an overstatement to say that Frank was responsible for much of the fun and success of Python’s early days. In fact, this very book was his idea. In recognition of his vision and friendship, we dedicate this update to him. Hack on, Frank.