《学习Python（第三版，影印版）》—

Velocity中国 Strata北京 AI北京 O'Reilly Conferences

学习Python（第三版，影印版）

出版时间：2008年08月

页数：700

Python是一种理想的独立程序和脚本程序语言，具有可移植、强大和易用的特点。无论您是初学程序设计还是初学Python，都能通过本书快速而高效地掌握Python核心语言的基础。通读本书，您可以获得足够多的知识，能够学习将Python用于您所选择的任何应用领域。

《学习Python（第三版）》基于作者Mark Lutz在过去10年间讲授培训课程所使用的资料。除了大量的注解插图和每章总结外，作者还为每章加入了独特的一节，通过实际练习和复习提问的方式让您在学习过程中练习新的技能，测验对概念的理解程度。

本书内容包括：

* 类型和运算——深入Python内置对象类型：数值、列表、字典及其他。
* 语句和语法——用来创建和处理对象的Python代码以及Python通用语法模型。
* 函数——Python的基本结构化和代码重用工具。
* 模块——将语句、函数和其他工具组织为更大的组件。
* 类和面向对象编程——可选的Python面向对象程序设计工具，用于定制和重用结构化代码。
* 异常和工具——处理语句和模块异常，并介绍编写较大型程序所使用的开发工具。
* 有关即将发布的Python 3.0的一些讨论。

《学习Python 第三版》为您理解Python语言提供了完整而又深入的介绍，帮助您领会在以后的工作中会遇到的应用级Python实例。如果您准备好探索Google和YouTube究竟从Python中发现了什么，那么本书就是一个最好的开始。

作为Python培训界的领军人物，Mark Lutz是有关Python方面的最早和最畅销书籍的作者，并且从1992年起就是Python社区的先驱之一。同时他还是O’Reilly的《Programming Python》和《Python Pocket Reference》两本书的作者。Mark从1997年开始教授Python课程，截至2007年已经指导了超过200次培训。此外Mark拥有计算机科学学士和硕士学位，以及25年的软件开发经验。

目录
产品信息
关于作者
封面介绍

Preface
Part I. Getting Started
1. A Python Q&A Session
Why Do People Use Python?
Software Quality
Developer Productivity
Is Python a “Scripting Language”?
OK, but What’s the Downside?
Who Uses Python Today?
What Can I Do with Python?
Systems Programming
GUIs
Internet Scripting
Component Integration
Database Programming
Rapid Prototyping
Numeric and Scientific Programming
Gaming, Images, AI, XML, Robots, and More
What Are Python’s Technical Strengths?
It’s Object Oriented
It’s Free
It’s Portable
It’s Powerful
It’s Mixable
It’s Easy to Use
It’s Easy to Learn
It’s Named After Monty Python
How Does Python Stack Up to Language X?
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
2. How Python Runs Programs
Introducing the Python Interpreter
Program Execution
The Programmer’s View
Python’s View
Byte code compilation
The Python Virtual Machine (PVM)
Performance implications
Development implications
Execution Model Variations
Python Implementation Alternatives
CPython
Jython
IronPython
Execution Optimization Tools
The Psyco just-in-time compiler
The Shedskin C++ translator
Frozen Binaries
Future Possibilities?
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
3. How You Run Programs
Interactive Coding
Using the Interactive Prompt
System Command Lines and Files
Using Command Lines and Files
Unix Executable Scripts (#!)
Clicking File Icons
Clicking Icons on Windows
The raw_input Trick
Other Icon-Click Limitations
Module Imports and Reloads
The Grander Module Story: Attributes
Modules and namespaces
import and reload Usage Notes
The IDLE User Interface
IDLE Basics
Using IDLE
Advanced IDLE Tools
Other IDEs
Embedding Calls
Frozen Binary Executables
Text Editor Launch Options
Other Launch Options
Future Possibilities?
Which Option Should I Use?
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part I Exercises
Part II. Types and Operations
4. Introducing Python Object Types
Why Use Built-in Types?
Python’s Core Data Types
Numbers
Strings
Sequence Operations
Immutability
Type-Specific Methods
Getting Help
Other Ways to Code Strings
Pattern Matching
Lists
Sequence Operations
Type-Specific Operations
Bounds Checking
Nesting
List Comprehensions
Dictionaries
Mapping Operations
Nesting Revisited
Sorting Keys: for Loops
Iteration and Optimization
Missing Keys: if Tests
Tuples
Why Tuples?
Files
Other File-Like Tools
Other Core Types
How to Break Your Code’s Flexibility
User-Defined Classes
And Everything Else
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
5. Numbers
Python Numeric Types
Numeric Literals
Built-in Numeric Tools and Extensions
Python Expression Operators
Mixed Operators Follow Operator Precedence
Parentheses Group Subexpressions
Mixed Types Are Converted Up
Preview: Operator Overloading
Numbers in Action
Variables and Basic Expressions
Numeric Display Formats
Division: Classic, Floor, and True
Bitwise Operations
Long Integers
Complex Numbers
Hexadecimal and Octal Notation
Other Built-in Numeric Tools
Other Numeric Types
Decimal Numbers
Sets
Booleans
Third-Party Extensions
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
6. The Dynamic Typing Interlude
The Case of the Missing Declaration Statements
Variables, Objects, and References
Types Live with Objects, Not Variables
Objects Are Garbage-Collected
Shared References
Shared References and In-Place Changes
Shared References and Equality
Dynamic Typing Is Everywhere
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
7. Strings
String Literals
Single- and Double-Quoted Strings Are the Same
Escape Sequences Represent Special Bytes
Raw Strings Suppress Escapes
Triple Quotes Code Multiline Block Strings
Unicode Strings Encode Larger Character Sets
Strings in Action
Basic Operations
Indexing and Slicing
Extended slicing: the third limit
String Conversion Tools
Character code conversions
Changing Strings
String Formatting
Advanced String Formatting
Dictionary-Based String Formatting
String Methods
String Method Examples: Changing Strings
String Method Examples: Parsing Text
Other Common String Methods in Action
The Original string Module
General Type Categories
Types Share Operation Sets by Categories
Mutable Types Can Be Changed In-Place
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
8. Lists and Dictionaries
Lists
Lists in Action
Basic List Operations
Indexing, Slicing, and Matrixes
Changing Lists In-Place
Index and slice assignments
List method calls
Other common list operations
Dictionaries
Dictionaries in Action
Basic Dictionary Operations
Changing Dictionaries In-Place
More Dictionary Methods
A Languages Table
Dictionary Usage Notes
Using dictionaries to simulate flexible lists
Using dictionaries for sparse data structures
Avoiding missing-key errors
Using dictionaries as “records”
Other ways to make dictionaries
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
9. Tuples, Files, and Everything Else
Tuples
Tuples in Action
Tuple syntax peculiarities: commas and parentheses
Conversions and immutability
Why Lists and Tuples?
Files
Opening Files
Using Files
Files in Action
Storing and parsing Python objects in files
Storing native Python objects with pickle
Storing and parsing packed binary data in files
Other File Tools
Type Categories Revisited
Object Flexibility
References Versus Copies
Comparisons, Equality, and Truth
The Meaning of True and False in Python
Python’s Type Hierarchies
Other Types in Python
Built-in Type Gotchas
Assignment Creates References, Not Copies
Repetition Adds One Level Deep
Beware of Cyclic Data Structures
Immutable Types Can’t Be Changed In-Place
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part II Exercises
Part III. Statements and Syntax
10. Introducing Python Statements
Python Program Structure Revisited
Python’s Statements
A Tale of Two ifs
What Python Adds
What Python Removes
Parentheses are optional
End of line is end of statement
End of indentation is end of block
Why Indentation Syntax?
A Few Special Cases
Statement rule special cases
Block rule special case
A Quick Example: Interactive Loops
A Simple Interactive Loop
Doing Math on User Inputs
Handling Errors by Testing Inputs
Handling Errors with try Statements
Nesting Code Three Levels Deep
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
11. Assignment, Expressions, and print
Assignment Statements
Assignment Statement Forms
Sequence Assignments
Advanced sequence assignment patterns
Multiple-Target Assignments
Multiple-target assignment and shared references
Augmented Assignments
Augmented assignment and shared references
Variable Name Rules
Naming conventions
Names have no type, but objects do
Expression Statements
Expression Statements and In-Place Changes
print Statements
The Python “Hello World” Program
Redirecting the Output Stream
The print >> file Extension
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
12. if Tests
if Statements
General Format
Basic Examples
Multiway Branching
Python Syntax Rules
Block Delimiters
Statement Delimiters
A Few Special Cases
Truth Tests
The if/else Ternary Expression
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
13. while and for Loops
while Loops
General Format
Examples
break, continue, pass, and the Loop else
General Loop Format
Examples
pass
continue
break
else
More on the loop else clause
for Loops
General Format
Examples
Basic usage
Other data types
Tuple assignment in for
Nested for loops
Iterators: A First Look
File Iterators
Other Built-in Type Iterators
Other Iteration Contexts
User-Defined Iterators
Loop Coding Techniques
Counter Loops: while and range
Nonexhaustive Traversals: range
Changing Lists: range
Parallel Traversals: zip and map
Dictionary construction with zip
Generating Both Offsets and Items: enumerate
List Comprehensions: A First Look
List Comprehension Basics
Using List Comprehensions on Files
Extended List Comprehension Syntax
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
14. The Documentation Interlude
Python Documentation Sources
# Comments
The dir Function
Docstrings: _ _doc_ _
User-defined docstrings
Docstring standards
Built-in docstrings
PyDoc: The help Function
PyDoc: HTML Reports
Standard Manual Set
Web Resources
Published Books
Common Coding Gotchas
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part III Exercises
Part IV. Functions
15. Function Basics
Why Use Functions?
Coding Functions
def Statements
def Executes at Runtime
A First Example: Definitions and Calls
Definition
Calls
Polymorphism in Python
A Second Example: Intersecting Sequences
Definition
Calls
Polymorphism Revisited
Local Variables
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
16. Scopes and Arguments
Scope Rules
Python Scope Basics
Name Resolution: The LEGB Rule
Scope Example
The Built-in Scope
The global Statement
Minimize Global Variables
Minimize Cross-File Changes
Other Ways to Access Globals
Scopes and Nested Functions
Nested Scope Details
Nested Scope Examples
Factory functions
Retaining enclosing scopes’ state with defaults
Nested scopes and lambdas
Scopes versus defaults with loop variables
Arbitrary scope nesting
Passing Arguments
Arguments and Shared References
Avoiding Mutable Argument Changes
Simulating Output Parameters
Special Argument-Matching Modes
Keyword and Default Examples
Keywords
Defaults
Arbitrary Arguments Examples
Collecting arguments
Unpacking arguments
Combining Keywords and Defaults
The min Wakeup Call
Full credit
Bonus points
The punch line
A More Useful Example: General Set Functions
Argument Matching: The Gritty Details
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
17. Advanced Function Topics
Anonymous Functions: lambda
lambda Expressions
Why Use lambda?
How (Not) to Obfuscate Your Python Code
Nested lambdas and Scopes
Applying Functions to Arguments
The apply Built-in
Passing keyword arguments
apply-Like Call Syntax
Mapping Functions over Sequences: map
Functional Programming Tools: filter and reduce
List Comprehensions Revisited: Mappings
List Comprehension Basics
Adding Tests and Nested Loops
List Comprehensions and Matrixes
Comprehending List Comprehensions
Iterators Revisited: Generators
Generator Function Example
Extended Generator Function Protocol: send Versus next
Iterators and Built-in Types
Generator Expressions: Iterators Meet List Comprehensions
Timing Iteration Alternatives
Function Design Concepts
Functions Are Objects: Indirect Calls
Function Gotchas
Local Names Are Detected Statically
Defaults and Mutable Objects
Functions Without returns
Enclosing Scope Loop Variables
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part IV Exercises
Part V. Modules
18. Modules: The Big Picture
Why Use Modules?
Python Program Architecture
How to Structure a Program
Imports and Attributes
Standard Library Modules
How Imports Work
1. Find It
The module search path
The sys.path list
Module file selection
Advanced module selection concepts
2. Compile It (Maybe)
3. Run It
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
19. Module Coding Basics
Module Creation
Module Usage
The import Statement
The from statement
The from * Statement
Imports Happen Only Once
import and from Are Assignments
Cross-File Name Changes
import and from Equivalence
Potential Pitfalls of the from Statement
When import is required
Module Namespaces
Files Generate Namespaces
Attribute Name Qualification
Imports Versus Scopes
Namespace Nesting
Reloading Modules
reload Basics
reload Example
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
20. Module Packages
Package Import Basics
Packages and Search Path Settings
Package _ _init_ _.py Files
Package Import Example
from Versus import with Packages
Why Use Package Imports?
A Tale of Three Systems
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
21. Advanced Module Topics
Data Hiding in Modules
Minimizing from * Damage: _X and _ _all_ _
Enabling Future Language Features
Mixed Usage Modes: _ _name_ _ and _ _main_ _
Unit Tests with _ _name_ _
Changing the Module Search Path
The import as Extension
Relative Import Syntax
Why Relative Imports?
Module Design Concepts
Modules Are Objects: Metaprograms
Module Gotchas
Statement Order Matters in Top-Level Code
Importing Modules by Name String
from Copies Names but Doesn’t Link
from * Can Obscure the Meaning of Variables
reload May Not Impact from Imports
reload, from, and Interactive Testing
reload Isn’t Applied Transitively
Recursive from Imports May Not Work
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part V Exercises
Part VI. Classes and OOP
22. OOP: The Big Picture
Why Use Classes?
OOP from 30,000 Feet
Attribute Inheritance Search
Classes and Instances
Class Method Calls
Coding Class Trees
OOP Is About Code Reuse
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
23. Class Coding Basics
Classes Generate Multiple Instance Objects
Class Objects Provide Default Behavior
Instance Objects Are Concrete Items
A First Example
Classes Are Customized by Inheritance
A Second Example
Classes Are Attributes in Modules
Classes Can Intercept Python Operators
A Third Example
Why Use Operator Overloading?
The World’s Simplest Python Class
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
24. Class Coding Details
The class Statement
General Form
Example
Methods
Example
Calling Superclass Constructors
Other Method Call Possibilities
Inheritance
Attribute Tree Construction
Specializing Inherited Methods
Class Interface Techniques
Abstract Superclasses
Operator Overloading
Common Operator Overloading Methods
_ _getitem_ _ Intercepts Index References
_ _getitem_ _ and _ _iter_ _ Implement Iteration
User-Defined Iterators
Multiple iterators on one object
_ _getattr_ _ and _ _setattr_ _ Catch Attribute References
Emulating Privacy for Instance Attributes
_ _repr_ _ and _ _str_ _ Return String Representations
_ _radd_ _ Handles Right-Side Addition
_ _call_ _ Intercepts Calls
Function Interfaces and Callback-Based Code
_ _del_ _ Is a Destructor
Namespaces: The Whole Story
Simple Names: Global Unless Assigned
Attribute Names: Object Namespaces
The “Zen” of Python Namespaces: Assignments Classify Names
Namespace Dictionaries
Namespace Links
A More Realistic Example
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
25. Designing with Classes
Python and OOP
Overloading by Call Signatures (or Not)
Classes As Records
OOP and Inheritance: “Is-a” Relationships
OOP and Composition: “Has-a” Relationships
Stream Processors Revisited
OOP and Delegation
Multiple Inheritance
Classes Are Objects: Generic Object Factories
Why Factories?
Methods Are Objects: Bound or Unbound
Documentation Strings Revisited
Classes Versus Modules
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
26. Advanced Class Topics
Extending Built-in Types
Extending Types by Embedding
Extending Types by Subclassing
Pseudoprivate Class Attributes
Name Mangling Overview
Why Use Pseudoprivate Attributes?
New-Style Classes
Diamond Inheritance Change
Diamond inheritance example
Explicit conflict resolution
Other New-Style Class Extensions
Static and class methods
Instance slots
Class properties
New _ _getattribute_ _ overloading method
Static and Class Methods
Using Static and Class Methods
Function Decorators
Decorator Example
Class Gotchas
Changing Class Attributes Can Have Side Effects
Multiple Inheritance: Order Matters
Methods, Classes, and Nested Scopes
“Overwrapping-itis”
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part VI Exercises
Part VII. Exceptions and Tools
27. Exception Basics
Why Use Exceptions?
Exception Roles
Exception Handling: The Short Story
The try/except/else Statement
try Statement Clauses
The try/else Clause
Example: Default Behavior
Example: Catching Built-in Exceptions
The try/finally Statement
Example: Coding Termination Actions with try/finally
Unified try/except/finally
Combining finally and except by Nesting
Unified try Example
The raise Statement
Example: Raising and Catching User-Defined Exceptions
Example: Passing Extra Data with raise
Example: Propagating Exceptions with raise
The assert Statement
Example: Trapping Constraints (but Not Errors)
with/as Context Managers
Basic Usage
The Context Management Protocol
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
28. Exception Objects
String-Based Exceptions
String Exceptions Are Right Out!
Class-Based Exceptions
Class Exception Example
Why Class Exceptions?
Built-in Exception Classes
Specifying Exception Text
Sending Extra Data and Behavior in Instances
Example: Extra data with classes and strings
General raise Statement Forms
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
29. Designing with Exceptions
Nesting Exception Handlers
Example: Control-Flow Nesting
Example: Syntactic Nesting
Exception Idioms
Exceptions Aren’t Always Errors
Functions Signal Conditions with raise
Debugging with Outer try Statements
Running In-Process Tests
More on sys.exc_info
Exception Design Tips
What Should Be Wrapped
Catching Too Much: Avoid Empty excepts
Catching Too Little: Use Class-Based Categories
Exception Gotchas
String Exceptions Match by Identity, Not by Value
Catching the Wrong Thing
Core Language Summary
The Python Toolset
Development Tools for Larger Projects
Chapter Summary
Brain Builder
Chapter Quiz
Quiz Answers
Brain Builder: Part VII Exercises
Part VIII. Appendixes
A. Installation and Configuration
B. Solutions to End-of-Part Exercises
Index

书名：学习Python（第三版，影印版）

作者：Mark Lutz 著

国内出版社：东南大学出版社

出版时间：2008年08月

页数：700

书号：978-7-5641-1240-0

原版书出版商：O'Reilly Media

Mark Lutz

作为全球Python培训界的领军人物。Mark Lutz是Python最畅销书籍的作者，也是Python社区的先驱。
Mark 是O’Reilly出版的《Programming Python》和《Python Pocket Reference》的作者，这两本书于2009年都已经出版了第3版。Mark自1992年开始接触Python，1995年开始撰写有关Python的书籍，从1997年开始教授Python课程。截止到2009年，他已经开办了225个Python短期培训课程，教授了大约3500名学习者，销售了大约25万册有关Python的书籍。许多书被翻译成十多种语言。
此外，Mark拥有威斯康星大学计算机科学学士和硕士学位，在过去的25年中，他主要从事编译器、编程工具、脚本程序以及各种客户端/服务器系统方面的工作。你也可以通过访问http://www.rmi.net/~lutz与他取得联系。

查看Mark Lutz更多信息

The animal on the cover of Learning Python, Third Edition, is a wood rat (Neotoma
Muridae). The wood rat lives in a wide range of conditions (mostly rocky, scrub, and
desert areas) over much of North and Central America, generally at some distance
from humans. They are good climbers, nesting in trees or bushes up to six meters off
the ground; some species burrow underground or in rock crevices or inhabit other
species’ abandoned holes.
These grayish-beige, medium-size rodents are the original pack rats: they carry
anything and everything into their homes, whether or not it’s needed, and are especially
attracted to shiny objects such as tin cans, glass, and silverware.

购买选项

定价：88.00元

书号：978-7-5641-1240-0

出版社：东南大学出版社

联系出版社邮购