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