学习python：英文版

Preface

Part I. Getting Started

1. A Python Q&A Session

Why Do People Use Python?

Is Python a Scripting Language?

Okay, But What's the Downside?

Who Uses Python Today?

What Can I Do with Python?

What Are Python's Technical Strengths?

How Does Python Stack Up to Language X?

2. How Python Runs Programs

Introducing the Python Interpreter

Program Execution

Execution Model Variations

3. How You Run Programs

Interactive Coding

System Command Lines and Files

Clicking Windows File Icons

Module Imports and Reloads

The IDLE User Interface

Other IDEs

Embedding Calls

Frozen Binary Executables

Text Editor Launch Options

Other Launch Options

Future Possibilities?

Which Option Should I Use?

Part I Exercises

Part II. Types and Operations

4. Numbers

Python Program Structure

Why Use Built-in Types?

Numbers

Python Expression Operators

Numbers in Action

The Dynamic Typing Interlude

5. Strings

String Literals

Strings in Action

String Formatting

String Methods

General Type Categories

6. Lists and Dictionaries

Lists

Lists in Action

Dictionaries

Dictionaries in Action

7. Tuples, Files, and Everything Else

Tuples

Files

Type Categories Revisited

Object Generality

References Versus Copies

Comparisons, Equality, and Truth

Python's Type Hierarchies

Other Types in Python

Built-in Type Gotchas

Part II Exercises

Part III. Statements and Syntax

8. Assignment, Expressions, and Print

Assignment Statements

Expression Statements

Print Statements

9. if Tests

if Statements

Python Syntax Rules

Truth Tests

10. while and for loops

while Loops

break, continue, pass, and the Loop else

for Loops

Loop Variations

11. Documenting Python Code

The Python Documentation Interlude

Common Coding Gotchas

Part III Exercises

Part IV. Functions

12. Function Basics

Why Use Functions?

Coding Functions

A First Example: Definitions and Calls

A Second Example: Intersecting Sequences

13. Scopes and Arguments

Scope Rules

The global Statement

Scopes and Nested Functions

Passing Arguments

Special Argument Matching Modes

14. Advanced Function Topics

Anonymous Functions: lambda

Applying Functions to Arguments

Mapping Functions Over Sequences

Functional Programming Tools

List Comprehensions

Generators and Iterators

Function Design Concepts

Function Gotchas

Part IV Exercises

Part V. Modules

15. Modules: The Big Picture

Why Use Modules?

Python Program Architecture

How Imports Work

16. Module Coding Basics

Module Creation

Module Usage

Module Namespaces

Reloading Modules

17. Module Packages

Package Import Basics

Package Import Example

Why Use Package Imports?

A Tale of Three Systems

18. Advanced Module Topics

Data Hiding in Modules

Enabling Future Language Features

Mixed Usage Modes: __name__ and __main_

Changing the Module Search Path

The import as Extension

Module Design Concepts

Module Gotchas

Part V Exercises

Part Vl. Classes and OOP

19. OOP: The Big Picture

Why Use Classes?

OOP from 30,000 Feet

20. Class Coding Basics

Classes Generate Multiple Instance Objects

Classes Are Customized by Inheritance

Classes Can Intercept Python Operators

21. Class Coding Details

The Class Statement

Methods

Inheritance

Operator Overloading

Namespaces: The Whole Story

22. Designing with Classes

Python and OOP

Classes as Records

OOP and Inheritance: "is-a" Relationships

OOP and Composition: "has-a" Relationships

OOP and Delegation

Multiple Inheritance

Classes Are Objects: Generic Object Factories

Methods Are Objects: Bound or Unbound

Documentation Strings Revisited

Classes Versus Modules

23. Advanced Class Topics

Extending Built-in Types

Pseudo-Private Class Attributes

"New Style" Classes in Python 2.2

Class Gotchas

Part VI Exercises

Part VII. Exceptions and Tools

24. Exception Basics

Why Use Exceptions?

Exception Handling: The Short Story

The try/except/else Statement

The try/finally Statement

The raise Statement

The assert Statement

25. Exception Objects

String-Based Exceptions

Class-Based Exceptions

General raise Statement Forms

26. Designing with Exceptions

Nesting Exception Handlers

Exception Idioms

Exception Design Tips

Exception Gotchas

Core Language Summary

Part VII Exercises

Part VIII. The Outer Layers

27. Common Tasks in Python

Conversions, Numbers, and Comparisons

Manipulating Strings

Data Structure Manipulations

Manipulating Files and Directories

Internet-Related Modules

Executing Programs

Debugging, Testing, Timing, Profiling

Exercises

28. Frameworks

An Automated Complaint System

Interfacing with COM: Cheap Public Relations

A Tkinter-Based GUI Editor for Managing Form Data

Jython: The Felicitous Union of Python and Java

Exercises

29. Python Resources

Layers of Community

The Process

Services and Products

The Legal Framework: The Python Software Foundation

Software

Popular Third-Party Software

Web Application Frameworks

Tools for Python Developers

Part IX. Appendixes

A. Installation and Configuration

B. Solutions to Exercises

Index