Learning Python, 3/e

Mark Lutz

  • 出版商: O'Reilly
  • 出版日期: 2007-11-01
  • 售價: $1,510
  • 貴賓價: 9.5$1,435
  • 語言: 英文
  • 頁數: 752
  • 裝訂: Paperback
  • ISBN: 0596513984
  • ISBN-13: 9780596513986
  • 相關分類: Python程式語言
  • 已絕版
    無現貨庫存(No stock available)





Portable, powerful, and a breeze to use, Python is ideal for both standalone programs and scripting applications. With this hands-on book, you can master the fundamentals of the core Python language quickly and efficiently, whether you're new to programming or just new to Python. Once you finish, you will know enough about the language to use it in any application domain you choose.

Learning Python is based on material from author Mark Lutz's popular training courses, which he's taught over the past decade. Each chapter is a self-contained lesson that helps you thoroughly understand a key component of Python before you continue. Along with plenty of annotated examples, illustrations, and chapter summaries, every chapter also contains Brain Builder, a unique section with practical exercises and review quizzes that let you practice new skills and test your understanding as you go.

This book covers:
  • Types and Operations -- Python's major built-in object types in depth: numbers, lists, dictionaries, and more

  • Statements and Syntax -- the code you type to create and process objects in Python, along with Python's general syntax model

  • Functions -- Python's basic procedural tool for structuring and reusing code

  • Modules -- packages of statements, functions, and other tools organized into larger components

  • Classes and OOP -- Python's optional object-oriented programming tool for structuring code for customization and reuse

  • Exceptions and Tools -- exception handling model and statements, plus a look at development tools for writing larger programs
Learning Python gives you a deep and complete understanding of the language that will help you comprehend any application-level examples of Python that you later encounter. If you're ready to discover what Google and YouTube see in Python, this book is the best way to get started.

Table of Contents



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


               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 20Chapter Quiz 20
               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




               Execution Optimization Tools

                   The Psyco just-in-time compiler

                   The Shedskin C++ translator

               Frozen Binaries

               Future Possibilities?

     Chapter Summary
Brain Builder   33
Chapter Quiz   33

               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   59
Chapter Quiz   59

               Quiz Answers
Brain Builder: Part I Exercises   61

Part II. Types and Operations

4. Introducing Python Object Types

     Why Use Built-in Types?

               Python's Core Data Types



               Sequence Operations


               Type-Specific Methods

               Getting Help

               Other Ways to Code Strings

               Pattern Matching


               Sequence Operations

               Type-Specific Operations

               Bounds Checking


               List Comprehensions


               Mapping Operations

               Nesting Revisited

               Sorting Keys: for Loops

               Iteration and Optimization

               Missing Keys: if Tests


               Why Tuples?


               Other File-Like Tools

     Other Core Types

               How to Break Your Code's Flexibility

               User-Defined Classes

               And Everything Else

     Chapter Summary
Brain Builder   91
Chapter Quiz   91

               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



               Third-Party Extensions

     Chapter Summary
Brain Builder   111
Chapter Quiz   111

               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   122
Chapter Quiz   122

               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   151
Chapter Quiz   151

               Quiz Answers

8. Lists and Dictionaries


     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 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   171
Chapter Quiz   171

               Quiz Answers

9. Tuples, Files, and Everything Else


               Tuples in Action

                   Tuple syntax peculiarities: commas and parentheses

                   Conversions and immutability

               Why Lists and Tuples?


               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   195
Chapter Quiz   195

               Quiz Answers
Brain Builder: Part II Exercises   196

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   216
Chapter Quiz   216

               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   235
Chapter Quiz   235

               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   247
Chapter Quiz   247

               Quiz Answers

13. while and for Loops

     while Loops

               General Format


     break, continue, pass, and the Loop else

               General Loop Format






                   More on the loop else clause

     for Loops

               General Format


                   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   276
Chapter Quiz   276

               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   294
Chapter Quiz   294

               Quiz Answers
Brain Builder: Part III Exercises   295

Part IV. Functions

15. Function Basics

     Why Use Functions?

     Coding Functions

               def Statements

               def Executes at Runtime

     A First Example: Definitions and Calls



               Polymorphism in Python

     A Second Example: Intersecting Sequences



               Polymorphism Revisited

               Local Variables

     Chapter Summary
Brain Builder   309
Chapter Quiz   309

               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



               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   342
Chapter Quiz   342

               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   377
Chapter Quiz   377

               Quiz Answers
Brain Builder: Part IV Exercises   379

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   397
Chapter Quiz   397

               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   414
Chapter Quiz   414

               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   425
Chapter Quiz   425

               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   445
Chapter Quiz   445

               Quiz Answers
Brain Builder: Part V Exercises   446

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   463
Chapter Quiz   463

               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   479
Chapter Quiz   479

               Quiz Answers

24. Class Coding Details

     The class Statement

               General Form




               Calling Superclass Constructors

               Other Method Call Possibilities


               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   516
Chapter Quiz   516

               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   538
Chapter Quiz   538

               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


     Chapter Summary
Brain Builder   565
Chapter Quiz   565

               Quiz Answers
Brain Builder: Part VI Exercises   566

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   601
Chapter Quiz   601

               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   616
Chapter Quiz   616

               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   635
Chapter Quiz   635

               Quiz Answers
Brain Builder: Part VII Exercises   636

Part VIII. Appendixes

A. Installation and Configuration

B. Solutions to End-of-Part Exercises