[ Team LiB ] Previous Section Next Section

• Table of Contents
• Index
• Reviews
• Reader Reviews
• Errata
• Academic
Learning Python, 2nd Edition
By David Ascher, Mark Lutz
Publisher: O'Reilly
Pub Date: December 2003
ISBN: 0-596-00281-5
Pages: 620

      About This Second Edition
      This Book's Scope
      This Book's Style and Structure
      Book Updates
      Font Conventions
      About the Programs in This Book
      Using Code Examples
      How to Contact Us
    Part I:  Getting Started
        Chapter 1.  A Python Q&A Session
      Section 1.1.  Why Do People Use Python?
      Section 1.2.  Is Python a Scripting Language?
      Section 1.3.  Okay, But What's the Downside?
      Section 1.4.  Who Uses Python Today?
      Section 1.5.  What Can I Do with Python?
      Section 1.6.  What Are Python's Technical Strengths?
      Section 1.7.  How Does Python Stack Up to Language X?
        Chapter 2.  How Python Runs Programs
      Section 2.1.  Introducing the Python Interpreter
      Section 2.2.  Program Execution
      Section 2.3.  Execution Model Variations
        Chapter 3.  How You Run Programs
      Section 3.1.  Interactive Coding
      Section 3.2.  System Command Lines and Files
      Section 3.3.  Clicking Windows File Icons
      Section 3.4.  Module Imports and Reloads
      Section 3.5.  The IDLE User Interface
      Section 3.6.  Other IDEs
      Section 3.7.  Embedding Calls
      Section 3.8.  Frozen Binary Executables
      Section 3.9.  Text Editor Launch Options
      Section 3.10.  Other Launch Options
      Section 3.11.  Future Possibilities?
      Section 3.12.  Which Option Should I Use?
      Section 3.13.  Part I Exercises
    Part II:  Types and Operations
        Chapter 4.  Numbers
      Section 4.1.  Python Program Structure
      Section 4.2.  Why Use Built-in Types?
      Section 4.3.  Numbers
      Section 4.4.  Python Expression Operators
      Section 4.5.  Numbers in Action
      Section 4.6.  The Dynamic Typing Interlude
        Chapter 5.  Strings
      Section 5.1.  String Literals
      Section 5.2.  Strings in Action
      Section 5.3.  String Formatting
      Section 5.4.  String Methods
      Section 5.5.  General Type Categories
        Chapter 6.  Lists and Dictionaries
      Section 6.1.  Lists
      Section 6.2.  Lists in Action
      Section 6.3.  Dictionaries
      Section 6.4.  Dictionaries in Action
        Chapter 7.  Tuples, Files, and Everything Else
      Section 7.1.  Tuples
      Section 7.2.  Files
      Section 7.3.  Type Categories Revisited
      Section 7.4.  Object Generality
      Section 7.5.  References Versus Copies
      Section 7.6.  Comparisons, Equality, and Truth
      Section 7.7.  Python's Type Hierarchies
      Section 7.8.  Other Types in Python
      Section 7.9.  Built-in Type Gotchas
      Section 7.10.  Part II Exercises
    Part III:  Statements and Syntax
        Chapter 8.  Assignment, Expressions, and Print
      Section 8.1.  Assignment Statements
      Section 8.2.  Expression Statements
      Section 8.3.  Print Statements
        Chapter 9.  if Tests
      Section 9.1.  if Statements
      Section 9.2.  Python Syntax Rules
      Section 9.3.  Truth Tests
        Chapter 10.  while and for Loops
      Section 10.1.  while Loops
      Section 10.2.  break, continue, pass, and the Loop else
      Section 10.3.  for Loops
      Section 10.4.  Loop Variations
        Chapter 11.  Documenting Python Code
      Section 11.1.  The Python Documentation Interlude
      Section 11.2.  Common Coding Gotchas
      Section 11.3.  Part III Exercises
    Part IV:  Functions
        Chapter 12.  Function Basics
      Section 12.1.  Why Use Functions?
      Section 12.2.  Coding Functions
      Section 12.3.  A First Example: Definitions and Calls
      Section 12.4.  A Second Example: Intersecting Sequences
        Chapter 13.  Scopes and Arguments
      Section 13.1.  Scope Rules
      Section 13.2.  The global Statement
      Section 13.3.  Scopes and Nested Functions
      Section 13.4.  Passing Arguments
      Section 13.5.  Special Argument Matching Modes
        Chapter 14.  Advanced Function Topics
      Section 14.1.  Anonymous Functions: lambda
      Section 14.2.  Applying Functions to Arguments
      Section 14.3.  Mapping Functions Over Sequences
      Section 14.4.  Functional Programming Tools
      Section 14.5.  List Comprehensions
      Section 14.6.  Generators and Iterators
      Section 14.7.  Function Design Concepts
      Section 14.8.  Function Gotchas
      Section 14.9.  Part IV Exercises
    Part V:  Modules
        Chapter 15.  Modules: The Big Picture
      Section 15.1.  Why Use Modules?
      Section 15.2.  Python Program Architecture
      Section 15.3.  How Imports Work
        Chapter 16.  Module Coding Basics
      Section 16.1.  Module Creation
      Section 16.2.  Module Usage
      Section 16.3.  Module Namespaces
      Section 16.4.  Reloading Modules
        Chapter 17.  Module Packages
      Section 17.1.  Package Import Basics
      Section 17.2.  Package Import Example
      Section 17.3.  Why Use Package Imports?
      Section 17.4.  A Tale of Three Systems
        Chapter 18.  Advanced Module Topics
      Section 18.1.  Data Hiding in Modules
      Section 18.2.  Enabling Future Language Features
      Section 18.3.  Mixed Usage Modes: __name__ and __main__
      Section 18.4.  Changing the Module Search Path
      Section 18.5.  The import as Extension
      Section 18.6.  Module Design Concepts
      Section 18.7.  Module Gotchas
      Section 18.8.  Part V Exercises
    Part VI:  Classes and OOP
        Chapter 19.  OOP: The Big Picture
      Section 19.1.  Why Use Classes?
      Section 19.2.  OOP from 30,000 Feet
        Chapter 20.  Class Coding Basics
      Section 20.1.  Classes Generate Multiple Instance Objects
      Section 20.2.  Classes Are Customized by Inheritance
      Section 20.3.  Classes Can Intercept Python Operators
        Chapter 21.  Class Coding Details
      Section 21.1.  The Class Statement
      Section 21.2.  Methods
      Section 21.3.  Inheritance
      Section 21.4.  Operator Overloading
      Section 21.5.  Namespaces: The Whole Story
        Chapter 22.  Designing with Classes
      Section 22.1.  Python and OOP
      Section 22.2.  Classes as Records
      Section 22.3.  OOP and Inheritance: "is-a" Relationships
      Section 22.4.  OOP and Composition: "has-a" Relationships
      Section 22.5.  OOP and Delegation
      Section 22.6.  Multiple Inheritance
      Section 22.7.  Classes Are Objects: Generic Object Factories
      Section 22.8.  Methods Are Objects: Bound or Unbound
      Section 22.9.  Documentation Strings Revisited
      Section 22.10.  Classes Versus Modules
        Chapter 23.  Advanced Class Topics
      Section 23.1.  Extending Built-in Types
      Section 23.2.  Pseudo-Private Class Attributes
      Section 23.3.  "New Style" Classes in Python 2.2
      Section 23.4.  Class Gotchas
      Section 23.5.  Part VI Exercises
    Part VII:  Exceptions and Tools
        Chapter 24.  Exception Basics
      Section 24.1.  Why Use Exceptions?
      Section 24.2.  Exception Handling: The Short Story
      Section 24.3.  The try/except/else Statement
      Section 24.4.  The try/finally Statement
      Section 24.5.  The raise Statement
      Section 24.6.  The assert Statement
        Chapter 25.  Exception Objects
      Section 25.1.  String-Based Exceptions
      Section 25.2.  Class-Based Exceptions
      Section 25.3.  General raise Statement Forms
        Chapter 26.  Designing with Exceptions
      Section 26.1.  Nesting Exception Handlers
      Section 26.2.  Exception Idioms
      Section 26.3.  Exception Design Tips
      Section 26.4.  Exception Gotchas
      Section 26.5.  Core Language Summary
      Section 26.6.  Part VII Exercises
    Part VIII:  The Outer Layers
        Chapter 27.  Common Tasks in Python
      Section 27.1.  Exploring on Your Own
      Section 27.2.  Conversions, Numbers, and Comparisons
      Section 27.3.  Manipulating Strings
      Section 27.4.  Data Structure Manipulations
      Section 27.5.  Manipulating Files and Directories
      Section 27.6.  Internet-Related Modules
      Section 27.7.  Executing Programs
      Section 27.8.  Debugging, Testing, Timing, Profiling
      Section 27.9.  Exercises
        Chapter 28.  Frameworks
      Section 28.1.  An Automated Complaint System
      Section 28.2.  Interfacing with COM: Cheap Public Relations
      Section 28.3.  A Tkinter-Based GUI Editor for Managing Form Data
      Section 28.4.  Jython: The Felicitous Union of Python and Java
      Section 28.5.  Exercises
        Chapter 29.  Python Resources
      Section 29.1.  Layers of Community
      Section 29.2.  The Process
      Section 29.3.  Services and Products
      Section 29.4.  The Legal Framework: The Python Software Foundation
      Section 29.5.  Software
      Section 29.6.  Popular Third-Party Software
      Section 29.7.  Web Application Frameworks
      Section 29.8.  Tools for Python Developers
    Part IX:  Appendixes
        Appendix A.  Installation and Configuration
      Section A.1.  Installing the Python Interpreter
        Appendix B.  Solutions to Exercises
      Section B.1.  Part I, Getting Started
      Section B.2.  Part II, Types and Operations
      Section B.3.  Part III, Statements and Syntax
      Section B.4.  Part IV, Functions
      Section B.5.  Part V, Modules
      Section B.6.  Part VI, Classes and OOP
      Section B.7.  Part VII, Exceptions and Tools
      Section B.8.  Part VIII, The Outer Layers
[ Team LiB ] Previous Section Next Section