You're Reading a Free Preview
Pages 30 to 126 are not shown in this preview.
Pages 30 to 126 are not shown in this preview.
You're Reading a Free Preview
Pages 156 to 302 are not shown in this preview.
Pages 156 to 302 are not shown in this preview.
You're Reading a Free Preview
Pages 332 to 474 are not shown in this preview.
Pages 332 to 474 are not shown in this preview.
You're Reading a Free Preview
Pages 504 to 525 are not shown in this preview.
Pages 504 to 525 are not shown in this preview.
You're Reading a Free Preview
Pages 555 to 748 are not shown in this preview.
Pages 555 to 748 are not shown in this preview.
of 00
Learning Python
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...
(More)
9,273 Reads
Info and Rating
| Category: | |
| Rating: | (2 Ratings) |
| Upload Date: | 05/16/2009 |
| Copyright: | Traditional Copyright: All rights reserved |
| Tags: |
This is a Free Preview
With this purchase, you can read the entire document on Scribd, download (as PDF), and print.
TIP Press Ctrl-F⌘F to quickly search anywhere in the document.
Search History:
Result 00 of 00
00 results for result for
p.
Sections
- Preface1
- PART I
- I.Getting Started
- Chapter 1
- CHAPTER 1
- A Python Q&A Session1
- Why Do People Use Python?
- Developer productivity
- Program portability
- Support libraries
- Component integration
- Software Quality
- Developer Productivity
- Is Python a “Scripting Language”?
- Shell tools
- Control 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
- Gaming, Images, AI, XML, Robots, and More
- What Are Python’s Technical Strengths?
- It’s Object Oriented
- Automatic memory management
- Programming-in-the-large support
- Built-in object types
- Library utilities
- Third-party utilities
- 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
- Chapter 2
- CHAPTER 2
- How Python Runs Programs 2
- 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
- Chapter 3
- CHAPTER 3
- How You Run Programs 3
- 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?
- PART II
- II.Types and Operations
- Chapter 4
- CHAPTER 4
- Introducing Python Object Types4
- Why Use Built-in Types?
- Python’s Core Data Types
- Numbers
- Strings
- Sequence Operations
- Immutability
- Getting Help
- Other Ways to Code Strings
- Pattern Matching
- Lists
- 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
- And Everything Else
- Chapter 5
- CHAPTER 5
- Numbers5
- Python Numeric Types
- Numeric Literals
- Numeric precision and long integers
- Long integer literals
- Built-in Numeric Tools and Extensions
- Built-in mathematical functions
- 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
- str and repr 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 6
- CHAPTER 6
- The Dynamic Typing Interlude 6
- 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 7
- CHAPTER 7
- Strings7
- String Literals
- Index, slice, length
- Iteration, membership
- 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 8
- CHAPTER 8
- Lists and Dictionaries 8
- Ordered collections of arbitrary objects
- Of the category mutable sequence
- Arrays of object references
- 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
- Unordered collections of arbitrary objects
- Of the category mutable mapping
- 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 9
- CHAPTER 9
- Tuples, Files, and Everything Else 9
- Of the category immutable sequence
- 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
- PART III
- III.Statements and Syntax
- Chapter 10
- CHAPTER 10
- Introducing Python Statements10
- 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 11
- CHAPTER 11
- Assignment, Expressions, and print11
- Assignment Statements
- Assignment Statement Forms
- Tuple- and list-unpacking assignments
- Multiple-target assignments
- 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 12
- CHAPTER 12
- if Statements
- General Format
- Basic Examples
- Multiway Branching
- Python Syntax Rules
- Block Delimiters
- Statement Delimiters
- Truth Tests
- The if/else Ternary Expression
- Why You Will Care: Booleans
- Chapter 13
- CHAPTER 13
- while and for Loops 13
- while Loops
- Examples
- break, continue, pass, and the Loop else
- General Loop Format
- pass
- continue
- break
- else
- More on the loop else clause
- for Loops
- Basic usage
- Other data types
- Tuple assignment in for
- Nested for loops
- Iterators: A First Look
- Why You Will Care: File Scanners
- File Iterators
- Other Built-in Type Iterators
- Other Iteration Contexts
- 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 14
- CHAPTER 14
- The Documentation Interlude 14
- Python Documentation Sources
- # Comments
- The dir Function
- Docstrings: __doc__
- Docstring standards
- Built-in docstrings
- PyDoc: The help Function
- PyDoc: HTML Reports
- Standard Manual Set
- Web Resources
- Published Books
- Common Coding Gotchas
- PART IV
- IV.Functions
- Chapter 15
- CHAPTER 15
- Function Basics15
- Why Use Functions?
- Maximizing code reuse and minimizing redundancy
- Procedural decomposition
- Coding Functions
- def Statements
- def Executes at Runtime
- A First Example: Definitions and Calls
- Calls
- Polymorphism in Python
- A Second Example: Intersecting Sequences
- Polymorphism Revisited
- Local Variables
- Chapter 16
- CHAPTER 16
- Scopes and Arguments 16
- 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 17
- CHAPTER 17
- Advanced Function Topics 17
- Anonymous Functions: lambda
- lambda Expressions
- Why Use lambda?
- How (Not) to Obfuscate Your Python Code
- Nested lambdas and Scopes
- Why You Will Care: Callbacks
- 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
- 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
- PART V
- V.Modules
- Chapter 18
- CHAPTER 18
- Modules: The Big Picture18
- Why Use Modules?
- System namespace partitioning
- Implementing shared services or data
- Python Program Architecture
- How to Structure a Program
- Imports and Attributes
- Standard Library Modules
- How Imports Work
- 1. Find It
- The module search path
- PYTHONPATH directories
- Standard library directories
- .pth file directories
- The sys.path list
- Advanced module selection concepts
- 2. Compile It (Maybe)
- 3. Run It
- Chapter 19
- CHAPTER 19
- Module Coding Basics 19
- 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 20
- CHAPTER 20
- Module Packages20
- Package Import Basics
- Packages and Search Path Settings
- Package __init__.py Files
- Package initialization
- Module namespace initialization
- Package Import Example
- from Versus import with Packages
- Why Use Package Imports?
- A Tale of Three Systems
- Chapter 21
- CHAPTER 21
- Advanced Module Topics 21
- 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
- PART VI
- VI.Classes and OOP
- Chapter 22
- CHAPTER 22
- OOP: The Big Picture22
- Why Use Classes?
- Customization via inheritance
- Operator overloading
- OOP from 30,000 Feet
- Attribute Inheritance Search
- Classes and Instances
- Class Method Calls
- Coding Class Trees
- OOP Is About Code Reuse
- Chapter 23
- CHAPTER 23
- Class Coding Basics23
- 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 24
- CHAPTER 24
- Class Coding Details24
- The class Statement
- General Form
- Example
- Methods
- 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
- 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 25
- CHAPTER 25
- Designing with Classes 25
- 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
- Why You Will Care: Classes and Persistence
- Multiple Inheritance
- Classes Are Objects: Generic Object Factories
- Why Factories?
- Methods Are Objects: Bound or Unbound
- Documentation Strings Revisited
- Why You Will Care: Bound Methods and Callbacks
- Classes Versus Modules
- Chapter 26
- CHAPTER 26
- Advanced Class Topics26
- 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
- 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”
- PART VII
- VII.Exceptions and Tools
- Chapter 27
- CHAPTER 27
- Exception Basics27
- Why Use Exceptions?
- Exception Roles
- Special-case handling
- Unusual control flows
- 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
- Combining finally and except by Nesting
- 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 28
- CHAPTER 28
- Exception Objects 28
- 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 29
- CHAPTER 29
- Designing with Exceptions29
- 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
- String Exceptions Match by Identity, Not by Value
- Core Language Summary
- Development Tools for Larger Projects
- PART VIII
- APPENDIX A
- Installation and Configuration1
- Where to Fetch Python
- The Python 2.5 MSI Installer on Windows Vista
- Appendix B
- APPENDIX B
- Solutions to End-of-Part Exercises 2
- Part III, Statements and Syntax
- Part VI, Classes and OOP
- Part VII, Exceptions and Tools
- Index
More from This User
Related Documents
More From This User
Privacy and Big Data
Much of what constitutes Big Data is information about us. Through our online...
Take Control of Your 802.11n AirPort Network
If you're trying to solve a particular problem, you can jump in and read the ...
Playful Design
Game design is a sibling discipline to software and Web design, but they're s...
Architecting Mobile Solutions for the Enterprise
Your guide to planning and executing a complete mobile web strategyRevisit yo...
Adobe Edge Preview 5: The Missing Manual
Want to create animated graphics for iPhone, iPad and the Web, using familiar...
Take Control of iCloud
Take Control of iCloud will teach you how to handle many aspects of iCloud, i...
Hadoop: The Definitive Guide
Ready to unlock the power of your data? With this comprehensive guide, you’ll...
Maintainable JavaScript
You may have definite ideas about writing code when working alone, but team d...
The Art of Community; Building the New Age of Participation
Online communities provide a wide range of opportunities for supporting a cau...
Beyond Point-and-Shoot; Learning to Use a Digital SLR or Interchang...
There are two types of new photographers: those satisfied with their low-cost...
Mobile Development with C#; Building Native iOS, Android, and Windo...
It’s true: you can build native apps for iOS, Android, and Windows Phone with...
Getting Started with .NET Gadgeteer
Learn how to quickly build cool electronic gadgets with .NET Gadgeteer. With ...
Inside Windows® Debugging; A Practical Guide to Debugging and Traci...
Use Windows debuggers throughout the development cycle—and build better softw...
Mobile Design Pattern Gallery, Color Edition
When you’re under pressure to produce a well designed, easy-to-navigate mobil...
The Saint Who Fought the Dragon
Kids discover the story of Saint George as he stands up for what good and tru...
Santa's Secret Story
Kids join a little girl named Rachel on a magical journey as she meets someon...
Photoshop CS6: The Missing Manual
Photoshop CS6 is truly amazing, but it can also be overwhelming if you’re jus...
Shine: Choices to Make God Smile
Shine provides examples of positive choices that help children ages 4 develop...
My First Missal (with revisions)
Kidsnd parentsill love this handy-sized missal. The parts of the Mass, prayer...
The Saints Pray for Us (ESS)
This stunning book features intercessory prayers to help children pray to the...
Catholic Family Fun
Looking for a way to bring your family together in faith and fun, but not sur...
Wisdom for Living the Final Season
Even those with a strong faith in God’s limitless mercy and may fear the proc...
Learn to Solder
Learn the fundamentals of soldering—and pick up an essential skill for buildi...
Secrets of the Spirit: Wisdom from Luis Martinez (CWC)
How do I develop a deep, loving relationship with God? Martinez, author of Th...
St. Gianna Beretta Molla
As a mother, wife, and doctor St. Gianna Molla is not your typical saint. She...
Related Docuements
Learning Python
Google and YouTube use Python because it's highly adaptable, easy to maintain...
From O'Reilly Media, Inc.
Frozen Binaries
Portable, powerful, and a breeze to use, Python is the popular open source ob...
From O'Reilly Media, Inc.
The IDLE User Interface
Portable, powerful, and a breeze to use, Python is the popular open source ob...
From O'Reilly Media, Inc.
Learning Python
Portable, powerful, and a breeze to use, Python is the popular open source ob...
From O'Reilly Media, Inc.
Chapter 18
Python is one of the most powerful, easy-to-read programming languages around...
From Wiley
Python For Dummies
Python is one of the most powerful, easy-to-read programming languages around...
From Wiley
Leave a Comment