Python编程(英文影印版)(第四版 上下册)

.15. server-side scripting
16. the pymailcgi server
part v. tools and techniques
17. databases and persistence
18. data structures
19. text and language
20. python/c integration
part vi. the end
21. conclusion: python and the development cycle
index

.　　The former of these constraints reflects the fact that core language topics are the exclusive domain of Learning Python, and I encourage you to consult that book before tackling this one if you are completely new to the Python language, as its topics are assumed here. Some language techniques are shown by example in this book too, of course, and the larger examples here illustrate how core concepts come together into realistic programs. OOP, for example, is often best sampled in the context of the larger programs we'll write here. Officially, though, this book assumes you already know enough Python fundamentals to understand its example code. Our focus here is mostly on libraries and tools; please see other resources if the basic code we'll use in that role is unclear.
　　The latter of the two constraints listed above reflects what has been a common misconception about this book over the years (indeed, this book might have been better titled Applying Python had we been more clairvoyant in 1995). I want to make this as clear as I can: this is not a reference book. It is a tutorial. Although you can hunt for some details using the index and table of contents, this book is not designed for that purpose. Instead, Python Pocket Reference provides the sort of quick reference to details that you'll find useful once you start writing nontrivial code on your own. There are other reference-focused resources available, including other books and Python's own reference manuals set. Here, the goal is a gradual tutorial that teaches you how to apply Python to common tasks but does not document minute details exhaustively.About This Fourth Edition
　　If this is the first edition of this book you've seen, you're probably less interested in recent changes, and you should feel free to skip ahead past this section. For readers of prior editions, though, this Fourth Edition of this book has changed in three important ways:
　　It's been updated to cover Python 3.X (only).
　　It's been slimmed down to sharpen its focus and make room for new topics.
　　It's been updated for newly emerged topics and tools in the Python world.
　　The first of these is probably the most significant--this edition employs the Python 3.X language, its version of the standard library, and the common practice of its users. To better explain how this and the other two changes take shape in this edition, though,I need to fill in a few more details.
　　Specific Changes in This Edition
　　Because the prior versions of this book were widely read, here is a quick rundown ofsome of the most prominent specific changes in this edition:
　　Its existing material was shortened to allow for new topics
　　The prior edition of this book was also a 1600-page volume, which didn't allow much room for covering new Python topics (Python 3.X's Unicode orientation alone implies much new material). Luckily, recent changes in the Python world have allowed us to pare down some less critical existing material this time around, in order to free up room for new coverage.
　　Depth was not sacrificed in the process, of course, and this is still just as substantial a book as before. In general, though, avoiding new growth was a primary goal of this update; many of the other specific changes and removals I'll mention below were made, in part, to help accommodate new topics.
　　It covers 3.X (only)
　　This book's examples and narrative have been updated to reflect and use the 3.X version of Python. Python 2.X is no longer supported here, except where 3.X and 2.X Pythons overlap. Although the overlap is large enough to make this of use to 2.X readers too, this is now officially a 3.X-only text.
　　This turns out to be a major factor behind the lack of growth in this edition. By restricting our scope to Python 3 .X--the incompatible successor to the Python 2.X line, and considered to be Python's future--we were able to avoid doubling the coverage size in places where the two Python lines differ. This version limit is es- pecially important in a book like this that is largely about more advanced examples, which can be listed in only one version's style.
　　For readers who still straddle the 2.X and 3.X worlds, I'll say more about Python 3.X changes later in this Preface. Probably the most significant 3.X-related change described there is the new Internationalization support in PyEdit and PyMailGUI; though 2.X had Unicode too, its new prominence in 3 .X almost forces such systems to rethink their former ASCII-only ways.
　　Inclusion of newly emerged libraries and tools
　　Since the prior edition, a variety of new libraries and tools have either come online or risen in popularity, and they get new mention here. This includes new standard library tools such as subprocess (in Chapters 2 and 3) and multiprocessing (in Chapter 5), as well as new third-party web frameworks and ORM database toolkits. Most of these are not covered extensively (many popular third-party extensions are complex systems in their own right and are best covered by dedicated books), but they are at the least introduced in summary form here.
　　For example, Python 3.1's new tkinter.ttk Tk themed widget set shows up in Chapter 7 now, but only briefly; as a rule, this edition prefers to mention such extensions in passing, rather than attempting to show you code without adequate explanation.
　　This Preface was tightened up
　　I've removed all the instructions for using and running program examples. Instead, please consult the README file in the examples distribution for example usage details. Moreover, most of the original acknowledgments are gone here because they are redundant with those in Learning Python; since that book is now considered a prerequisite, duplication of material here is unwarranted. A description of book contents was also deleted; please see the table of contents for a preview of this book's structure.
　　The initial Python overview chapter is gone
　　I've removed the prior edition's "managerial summary" chapter which introduced Python's strong points, prominent users, philosophies, and so on. Proselytizing does play an important role in a field that sometimes asks the "why" questions less often than it should. Indeed, if advocacy had not been part of the Python experi- ence, we'd probably all be using Perl or shell languages today!
　　However, this chapter has now grown completely redundant with a similar chapter in Learning Python. Since that book is a precursor to this one, I opted to not devote space to restating "Pythonista" propaganda here (fun as it may be). Instead, this book assumes you already know why Python is worth using, and we jump right into applying it here.
　　The conclusion's postscripts are gone
　　This book's conclusion comes from the first edition, and it is now 15 years old. Naturally, some of it reflects the Python mindset from that period more than that of today. For example, its focus on Python's role in hybrid applications seemed more important in 1995 than in 2010; in today's much larger Python world, most Python users never deal with linked-in C code at all.
　　In prior editions, I added postscripts for each edition to elaborate on and update the ideas presented in the book's conclusion. These postscripts are gone now, re- placed by a short note at the start of the conclusion. I opted to keep the conclusion itself, though, because it's still relevant to many readers and bears some historic value. Well, that, plus the jokes...
　　The forewords are gone
　　For reasons similar to those of the prior two points, the accumulated forewords from the prior three editions were also dropped this time around. You can read all about Python creator Guido van Rossum's historical rationale for Python's evolu- tion in numerous places on the Web, ifyou are so inclined. Ifyou are interested in how Python has changed technically over the years, see also the "What's New" documents that are part of the Python standard manuals set (available at http:// www.python.org/doc, and installed alongside Python on Windows and other platforms).
　　The C integration part has been reduced to just one chapter
　　I've reduced the C extending and embedding part's material to one shorter chapter at the end of the tools part, which briefly introduces the core concepts in this domain. Only a fraction of Python users must care about linking in C libraries today, and those who do already have the skills required to read the larger and more complete examples of integration present in the source code of Python itself. There is still enough to hint at possibilities here, but vast amounts of C code have been cut, in deference to the better examples you'll find in Python's own code.
　　The systems programming part was condensed and reworked
　　The former two larger system examples chapters have been merged into one shorter one, with new or greatly rewritten examples. In fact, this part (Part II) was probably overhauled the most of any part in the book. It incorporates new tools such as subprocess and multiprocessing, introduces sockets earlier, and removes dated topics and examples still lingering from prior editions. Frankly, a few of the file- oriented examples here dated back to the 1990s, and were overdue for a general refresh. The initial chapter in this part was also split into two to make its material easier to read (shell context, including streams, gets its own chapter now), and a few large program listings here (including the auto-configuring launcher scripts) are now external suggested reading.
　　Some larger examples were removed (but are available in the examples distribution) Along the same lines, two of the larger GUI examples in the prior edition, PyTree and PyForm, have been removed. Instead, their updated code is available in the book's examples distribution package, as suggested supplemental reading. You'll still find many larger examples covered and listed in this edition--including both GUI- and Web-based renderings of full-featured email clients, along with image viewers, calculators, clocks, Unicode-aware text editors, drawing programs, re- gression test scripts, and more. However, because the code of the examples re- moved doesn't add much to what is already covered, and because they were already largely self-study examples anyhow, I've made them optional and external to the printed text in this edition.
　　The advanced Internet topics chapter was replaced by brief summaries I've cut the advanced Internet topics chapter completely, leaving only simple sum- maries at the start of the Internet part (intentionally mirroring the GUI option summaries at the start of the GUI part). This includes prior coverage for tools such as the ZOPE web framework, COM, Windows active scripting and ASP,
　　HTMLgen, Python Server Pages (PSP), Jython, and the now very dated Grail sys- tem. Some of these systems still receive honorable mention in the summaries, but none are now presented in any sort of detail. Summaries of new tools (including many of those listed in the following paragraph) were added to this set, but again, in brief fashion with no example code.
　　Despite authors' best attempts to foresee the future, the Web domain evolves faster than books like this can. For instance, Web frameworks like Django, Google's App Engine, TurboGears, pylons, and web2py are now popular alternatives to ZOPE. Similarly, the .NET framework supersedes much of COM on Windows;
　　IronPython now provides the same type of integration for .NET as Jython did first Python allows us to avoid additional growth here. Please see that book for more on these subjects.
　　Other random bits
　　Naturally, there were additional smaller changes made along the way. For example, tkinter's grid method is used instead of pack for layout of most input forms, because it yields a more consistent layout on platforms where label font sizes don't match up with entry widget height (including on a Windows 7 netbook laptop, this edi- tion's development machine). There's also new material scattered throughout, in- cluding a new exploration of redirecting streams to sockets in the Internet part; a new threaded and Unicode-aware "grep" dialog and process-wide change tests on exit in the PyEdit example; and other things you are probably better off uncovering along the way than reading further about in this Preface.
　　! also finally replaced some remaining "#" comment blocks at the top of source files with docstrings (even, for consistency, in scripts not meant to be imported, though some "#" lines are retained in larger examples to offset the text); changed a few lingering "while 1" to "while True"; use += more often; and cleaned up a few other cases of now-dated coding patterns. Old habits may die hard, but such up dates make the examples both more functional and more representative of common practice today.
　　Although new topics were added, all told, four chapters were cut outright (the nontechnical introduction, one of the system example chapters, advanced Internet topics,and one integration chapter), some additional examples and material were trimmed (including PyForm and PyTree), and focus was deliberately restricted to Python 3.X and application fundamentals to conserve space.
　　What's Left, Then?
　　The combined effect of all the changes just outlined is that this edition more concisely and sharply reflects its core focus--that of a tutorial introduction to ways to apply Python in common programming domains. Nevertheless, as you can tell from this book's page count, it is still a substantial and in-depth book, designed to be a first step on your path to mastering realistic applications of Python.
　　Contrary to recent trends (and at some risk of being branded a heretic), I firmly believe that the job of books like this one is to elevate their readers, not pander to them. Lowering the intellectual bar does a disservice both to readers and to the fields in which they hope to work. While that means you won't find as many cartoons in this book as in some, this book also won't insult you by emphasizing entertainment at the expense of technical depth. Instead, the goal of my books is to impart sophisticated concepts in a satisfying and substantive way and to equip you with the tools you'll need in the real world of software development.
　　There are many types of learners, of course, and no one book can ever satisfy every possible audience. In fact, that's why the original version of this book later became two,with language basics delegated to Learning Python. Moreover, one can make a case for a distinction between programmers, who must acquire deep software development skills, and scripters, who do not. For some, a rudimentary knowledge of programming may be enough to leverage a system or library that solves the problem at hand. That is,until their coding forays start encroaching on the realm of full-scale software engineering--a threshold that can inspire disappointment at worst, but a better appreciation of the challenging nature of this field at best.
　　No matter which camp you're from, it's important to understand this book's intent upfront. If you're looking for a shortcut to proficiency that's light on technical content,you probably won't be happy with this book (or the software field in general). If your goal is to master programming Python well, though, and have some fun along the way,you'll probably find this book to be an important piece of your learning experience.At the end of the day, learning to program well is much more demanding than implied by some contemporary media. If you're willing to invest the focus and effort required,though, you'll find that it's also much more rewarding. This is especially true for those who equip themselves for the journey with a programmer-friendly tool like Python.While no book or class can turn you into a Python "Master of the Universe" by itself,this book's goal is to help you get there, by shortening your start-up time and providing a solid foundation in Python's most common application domains.
　　Python 3.X Impacts on This Book
　　As mentioned, this edition now covers Python 3.X only. Python 3.X is an incompatible version of the language. The 3.X core language itself is very similar to Python 2.X, but there are substantial changes in both the language and its many standard libraries.Although some readers with no prior background in 2.X may be able to bypass the differences, the changes had a big impact on the content of this edition. For the still very large existing Python 2.X user base, this section documents the most noteworthy changes in this category.
　　Ifyou're interested in 2.X differences, I also suggest finding a copy of the Fourth Edition of the book Python Pocket Reference described earlier. That book gives both 2.X and 3.X versions of core language structures, built-in functions and exceptions, and many of the standard library modules and tools used in this book. Though not designed to be a reference or version translator per se, the Fourth Edition of Learning Python similarly covers both 2.X and 3.X, and as stated, is prerequisite material to this book. The goal of this 3.X-only Programming Python is not to abandon the current vast 2.X user base in favor of a still imaginary one for 3.X; it is to help readers with the migration,and avoid doubling the size of an already massive book.
　　Specific 3.X Changes
　　Language Versus Library: Unicode
　　Python 3.1 Limitations: Email, CGI
　　Using Book Examples
　　Where to Look for Examples and Updates
　　Example Portability
　　Demo Launchers
　　Code Reuse Policies
　　Contacting O'Reilly
　　Conventions Used in This Book
　　Acknowledgments