Learning Python. 2nd Edition Mark Lutz, David Ascher

Spis treści książki

• Learning Python, 2nd Edition
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • About This Second Edition
    • Prerequisites
    • This Books Scope
    • This Book's Style and Structure
      • Core Language
      • Outer Layers
      • Appendixes
    • Book Updates
    • Font Conventions
    • About the Programs in This Book
    • Using Code Examples
    • How to Contact Us
    • Acknowledgments
      • Mark Also Says:
      • David Also Says:
  • I. Getting Started
    • 1. A Python Q&A Session
      • 1.1. Why Do People Use Python?
        • 1.1.1. Software Quality
        • 1.1.2. Developer Productivity
      • 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.5.1. Systems Programming
        • 1.5.2. GUIs
        • 1.5.3. Internet Scripting
        • 1.5.4. Component Integration
        • 1.5.5. Database Programming
        • 1.5.6. Rapid Prototyping
        • 1.5.7. Numeric Programming
        • 1.5.8. Gaming, Images, AI, XML, and More
      • 1.6. What Are Python's Technical Strengths?
        • 1.6.1. It's Object-Oriented
        • 1.6.2. It's Free
        • 1.6.3. It's Portable
        • 1.6.4. It's Powerful
        • 1.6.5. It's Mixable
        • 1.6.6. It's Easy to Use
        • 1.6.7. It's Easy to Learn
      • 1.7. How Does Python Stack Up to Language X?
    • 2. How Python Runs Programs
      • 2.1. Introducing the Python Interpreter
      • 2.2. Program Execution
        • 2.2.1. The Programmer's View
        • 2.2.2. Python's View
          • 2.2.2.1. Byte code compilation
          • 2.2.2.2. Python Virtual Machine (PVM)
          • 2.2.2.3. Performance implications
          • 2.2.2.4. Development implications
      • 2.3. Execution Model Variations
        • 2.3.1. Python Implementation Alternatives
          • 2.3.1.1. CPython
          • 2.3.1.2. Jython
          • 2.3.1.3. Python.NET
        • 2.3.2. The Psyco Just-in-Time Compiler
        • 2.3.3. Frozen Binaries
        • 2.3.4. Future Possibilities?
    • 3. How You Run Programs
      • 3.1. Interactive Coding
        • 3.1.1. Using the Interactive Prompt
      • 3.2. System Command Lines and Files
        • 3.2.1. Using Command Lines and Files
        • 3.2.2. Unix Executable Scripts (#!)
      • 3.3. Clicking Windows File Icons
        • 3.3.1. Clicking Icons on Windows
        • 3.3.2. The raw_input Trick
        • 3.3.3. Other Icon Click Limitations
      • 3.4. Module Imports and Reloads
        • 3.4.1. The Grander Module Story: Attributes
        • 3.4.2. Import and Reload Usage Notes
      • 3.5. The IDLE User Interface
        • 3.5.1. IDLE Basics
        • 3.5.2. Using IDLE
      • 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
  • II. Types and Operations
    • 4. Numbers
      • 4.1. Python Program Structure
      • 4.2. Why Use Built-in Types?
      • 4.3. Numbers
        • 4.3.1. Number Literals
        • 4.3.2. Built-in Tools and Extensions
      • 4.4. Python Expression Operators
        • 4.4.1. Mixed Operators: Operator Precedence
        • 4.4.2. Parentheses Group Subexpressions
        • 4.4.3. Mixed Types: Converted Up
        • 4.4.4. Preview: Operator Overloading
      • 4.5. Numbers in Action
        • 4.5.1. Basic Operations and Variables
        • 4.5.2. Numeric Representation
        • 4.5.3. Division: Classic, Floor, and True
        • 4.5.4. B itwise Operations
        • 4.5.5. L ong Integers
        • 4.5.6. Complex Numbers
        • 4.5.7. Hexadecimal and Octal Notation
        • 4.5.8. Other Numeric Tools
      • 4.6. The Dynamic Typing Interlude
        • 4.6.1. How Assignments Work
        • 4.6.2. References and Changeable Objects
        • 4.6.3. References and Garbage Collection
    • 5. Strings
      • 5.1. String Literals
        • 5.1.1. Single- and Double-Quoted Strings Are the Same
        • 5.1.2. Escape Sequences Code Special Bytes
        • 5.1.3. Raw Strings Suppress Escapes
        • 5.1.4. Triple Quotes Code Multiline Block Strings
        • 5.1.5. Unicode Strings Encode Larger Character Sets
      • 5.2. Strings in Action
        • 5.2.1. Basic Operations
        • 5.2.2. Indexing and Slicing
          • 5.2.2.1. I ndexing (S[i]) fetches components at offsets
          • 5.2.2.2. S licing (S[i:j]) extracts contiguous sections of a sequence
        • 5.2.3. String Conversion Tools
        • 5.2.4. C hanging Strings
      • 5.3. String Formatting
        • 5.3.1. Advanced String Formatting
      • 5.4. String Methods
        • 5.4.1. String Method Examples: Changing Strings
        • 5.4.2. String Method Examples: Parsing Text
        • 5.4.3. The Original Module
      • 5.5. General Type Categories
        • 5.5.1. Types Share Operation Sets by Categories
        • 5.5.2. Mutable Types Can Be Changed in-Place
    • 6. Lists and Dictionaries
      • 6.1. Lists
      • 6.2. Lists in Action
        • 6.2.1. Basic List Operations
        • 6.2.2. In dexing, Slicing, and Matrixes
        • 6.2.3. Changing Lists in-Place
          • 6.2.3.1. Index and slice assignment
          • 6.2.3.2. List method calls
      • 6.3. Dictionaries
      • 6.4. Dictionaries in Action
        • 6.4.1. Basic Dictionary Operations
        • 6.4.2. Changing Dictionaries in-Place
        • 6.4.3. More Dictionary Methods
        • 6.4.4. A Languages Table
        • 6.4.5. Dictionary Usage Notes
          • 6.4.5.1. Using dictionaries to simulate flexible lists
          • 6.4.5.2. Using dictionaries for sparse data structures
          • 6.4.5.3. Using dictionaries as "records"
    • 7. Tuples, Files, and Everything Else
      • 7.1. Tuples
        • 7.1.1. Why Lists and Tuples?
      • 7.2. Files
        • 7.2.1. Files in Action
      • 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.9.1. Assignment Creates References, Not Copies
        • 7.9.2. Repetition Adds One-Level Deep
          • 7.9.2.1. Solutions
        • 7.9.3. Cyclic Data Structures
        • 7.9.4. Immutable Types Can't Be Changed in-Place
      • 7.10. Part II Exercises
  • III. Statements and Syntax
    • 8. Assignment, Expressions, and Print
      • 8.1. Assignment Statements
        • 8.1.1. Variable Name Rules
          • 8.1.1.1. Naming conventions
          • 8.1.1.2. Names have no type, but objects do
        • 8.1.2. Augmented Assignment Statements
      • 8.2. Expression Statements
      • 8.3. Print Statements
        • 8.3.1. The Python "Hello World" Program
        • 8.3.2. Redirecting the Output Stream
          • 8.3.2.1. The print>>file extension
    • 9. if Tests
      • 9.1. if Statements
        • 9.1.1. General Format
        • 9.1.2. Examples
          • 9.1.2.1. Multiway branching
      • 9.2. Python Syntax Rules
        • 9.2.1. Block Delimiters
        • 9.2.2. Statement Delimiters
        • 9.2.3. A Few Special Cases
      • 9.3. Truth Tests
    • 10. while and for Loops
      • 10.1. while Loops
        • 10.1.1. General Format
        • 10.1.2. Examples
      • 10.2. break, continue, pass, and the Loop else
        • 10.2.1. General Loop Format
        • 10.2.2. Examples
        • 10.2.3. More on the Loop else
      • 10.3. for Loops
        • 10.3.1. General Format
        • 10.3.2. Examples
      • 10.4. Loop Variations
        • 10.4.1. Counter Loops: range
        • 10.4.2. Nonexhaustive Traversals: range
        • 10.4.3. Changing Lists: range
        • 10.4.4. Parallel Traversals: zip and map
        • 10.4.5. Dictionary Construction with zip
    • 11. Documenting Python Code
      • 11.1. The Python Documentation Interlude
        • 11.1.1. Documentation Sources
        • 11.1.2. # Comments
        • 11.1.3. The dir Function
        • 11.1.4. Docstrings: __doc__
          • 11.1.4.1. User-defined docstrings
          • 11.1.4.2. Docstring standards
          • 11.1.4.3. Built-in docstrings
        • 11.1.5. PyDoc: The help Function
        • 11.1.6. PyDoc: HTML Reports
        • 11.1.7. Standard Manual Set
        • 11.1.8. Web Resources
        • 11.1.9. Published Books
      • 11.2. Common Coding Gotchas
      • 11.3. Part III Exercises
  • IV. Functions
    • 12. Function Basics
      • 12.1. Why Use Functions?
      • 12.2. Coding Functions
        • 12.2.1. def Statements
        • 12.2.2. def Executes at Runtime
      • 12.3. A First Example: Definitions and Calls
        • 12.3.1. Definition
        • 12.3.2. Calls
        • 12.3.3. Polymorphism in Python
      • 12.4. A Second Example: Intersecting Sequences
        • 12.4.1. Definition
        • 12.4.2. Calls
        • 12.4.3. Polymorphism Revisited
        • 12.4.4. Local Variables
    • 13. Scopes and Arguments
      • 13.1. Scope Rules
        • 13.1.1. Python Scope Basics
        • 13.1.2. Name Resolution: The LEGB Rule
        • 13.1.3. Scope Example
        • 13.1.4. The Built-in Scope
      • 13.2. The global Statement
      • 13.3. Scopes and Nested Functions
        • 13.3.1. Nested Scope Details
        • 13.3.2. Nested Scope Examples
      • 13.4. Passing Arguments
        • 13.4.1. Arguments and Shared References
        • 13.4.2. Avoiding Mutable Argument Changes
        • 13.4.3. Simulating Output Parameters
      • 13.5. Special Argument Matching Modes
        • 13.5.1. Keyword and Default Examples
        • 13.5.2. Arbitrary Arguments Examples
        • 13.5.3. Combining Keywords and Defaults
        • 13.5.4. The min Wakeup Call
          • 13.5.4.1. Full credit
          • 13.5.4.2. Bonus points
          • 13.5.4.3. The punch line
        • 13.5.5. A More Useful Example: General Set Functions
        • 13.5.6. Argument Matching: The Gritty Details
    • 14. Advanced Function Topics
      • 14.1. Anonymous Functions: lambda
        • 14.1.1. lambda Expressions
        • 14.1.2. Why lambda?
        • 14.1.3. How (Not) to Obfuscate Your Python Code
        • 14.1.4. Nested lambdas and Scopes
      • 14.2. Applying Functions to Arguments
        • 14.2.1. The apply Built-in
          • 14.2.1.1. Passing keyword arguments
        • 14.2.2. Apply-Like Call Syntax
      • 14.3. Mapping Functions Over Sequences
      • 14.4. Functional Programming Tools
      • 14.5. List Comprehensions
        • 14.5.1. List Comprehension Basics
        • 14.5.2. Adding Tests and Nested Loops
        • 14.5.3. Comprehending List Comprehensions
      • 14.6. Generators and Iterators
        • 14.6.1. Generator Example
        • 14.6.2. Iterators and Built-in Types
      • 14.7. Function Design Concepts
        • 14.7.1. Functions Are Objects: Indirect Calls
      • 14.8. Function Gotchas
        • 14.8.1. Local Names Are Detected Statically
        • 14.8.2. Defaults and Mutable Objects
        • 14.8.3. Functions Without Returns
      • 14.9. Part IV Exercises
  • V. Modules
    • 15. Modules: The Big Picture
      • 15.1. Why Use Modules?
      • 15.2. Python Program Architecture
        • 15.2.1. How to Structure a Program
        • 15.2.2. Imports and Attributes
        • 15.2.3. Standard Library Modules
      • 15.3. How Imports Work
        • 15.3.1. 1. Find It
          • 15.3.1.1. The module search path
          • 15.3.1.2. The sys.path list
          • 15.3.1.3. Module file selection
        • 15.3.2. 2. Compile It (Maybe)
        • 15.3.3. 3. Run It
    • 16. Module Coding Basics
      • 16.1. Module Creation
      • 16.2. Module Usage
        • 16.2.1. The import Statement
        • 16.2.2. The from statement
        • 16.2.3. The from * statement
        • 16.2.4. Imports Happen Only Once
        • 16.2.5. import and from Are Assignments
        • 16.2.6. Cross-File Name Changes
        • 16.2.7. import and from Equivalence
      • 16.3. Module Namespaces
        • 16.3.1. Files Generate Namespaces
        • 16.3.2. Attribute Name Qualification
        • 16.3.3. Imports Versus Scopes
        • 16.3.4. Namespace Nesting
      • 16.4. Reloading Modules
        • 16.4.1. Reload Basics
        • 16.4.2. Reload Example
    • 17. Module Packages
      • 17.1. Package Import Basics
        • 17.1.1. Packages and Search Path Settings
        • 17.1.2. Package __init__.py Files
      • 17.2. Package Import Example
        • 17.2.1. from Versus import with Packages
      • 17.3. Why Use Package Imports?
      • 17.4. A Tale of Three Systems
    • 18. Advanced Module Topics
      • 18.1. Data Hiding in Modules
        • 18.1.1. Minimizing from* damage: _X and __all__
      • 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.6.1. Modules Are Objects: Metaprograms
      • 18.7. Module Gotchas
        • 18.7.1. Importing Modules by Name String
        • 18.7.2. from Copies Names but Doesn't Link
        • 18.7.3. Statement Order Matters in Top-Level Code
        • 18.7.4. Recursive "from" Imports May Not Work
        • 18.7.5. reload May Not Impact from Imports
        • 18.7.6. reload and from and Interactive Testing
        • 18.7.7. reload Isn't Applied Transitively
      • 18.8. Part V Exercises
  • VI. Classes and OOP
    • 19. OOP: The Big Picture
      • 19.1. Why Use Classes?
      • 19.2. OOP from 30,000 Feet
        • 19.2.1. Attribute Inheritance Search
        • 19.2.2. Coding Class Trees
        • 19.2.3. OOP Is About Code Reuse
    • 20. Class Coding Basics
      • 20.1. Classes Generate Multiple Instance Objects
        • 20.1.1. Class Objects Provide Default Behavior
        • 20.1.2. Instance Objects Are Concrete Items
        • 20.1.3. A First Example
      • 20.2. Classes Are Customized by Inheritance
        • 20.2.1. A Second Example
        • 20.2.2. Classes and Modules
      • 20.3. Classes Can Intercept Python Operators
        • 20.3.1. A Third Example
        • 20.3.2. Why Operator Overloading?
    • 21. Class Coding Details
      • 21.1. The Class Statement
        • 21.1.1. General Form
        • 21.1.2. Example
      • 21.2. Methods
        • 21.2.1. Example
        • 21.2.2. Calling Superclass Constructors
        • 21.2.3. Other Method Call Possibilities
      • 21.3. Inheritance
        • 21.3.1. Attribute Tree Construction
        • 21.3.2. Specializing Inherited Methods
        • 21.3.3. Class Interface Techniques
        • 21.3.4. Abstract Superclasses
      • 21.4. Operator Overloading
        • 21.4.1. Common Operator Overloading Methods
        • 21.4.2. __getitem__ Intercepts Index References
        • 21.4.3. __getitem__ and __iter__ Implement Iteration
          • 21.4.3.1. User-defined iterators
        • 21.4.4. __getattr__ and __setattr__ Catch Attribute References
        • 21.4.5. __repr__ and __str__Return String Representations
        • 21.4.6. __radd__ Handles Right-Side Addition
        • 21.4.7. __call__ Intercepts Calls
        • 21.4.8. __del__ Is a Destructor
      • 21.5. Namespaces: The Whole Story
        • 21.5.1. Unqualified Names: Global Unless Assigned
        • 21.5.2. Qualified Names: Object Namespaces
        • 21.5.3. Assignments Classify Names
        • 21.5.4. Namespace Dictionaries
        • 21.5.5. Namespace Links
    • 22. Designing with Classes
      • 22.1. Python and OOP
        • 22.1.1. Overloading by Call Signatures (or Not)
      • 22.2. Classes as Records
      • 22.3. OOP and Inheritance: "is-a" Relationships
      • 22.4. OOP and Composition: "has-a" Relationships
        • 22.4.1. Stream Processors Revisited
      • 22.5. OOP and Delegation
      • 22.6. Multiple Inheritance
      • 22.7. Classes Are Objects: Generic Object Factories
        • 22.7.1. Why Factories?
      • 22.8. Methods Are Objects: Bound or Unbound
      • 22.9. Documentation Strings Revisited
      • 22.10. Classes Versus Modules
    • 23. Advanced Class Topics
      • 23.1. Extending Built-in Types
        • 23.1.1. Extending Types by Embedding
        • 23.1.2. Extending Types by Subclassing
      • 23.2. Pseudo-Private Class Attributes
        • 23.2.1. Name Mangling Overview
        • 23.2.2. Why Use Pseudo-Private Attributes?
      • 23.3. "New Style" Classes in Python 2.2
        • 23.3.1. Diamond Inheritance Change
          • 23.3.1.1. Diamond inheritance example
          • 23.3.1.2. Explicit conflict resolution
        • 23.3.2. Other New Style Class Extensions
          • 23.3.2.1. Static and class methods
          • 23.3.2.2. Instance slots
          • 23.3.2.3. Class properties
          • 23.3.2.4. New __getattribute__ overload method
      • 23.4. Class Gotchas
        • 23.4.1. Changing Class Attributes Can Have Side Effects
        • 23.4.2. Multiple Inheritance: Order Matters
        • 23.4.3. Class Function Attributes Are Special: Static Methods
          • 23.4.3.1. Solution (prior to 2.2, and in 2.2 normally)
          • 23.4.3.2. Static and class methods in Python 2.2
        • 23.4.4. Methods, Classes, and Nested Scopes
        • 23.4.5. Overwrapping-itis
      • 23.5. Part VI Exercises
  • VII. Exceptions and Tools
    • 24. Exception Basics
      • 24.1. Why Use Exceptions?
        • 24.1.1. Exception Roles
      • 24.2. Exception Handling: The Short Story
      • 24.3. The try/except/else Statement
        • 24.3.1. Try Statement Clauses
        • 24.3.2. The try/else Clause
        • 24.3.3. Example: Default Behavior
        • 24.3.4. Example: Catching Built-in Exceptions
      • 24.4. The try/finally Statement
        • 24.4.1. Example: Coding Termination Actions with try/finally
      • 24.5. The raise Statement
        • 24.5.1. Example: Raising and Catching User-Defined Exceptions
        • 24.5.2. Example: Passing Extra Data with raise
        • 24.5.3. Example: Propagating Exceptions with raise
      • 24.6. The assert Statement
        • 24.6.1. Example: Trapping Constraints (but Not Errors)
    • 25. Exception Objects
      • 25.1. String-Based Exceptions
      • 25.2. Class-Based Exceptions
        • 25.2.1. Class Exception Example
        • 25.2.2. Why Class Exceptions?
        • 25.2.3. Built-in Exception Classes
        • 25.2.4. Specifying Exception Text
        • 25.2.5. Sending Extra Data in Instances
          • 25.2.5.1. Example: extra data with classes and strings
      • 25.3. General raise Statement Forms
    • 26. Designing with Exceptions
      • 26.1. Nesting Exception Handlers
        • 26.1.1. Example: Control-Flow Nesting
        • 26.1.2. Example: Syntactic Nesting
      • 26.2. Exception Idioms
        • 26.2.1. Exceptions Aren't Always Errors
        • 26.2.2. Functions Signal Conditions with raise
        • 26.2.3. Debugging with Outer try Statements
        • 26.2.4. Running in-Process Tests
      • 26.3. Exception Design Tips
        • 26.3.1. What Should Be Wrapped
        • 26.3.2. Catching Too Much
        • 26.3.3. Catching Too Little
      • 26.4. Exception Gotchas
        • 26.4.1. String Exceptions Match by Identity, Not Value
        • 26.4.2. Catching the Wrong Thing
      • 26.5. Core Language Summary
        • 26.5.1. The Python Toolset
        • 26.5.2. Development Tools for Larger Projects
      • 26.6. Part VII Exercises
  • VIII. The Outer Layers
    • 27. Common Tasks in Python
      • 27.1. Exploring on Your Own
      • 27.2. Conversions, Numbers, and Comparisons
      • 27.3. Manipulating Strings
        • 27.3.1. The string Module
        • 27.3.2. Complicated String Matches with Regular Expressions
          • 27.3.2.1. A real regular expression problem
      • 27.4. Data Structure Manipulations
        • 27.4.1. Making Copies
          • 27.4.1.1. The copy module
        • 27.4.2. Sorting
        • 27.4.3. Randomizing
        • 27.4.4. Making New Data Structures
        • 27.4.5. Making New Lists and Dictionaries
      • 27.5. Manipulating Files and Directories
        • 27.5.1. The os and os.path Modules
        • 27.5.2. Copying Files and Directories: The shutil Module
        • 27.5.3. Filenames and Directories
        • 27.5.4. Matching Sets of Files
        • 27.5.5. Using Temporary Files
        • 27.5.6. Modifying Input and Outputs
        • 27.5.7. Using Standard I/O to Process Files
          • 27.5.7.1. Finding all lines that start with a #
          • 27.5.7.2. Extracting the fourth column of a file (where columns are defined by whitespace)
          • 27.5.7.3. Extracting the fourth column of a file, where columns are separated by colons, and making it lowercase
          • 27.5.7.4. Printing the first 10 lines, the last 10 lines, and every other line
          • 27.5.7.5. Counting the number of times the word "Python" occurs in a file
          • 27.5.7.6. Changing a list of columns into a list of rows
          • 27.5.7.7. Choosing chunk sizes
        • 27.5.8. Doing Something to a Set of Files Specified on the Command Line
        • 27.5.9. Processing Each Line of One or More Files
        • 27.5.10. Dealing with Binary Data: The struct Module
      • 27.6. Internet-Related Modules
        • 27.6.1. The Common Gateway Interface: The cgi Module
        • 27.6.2. Manipulating URLs: The urllib and urlparse Modules
        • 27.6.3. Specific Internet Protocols
        • 27.6.4. Processing Internet Data
        • 27.6.5. XML Processing
      • 27.7. Executing Programs
      • 27.8. Debugging, Testing, Timing, Profiling
        • 27.8.1. Debugging with pdb
        • 27.8.2. Testing with unittest
        • 27.8.3. Timing
      • 27.9. Exercises
    • 28. Frameworks
      • 28.1. An Automated Complaint System
        • 28.1.1. Excerpt from the HTML File
      • 28.2. Interfacing with COM: Cheap Public Relations
      • 28.3. A Tkinter-Based GUI Editor for Managing Form Data
        • 28.3.1. The Main Program
        • 28.3.2. The Form Editor
        • 28.3.3. Design Considerations
      • 28.4. Jython: The Felicitous Union of Python and Java
        • 28.4.1. Jython Gives Python Programmers Access to Java Libraries
        • 28.4.2. Jython as a Java Scripting Language
        • 28.4.3. A Real Jython/Swing Application: grapher.py
      • 28.5. Exercises
    • 29. Python Resources
      • 29.1. Layers of Community
        • 29.1.1. The Core
        • 29.1.2. Local User Groups
        • 29.1.3. Conferences and Workshops
        • 29.1.4. Where to Get Help
          • 29.1.4.1. Python-help
          • 29.1.4.2. Python-tutor
          • 29.1.4.3. Python-list
        • 29.1.5. Special Interest Groups
        • 29.1.6. python-dev
        • 29.1.7. News Sources
      • 29.2. The Process
      • 29.3. Services and Products
      • 29.4. The Legal Framework: The Python Software Foundation
      • 29.5. Software
        • 29.5.1. Search the Web
        • 29.5.2. Search the Mailing List Archives
        • 29.5.3. Look in the Vaults of Parnassus
        • 29.5.4. Check the Python Package Index (PyPI)
        • 29.5.5. Look in the Python Cookbook
      • 29.6. Popular Third-Party Software
        • 29.6.1. Interfaces to Windows and the MacOS
          • 29.6.1.1. Windows
          • 29.6.1.2. Macintosh
        • 29.6.2. Special-Purpose Libraries
          • 29.6.2.1. Scientific computing libraries
          • 29.6.2.2. Relational database interfaces
          • 29.6.2.3. Graphics libraries
            • 29.6.2.3.1. Python Imaging Library (PIL)
            • 29.6.2.3.2. PyGame and PyOpenGL
        • 29.6.3. Interfaces to GUI Toolkits
        • 29.6.4. Interfaces to C/C++/Fortran
          • 29.6.4.1. SWIG and f2py
          • 29.6.4.2. CXX and Boost::Python
          • 29.6.4.3. Pyrex, Weave, and Psyco
          • 29.6.4.4. ctypes
        • 29.6.5. Little Gems
        • 29.6.6. Packaging Tools
          • 29.6.6.1. Installer
          • 29.6.6.2. py2exe
      • 29.7. Web Application Frameworks
        • 29.7.1. Zope
        • 29.7.2. Twisted
        • 29.7.3. Quixote
        • 29.7.4. Webware, Spyce, and More
      • 29.8. Tools for Python Developers
  • IX. Appendixes
    • A. Installation and Configuration
      • A.1. Installing the Python Interpreter
        • A.1.1. Where to Get Python
        • A.1.2. Installation Steps
        • A.1.3. Configuration Steps
          • A.1.3.1. Python environment variables
        • A.1.4. How to Set Configuration Options
          • A.1.4.1. UNIX/Linux shell variables
          • A.1.4.2. DOS variables (Windows)
          • A.1.4.3. Other Windows options
          • A.1.4.4. Path files
    • B. Solutions to Exercises
      • B.1. Part I
      • B.2. Part II
      • B.3. Part III
      • B.4. Part IV
      • B.5. Part V
      • B.6. Part VI
      • B.7. Part VII
      • B.8. Part VIII
        • B.8.1. Chapter 27
        • B.8.2. Chapter 28
  • About the Authors
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje