This book provides an introduction to the Python programming language. Python is a popular object-oriented language used for both standalone programs and scripting applications in a variety of domains. It is free, portable, powerful, and remarkably easy to use.
Whether you are new to programming or a professional developer, this book's goal is to bring you up to speed on the core Python language in a hurry.
About This Second Edition
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:
· List comprehension (Chapter 14)
· Class exceptions (Chapter 25)
· String methods (Chapter 5)
· Augmented assignment (Chapter 8)
· Classic, true, and floor division (Chapter 4)
· Package imports (Chapter 17)
· Nested function scopes (Chapter 13)
· Generators and iterators (Chapter 14)
· Unicode strings (Chapter 5)
· Subclass types (Chapters 7 and 23)
· Static and class methods (Chapter 23)
· Pseudo-private class attributes (Chapter 23)
· Extended print and import statements (Chapters 8 and 18)
· New built-ins such as zip and isinstance (Chapters 7 and 10)
· New-style classes (Chapter 23)
. · New configuration and launch options, and .pth files (Chapter 3 and Appendix A)
· New development tools such as IDLE, Psyco, Py2exe, and Installer (Chapters 2, 3, and 29)
· New testing and documentation tools such as PyDoc, PyUnit, and doctest (Chapter 26)
Smaller language changes (e.g., long integer promotion, module export lists) appear throughout the book. Besides such language changes, we augmented the core lan- guage parts of this edition (Parts I-VII) with new topics and examples presented in the Python training sessions Mark has held in recent years. For example, you'll find:
· A new OOP introduction (Chapter 19)
· A new dynamic typing overview (Chapter 4)
· A new development tools summary (Chapter 26)
· New material on program architecture and execution (Chapters 2, 3, and 15)
· New coverage of documentation sources (Chapter 11)
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 modem 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.* 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.
Prerequisites
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.
This Book's Scope
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 complemented 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.
This Book's Style and Structure
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.
Core Language
This portion of the book presents the Python language, in a bottom-up fashion. It is organized with one part per major language feature--types, functions, and so forth--and most of the examples are small and self-contained (some might also call the examples in this section artificial, but they illustrate the points we're out to make). This section represents the bulk of the text, which tells you something about the focus of the book. It is composed of the following parts:
Part I, Getting Started
We begin with a general overview of Python, that answers commonly asked initial questions--why people use the language, what it's useful for, and so on. The first chapter introduces the major ideas underlying the technology, to give you some background context. This part then begins the technical material of the book, by exploring the ways that both you and Python run programs. Its goal is to give you just enough information to be able to work along with later examples and exercises. If you need more help getting started, additional configuration details are available in Appendix A.
Part II, Types and Operations
Next, we begin our tour of the Python language, by studying Python's major built-in object types in depth: numbers, lists, dictionaries, and so on. You can get a lot done in Python with these tools alone.
Part III, Statements and Syntax
The next part moves on to introduce Python's statements--the code you type to create and process objects in Python. It also presents Python's general syntax model.
Part IV, Functions
This part begins our look at Python's higher-level program structure tools. Functions turn out to be a simple way to package code for reuse.
Part V, Modules
Python modules let you organize statements and functions into larger components, and this part illustrates how to create, use, and reload modules.
Part VI, Classes and OOP
Here we explore Python's object-oriented programming (OOP) tool, the class. As you'll see, OOP in Python is mostly about looking up names in linked objects.
Part VII, Exceptions and Tools
We wrap up the core language coverage of this book section with a look at Python's exception handling model and statements, and a brief overview of development tools. This comes last, because exceptions can be classes if you want them to be.
Outer Layers
Part VIII samples Python's built-in tools, and puts them to use in a collection of small example programs. Common tasks are demonstrated in Python to give you some realworld context, using both the language itself, and its standard libraries and tools.
Chapter 27, Common Tasks in Python
This chapter presents a selection of the modules and functions that are included in the default Python installation. By definition, they comprise the minimum set of modules you can reasonably expect any Python user to have access to. Knowing
the contents of this standard toolset will likely save you weeks of work.
Chapter 28, Frameworks
This chapter presents a few real applications. By building on the language core explained in earlier parts and the built-in tools described in Chapter 27, we present many small but useful programs that show how to put it all together. We cover three areas that are of interest to most Python users: basic tasks, text
processing, and system interfaces. We close with a brief discussion of Jython, the Java port of Python, and a substantial Jython program.
Chapter 29, Python Resources
This chapter discusses the layers of the Python community and specialized libraries that are either part of the standard Python distribution or freely available from third parties.
Appendixes
The book ends with appendixes that give platform-specific tips for using Python on various platforms (Appendix A), and provide solutions to exercises that appear at the end of the last chapter in each part (Appendix B). Note that the index and table of contents can be used to hunt for details, but there are no reference appendixes in this book. As mentioned earlier, the Python Pocket Reference, Second Edition (O'Reilly), as well as other books and the free Python reference manuals maintained at http:// www.python.org, fill in syntax and built-in tool details.
Book Updates
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:
· http://www, oreilly.com (O'Reilly's site)
· http://www, rmi. net/~lutz (Mark's site)
· http://starship.python.net/~da (David's site)
· http://www.python.org (Python's main site)
· http://www, rmi.net/~lutz/about-lp, html (book's web page)
If we could be more clairvoyant, we would, but the Web changes faster than printed books.
Font Conventions
This book uses the following typographical conventions:
Italic
For email addresses, filenames, URLs, for emphasizing new terms when first introduced, and for some comments within code sections
Constant width
Shows the contents of files or the output from commands and to designate modules, methods, statements, and commands
Constant width bold
In code sections to show commands or text that would be typed
Constant width italic
Shows replaceables in code sections
[Constant width]
Represents syntactic units that you replace with real code
点击看大图
)
加载中...
