|
Learning Python 3rd Edition
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.
CONTENTS:
Preface
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
GUIs
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 20
Chapter 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
CPython
Jython
IronPython
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
Numbers
Strings
Sequence Operations
Immutability
Type-Specific Methods
Getting Help
Other Ways to Code Strings
Pattern Matching
Lists
Sequence Operations
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
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
Sets
Booleans
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
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
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
Tuples in Action
Tuple syntax peculiarities: commas and parentheses
Conversions and immutability
Why Lists and Tuples?
Files
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
Examples
break, continue, pass, and the Loop else
General Loop Format
Examples
pass
continue
break
else
More on the loop else clause
for Loops
General Format
Examples
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
Definition
Calls
Polymorphism in Python
A Second Example: Intersecting Sequences
Definition
Calls
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
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 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
Example
Methods
Example
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
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
" Overwrapping-itis"
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
Index
|
