
Python Documentation contents
*****************************

* What's New in Python
  * What's New in Python 2.6
    * Python 3.0
    * Changes to the Development Process
      * New Issue Tracker: Roundup
      * New Documentation Format: reStructuredText Using Sphinx
    * PEP 343: The 'with' statement
      * Writing Context Managers
      * The contextlib module
    * PEP 366: Explicit Relative Imports From a Main Module
    * PEP 370: Per-user ``site-packages`` Directory
    * PEP 371: The ``multiprocessing`` Package
    * PEP 3101: Advanced String Formatting
    * PEP 3105: ``print`` As a Function
    * PEP 3110: Exception-Handling Changes
    * PEP 3112: Byte Literals
    * PEP 3116: New I/O Library
    * PEP 3118: Revised Buffer Protocol
    * PEP 3119: Abstract Base Classes
    * PEP 3127: Integer Literal Support and Syntax
    * PEP 3129: Class Decorators
    * PEP 3141: A Type Hierarchy for Numbers
      * The ``fractions`` Module
    * Other Language Changes
      * Optimizations
      * Interpreter Changes
    * New and Improved Modules
      * The ``ast`` module
      * The ``future_builtins`` module
      * The ``json`` module: JavaScript Object Notation
      * The ``plistlib`` module: A Property-List Parser
      * ctypes Enhancements
      * Improved SSL Support
    * Deprecations and Removals
    * Build and C API Changes
      * Port-Specific Changes: Windows
      * Port-Specific Changes: Mac OS X
      * Port-Specific Changes: IRIX
    * Porting to Python 2.6
    * Acknowledgements
  * What's New in Python 2.5
    * PEP 308: Conditional Expressions
    * PEP 309: Partial Function Application
    * PEP 314: Metadata for Python Software Packages v1.1
    * PEP 328: Absolute and Relative Imports
    * PEP 338: Executing Modules as Scripts
    * PEP 341: Unified try/except/finally
    * PEP 342: New Generator Features
    * PEP 343: The 'with' statement
      * Writing Context Managers
      * The contextlib module
    * PEP 352: Exceptions as New-Style Classes
    * PEP 353: Using ssize_t as the index type
    * PEP 357: The '__index__' method
    * Other Language Changes
      * Interactive Interpreter Changes
      * Optimizations
    * New, Improved, and Removed Modules
      * The ctypes package
      * The ElementTree package
      * The hashlib package
      * The sqlite3 package
      * The wsgiref package
    * Build and C API Changes
      * Port-Specific Changes
    * Porting to Python 2.5
    * Acknowledgements
  * What's New in Python 2.4
    * PEP 218: Built-In Set Objects
    * PEP 237: Unifying Long Integers and Integers
    * PEP 289: Generator Expressions
    * PEP 292: Simpler String Substitutions
    * PEP 318: Decorators for Functions and Methods
    * PEP 322: Reverse Iteration
    * PEP 324: New subprocess Module
    * PEP 327: Decimal Data Type
      * Why is Decimal needed?
      * The ``Decimal`` type
      * The ``Context`` type
    * PEP 328: Multi-line Imports
    * PEP 331: Locale-Independent Float/String Conversions
    * Other Language Changes
      * Optimizations
    * New, Improved, and Deprecated Modules
      * cookielib
      * doctest
    * Build and C API Changes
      * Port-Specific Changes
    * Porting to Python 2.4
    * Acknowledgements
  * What's New in Python 2.3
    * PEP 218: A Standard Set Datatype
    * PEP 255: Simple Generators
    * PEP 263: Source Code Encodings
    * PEP 273: Importing Modules from ZIP Archives
    * PEP 277: Unicode file name support for Windows NT
    * PEP 278: Universal Newline Support
    * PEP 279: enumerate()
    * PEP 282: The logging Package
    * PEP 285: A Boolean Type
    * PEP 293: Codec Error Handling Callbacks
    * PEP 301: Package Index and Metadata for Distutils
    * PEP 302: New Import Hooks
    * PEP 305: Comma-separated Files
    * PEP 307: Pickle Enhancements
    * Extended Slices
    * Other Language Changes
      * String Changes
      * Optimizations
    * New, Improved, and Deprecated Modules
      * Date/Time Type
      * The optparse Module
    * Pymalloc: A Specialized Object Allocator
    * Build and C API Changes
      * Port-Specific Changes
    * Other Changes and Fixes
    * Porting to Python 2.3
    * Acknowledgements
  * What's New in Python 2.2
    * Introduction
    * PEPs 252 and 253: Type and Class Changes
      * Old and New Classes
      * Descriptors
      * Multiple Inheritance: The Diamond Rule
      * Attribute Access
      * Related Links
    * PEP 234: Iterators
    * PEP 255: Simple Generators
    * PEP 237: Unifying Long Integers and Integers
    * PEP 238: Changing the Division Operator
    * Unicode Changes
    * PEP 227: Nested Scopes
    * New and Improved Modules
    * Interpreter Changes and Fixes
    * Other Changes and Fixes
    * Acknowledgements
  * What's New in Python 2.1
    * Introduction
    * PEP 227: Nested Scopes
    * PEP 236: __future__ Directives
    * PEP 207: Rich Comparisons
    * PEP 230: Warning Framework
    * PEP 229: New Build System
    * PEP 205: Weak References
    * PEP 232: Function Attributes
    * PEP 235: Importing Modules on Case-Insensitive Platforms
    * PEP 217: Interactive Display Hook
    * PEP 208: New Coercion Model
    * PEP 241: Metadata in Python Packages
    * New and Improved Modules
    * Other Changes and Fixes
    * Acknowledgements
  * What's New in Python 2.0
    * Introduction
    * What About Python 1.6?
    * New Development Process
    * Unicode
    * List Comprehensions
    * Augmented Assignment
    * String Methods
    * Garbage Collection of Cycles
    * Other Core Changes
      * Minor Language Changes
      * Changes to Built-in Functions
    * Porting to 2.0
    * Extending/Embedding Changes
    * Distutils: Making Modules Easy to Install
    * XML Modules
      * SAX2 Support
      * DOM Support
      * Relationship to PyXML
    * Module changes
    * New modules
    * IDLE Improvements
    * Deleted and Deprecated Modules
    * Acknowledgements
* The Python Tutorial
  * Whetting Your Appetite
  * Using the Python Interpreter
    * Invoking the Interpreter
      * Argument Passing
      * Interactive Mode
    * The Interpreter and Its Environment
      * Error Handling
      * Executable Python Scripts
      * Source Code Encoding
      * The Interactive Startup File
  * An Informal Introduction to Python
    * Using Python as a Calculator
      * Numbers
      * Strings
      * Unicode Strings
      * Lists
    * First Steps Towards Programming
  * More Control Flow Tools
    * ``if`` Statements
    * ``for`` Statements
    * The ``range()`` Function
    * ``break`` and ``continue`` Statements, and ``else`` Clauses on
      Loops
    * ``pass`` Statements
    * Defining Functions
    * More on Defining Functions
      * Default Argument Values
      * Keyword Arguments
      * Arbitrary Argument Lists
      * Unpacking Argument Lists
      * Lambda Forms
      * Documentation Strings
    * Intermezzo: Coding Style
  * Data Structures
    * More on Lists
      * Using Lists as Stacks
      * Using Lists as Queues
      * Functional Programming Tools
      * List Comprehensions
      * Nested List Comprehensions
    * The ``del`` statement
    * Tuples and Sequences
    * Sets
    * Dictionaries
    * Looping Techniques
    * More on Conditions
    * Comparing Sequences and Other Types
  * Modules
    * More on Modules
      * Executing modules as scripts
      * The Module Search Path
      * "Compiled" Python files
    * Standard Modules
    * The ``dir()`` Function
    * Packages
      * Importing * From a Package
      * Intra-package References
      * Packages in Multiple Directories
  * Input and Output
    * Fancier Output Formatting
      * Old string formatting
    * Reading and Writing Files
      * Methods of File Objects
      * The ``pickle`` Module
  * Errors and Exceptions
    * Syntax Errors
    * Exceptions
    * Handling Exceptions
    * Raising Exceptions
    * User-defined Exceptions
    * Defining Clean-up Actions
    * Predefined Clean-up Actions
  * Classes
    * A Word About Names and Objects
    * Python Scopes and Namespaces
    * A First Look at Classes
      * Class Definition Syntax
      * Class Objects
      * Instance Objects
      * Method Objects
    * Random Remarks
    * Inheritance
      * Multiple Inheritance
    * Private Variables
    * Odds and Ends
    * Exceptions Are Classes Too
    * Iterators
    * Generators
    * Generator Expressions
  * Brief Tour of the Standard Library
    * Operating System Interface
    * File Wildcards
    * Command Line Arguments
    * Error Output Redirection and Program Termination
    * String Pattern Matching
    * Mathematics
    * Internet Access
    * Dates and Times
    * Data Compression
    * Performance Measurement
    * Quality Control
    * Batteries Included
  * Brief Tour of the Standard Library -- Part II
    * Output Formatting
    * Templating
    * Working with Binary Data Record Layouts
    * Multi-threading
    * Logging
    * Weak References
    * Tools for Working with Lists
    * Decimal Floating Point Arithmetic
  * What Now?
  * Interactive Input Editing and History Substitution
    * Line Editing
    * History Substitution
    * Key Bindings
    * Alternatives to the Interactive Interpreter
  * Floating Point Arithmetic:  Issues and Limitations
    * Representation Error
* Using Python
  * Command line and environment
    * Command line
      * Interface options
      * Generic options
      * Miscellaneous options
      * Options you shouldn't use
    * Environment variables
      * Debug-mode variables
  * Using Python on Unix platforms
    * Getting and installing the latest version of Python
      * On Linux
      * On FreeBSD and OpenBSD
      * On OpenSolaris
    * Building Python
    * Python-related paths and files
    * Miscellaneous
    * Editors
  * Using Python on Windows
    * Installing Python
    * Alternative bundles
    * Configuring Python
      * Excursus: Setting environment variables
      * Finding the Python executable
      * Finding modules
      * Executing scripts
    * Additional modules
      * PyWin32
      * Py2exe
      * WConio
    * Compiling Python on Windows
    * Other resources
  * Using Python on a Macintosh
    * Getting and Installing MacPython
      * How to run a Python script
      * Running scripts with a GUI
      * Configuration
    * The IDE
    * Installing Additional Python Packages
    * GUI Programming on the Mac
    * Distributing Python Applications on the Mac
    * Application Scripting
    * Other Resources
* The Python Language Reference
  * Introduction
    * Alternate Implementations
    * Notation
  * Lexical analysis
    * Line structure
      * Logical lines
      * Physical lines
      * Comments
      * Encoding declarations
      * Explicit line joining
      * Implicit line joining
      * Blank lines
      * Indentation
      * Whitespace between tokens
    * Other tokens
    * Identifiers and keywords
      * Keywords
      * Reserved classes of identifiers
    * Literals
      * String literals
      * String literal concatenation
      * Numeric literals
      * Integer and long integer literals
      * Floating point literals
      * Imaginary literals
    * Operators
    * Delimiters
  * Data model
    * Objects, values and types
    * The standard type hierarchy
    * New-style and classic classes
    * Special method names
      * Basic customization
      * Customizing attribute access
        * More attribute access for new-style classes
        * Implementing Descriptors
        * Invoking Descriptors
        * __slots__
      * Customizing class creation
      * Customizing instance and subclass checks
      * Emulating callable objects
      * Emulating container types
      * Additional methods for emulation of sequence types
      * Emulating numeric types
      * Coercion rules
      * With Statement Context Managers
      * Special method lookup for old-style classes
      * Special method lookup for new-style classes
  * Execution model
    * Naming and binding
      * Interaction with dynamic features
    * Exceptions
  * Expressions
    * Arithmetic conversions
    * Atoms
      * Identifiers (Names)
      * Literals
      * Parenthesized forms
      * List displays
      * Generator expressions
      * Dictionary displays
      * String conversions
      * Yield expressions
    * Primaries
      * Attribute references
      * Subscriptions
      * Slicings
      * Calls
    * The power operator
    * Unary arithmetic and bitwise operations
    * Binary arithmetic operations
    * Shifting operations
    * Binary bitwise operations
    * Comparisons
    * Boolean operations
    * Conditional Expressions
    * Lambdas
    * Expression lists
    * Evaluation order
    * Summary
  * Simple statements
    * Expression statements
    * Assignment statements
      * Augmented assignment statements
    * The ``assert`` statement
    * The ``pass`` statement
    * The ``del`` statement
    * The ``print`` statement
    * The ``return`` statement
    * The ``yield`` statement
    * The ``raise`` statement
    * The ``break`` statement
    * The ``continue`` statement
    * The ``import`` statement
      * Future statements
    * The ``global`` statement
    * The ``exec`` statement
  * Compound statements
    * The ``if`` statement
    * The ``while`` statement
    * The ``for`` statement
    * The ``try`` statement
    * The ``with`` statement
    * Function definitions
    * Class definitions
  * Top-level components
    * Complete Python programs
    * File input
    * Interactive input
    * Expression input
  * Full Grammar specification
* The Python Standard Library
  * Introduction
  * Built-in Functions
  * Non-essential Built-in Functions
  * Built-in Constants
    * Constants added by the ``site`` module
  * Built-in Types
    * Truth Value Testing
    * Boolean Operations --- ``and``, ``or``, ``not``
    * Comparisons
    * Numeric Types --- ``int``, ``float``, ``long``, ``complex``
      * Bit-string Operations on Integer Types
      * Additional Methods on Float
    * Iterator Types
      * Generator Types
    * Sequence Types --- ``str``, ``unicode``, ``list``, ``tuple``,
      ``buffer``, ``xrange``
      * String Methods
      * String Formatting Operations
      * XRange Type
      * Mutable Sequence Types
    * Set Types --- ``set``, ``frozenset``
    * Mapping Types --- ``dict``
    * File Objects
    * Context Manager Types
    * Other Built-in Types
      * Modules
      * Classes and Class Instances
      * Functions
      * Methods
      * Code Objects
      * Type Objects
      * The Null Object
      * The Ellipsis Object
      * Boolean Values
      * Internal Objects
    * Special Attributes
  * Built-in Exceptions
    * Exception hierarchy
  * String Services
    * ``string`` --- Common string operations
      * String constants
      * String Formatting
      * Format String Syntax
        * Format Specification Mini-Language
        * Format examples
      * Template strings
      * String functions
      * Deprecated string functions
    * ``re`` --- Regular expression operations
      * Regular Expression Syntax
      * Matching vs Searching
      * Module Contents
      * Regular Expression Objects
      * Match Objects
      * Examples
        * Checking For a Pair
        * Simulating scanf()
        * Avoiding recursion
        * search() vs. match()
        * Making a Phonebook
        * Text Munging
        * Finding all Adverbs
        * Finding all Adverbs and their Positions
        * Raw String Notation
    * ``struct`` --- Interpret strings as packed binary data
      * Functions and Exceptions
      * Format Strings
        * Byte Order, Size, and Alignment
        * Format Characters
        * Examples
      * Classes
    * ``difflib`` --- Helpers for computing deltas
      * SequenceMatcher Objects
      * SequenceMatcher Examples
      * Differ Objects
      * Differ Example
      * A command-line interface to difflib
    * ``StringIO`` --- Read and write strings as files
    * ``cStringIO`` --- Faster version of ``StringIO``
    * ``textwrap`` --- Text wrapping and filling
    * ``codecs`` --- Codec registry and base classes
      * Codec Base Classes
        * Codec Objects
        * IncrementalEncoder Objects
        * IncrementalDecoder Objects
        * StreamWriter Objects
        * StreamReader Objects
        * StreamReaderWriter Objects
        * StreamRecoder Objects
      * Encodings and Unicode
      * Standard Encodings
      * ``encodings.idna`` --- Internationalized Domain Names in
        Applications
      * ``encodings.utf_8_sig`` --- UTF-8 codec with BOM signature
    * ``unicodedata`` --- Unicode Database
    * ``stringprep`` --- Internet String Preparation
    * ``fpformat`` --- Floating point conversions
  * Data Types
    * ``datetime`` --- Basic date and time types
      * Available Types
      * ``timedelta`` Objects
      * ``date`` Objects
      * ``datetime`` Objects
      * ``time`` Objects
      * ``tzinfo`` Objects
      * ``strftime()`` and ``strptime()`` Behavior
    * ``calendar`` --- General calendar-related functions
    * ``collections`` --- High-performance container datatypes
      * ABCs - abstract base classes
      * ``deque`` objects
        * ``deque`` Recipes
      * ``defaultdict`` objects
        * ``defaultdict`` Examples
      * ``namedtuple()`` Factory Function for Tuples with Named Fields
    * ``heapq`` --- Heap queue algorithm
      * Theory
    * ``bisect`` --- Array bisection algorithm
      * Examples
    * ``array`` --- Efficient arrays of numeric values
    * ``sets`` --- Unordered collections of unique elements
      * Set Objects
      * Example
      * Protocol for automatic conversion to immutable
      * Comparison to the built-in ``set`` types
    * ``sched`` --- Event scheduler
      * Scheduler Objects
    * ``mutex`` --- Mutual exclusion support
      * Mutex Objects
    * ``queue`` --- A synchronized queue class
      * Queue Objects
    * ``weakref`` --- Weak references
      * Weak Reference Objects
      * Example
    * ``UserDict`` --- Class wrapper for dictionary objects
    * ``UserList`` --- Class wrapper for list objects
    * ``UserString`` --- Class wrapper for string objects
    * ``types`` --- Names for built-in types
    * ``new`` --- Creation of runtime internal objects
    * ``copy`` --- Shallow and deep copy operations
    * ``pprint`` --- Data pretty printer
      * PrettyPrinter Objects
      * pprint Example
    * ``repr`` --- Alternate ``repr()`` implementation
      * Repr Objects
      * Subclassing Repr Objects
  * Numeric and Mathematical Modules
    * ``numbers`` --- Numeric abstract base classes
      * The numeric tower
      * Notes for type implementors
        * Adding More Numeric ABCs
        * Implementing the arithmetic operations
    * ``math`` --- Mathematical functions
      * Number-theoretic and representation functions
      * Power and logarithmic functions
      * Trigonometric functions
      * Angular conversion
      * Hyperbolic functions
      * Constants
    * ``cmath`` --- Mathematical functions for complex numbers
      * Conversions to and from polar coordinates
      * Power and logarithmic functions
      * Trigonometric functions
      * Hyperbolic functions
      * Classification functions
      * Constants
    * ``decimal`` --- Decimal fixed point and floating point
      arithmetic
      * Quick-start Tutorial
      * Decimal objects
        * Logical operands
      * Context objects
      * Signals
      * Floating Point Notes
        * Mitigating round-off error with increased precision
        * Special values
      * Working with threads
      * Recipes
      * Decimal FAQ
    * ``fractions`` --- Rational numbers
    * ``random`` --- Generate pseudo-random numbers
    * ``itertools`` --- Functions creating iterators for efficient
      looping
      * Itertool functions
      * Examples
      * Recipes
    * ``functools`` --- Higher order functions and operations on
      callable objects
      * ``partial`` Objects
    * ``operator`` --- Standard operators as functions
      * Mapping Operators to Functions
  * File and Directory Access
    * ``os.path`` --- Common pathname manipulations
    * ``fileinput`` --- Iterate over lines from multiple input streams
    * ``stat`` --- Interpreting ``stat()`` results
    * ``statvfs`` --- Constants used with ``os.statvfs()``
    * ``filecmp`` --- File and Directory Comparisons
      * The ``dircmp`` class
    * ``tempfile`` --- Generate temporary files and directories
    * ``glob`` --- Unix style pathname pattern expansion
    * ``fnmatch`` --- Unix filename pattern matching
    * ``linecache`` --- Random access to text lines
    * ``shutil`` --- High-level file operations
      * Example
    * ``dircache`` --- Cached directory listings
    * ``macpath`` --- Mac OS 9 path manipulation functions
  * Data Persistence
    * ``pickle`` --- Python object serialization
      * Relationship to other Python modules
      * Data stream format
      * Usage
      * What can be pickled and unpickled?
      * The pickle protocol
        * Pickling and unpickling normal class instances
        * Pickling and unpickling extension types
        * Pickling and unpickling external objects
      * Subclassing Unpicklers
      * Example
    * ``cPickle`` --- A faster ``pickle``
    * ``copy_reg`` --- Register ``pickle`` support functions
    * ``shelve`` --- Python object persistence
      * Restrictions
      * Example
    * ``marshal`` --- Internal Python object serialization
    * ``anydbm`` --- Generic access to DBM-style databases
    * ``whichdb`` --- Guess which DBM module created a database
    * ``dbm`` --- Simple "database" interface
    * ``gdbm`` --- GNU's reinterpretation of dbm
    * ``dbhash`` --- DBM-style interface to the BSD database library
      * Database Objects
    * ``bsddb`` --- Interface to Berkeley DB library
      * Hash, BTree and Record Objects
    * ``dumbdbm`` --- Portable DBM implementation
      * Dumbdbm Objects
    * ``sqlite3`` --- DB-API 2.0 interface for SQLite databases
      * Module functions and constants
      * Connection Objects
      * Cursor Objects
      * Row Objects
      * SQLite and Python types
        * Introduction
        * Using adapters to store additional Python types in SQLite
          databases
          * Letting your object adapt itself
          * Registering an adapter callable
        * Converting SQLite values to custom Python types
        * Default adapters and converters
      * Controlling Transactions
      * Using ``sqlite3`` efficiently
        * Using shortcut methods
        * Accessing columns by name instead of by index
        * Using the connection as a context manager
  * Data Compression and Archiving
    * ``zlib`` --- Compression compatible with **gzip**
    * ``gzip`` --- Support for **gzip** files
      * Examples of usage
    * ``bz2`` --- Compression compatible with **bzip2**
      * (De)compression of files
      * Sequential (de)compression
      * One-shot (de)compression
    * ``zipfile`` --- Work with ZIP archives
      * ZipFile Objects
      * PyZipFile Objects
      * ZipInfo Objects
    * ``tarfile`` --- Read and write tar archive files
      * TarFile Objects
      * TarInfo Objects
      * Examples
      * Supported tar formats
      * Unicode issues
  * File Formats
    * ``csv`` --- CSV File Reading and Writing
      * Module Contents
      * Dialects and Formatting Parameters
      * Reader Objects
      * Writer Objects
      * Examples
    * ``ConfigParser`` --- Configuration file parser
      * RawConfigParser Objects
      * ConfigParser Objects
      * SafeConfigParser Objects
      * Examples
    * ``robotparser`` ---  Parser for robots.txt
    * ``netrc`` --- netrc file processing
      * netrc Objects
    * ``xdrlib`` --- Encode and decode XDR data
      * Packer Objects
      * Unpacker Objects
      * Exceptions
    * ``plistlib`` --- Generate and parse Mac OS X ``.plist`` files
      * Examples
  * Cryptographic Services
    * ``hashlib`` --- Secure hashes and message digests
    * ``hmac`` --- Keyed-Hashing for Message Authentication
    * ``md5`` --- MD5 message digest algorithm
    * ``sha`` --- SHA-1 message digest algorithm
  * Generic Operating System Services
    * ``os`` --- Miscellaneous operating system interfaces
      * Process Parameters
      * File Object Creation
      * File Descriptor Operations
        * ``open()`` flag constants
      * Files and Directories
      * Process Management
      * Miscellaneous System Information
      * Miscellaneous Functions
    * ``io`` --- Core tools for working with streams
      * Module Interface
      * I/O Base Classes
      * Raw File I/O
      * Buffered Streams
      * Text I/O
    * ``time`` --- Time access and conversions
    * ``optparse`` --- More powerful command line option parser
      * Background
        * Terminology
        * What are options for?
        * What are positional arguments for?
      * Tutorial
        * Understanding option actions
        * The store action
        * Handling boolean (flag) options
        * Other actions
        * Default values
        * Generating help
        * Printing a version string
        * How ``optparse`` handles errors
        * Putting it all together
      * Reference Guide
        * Creating the parser
        * Populating the parser
        * Defining options
        * Option attributes
        * Standard option actions
        * Standard option types
        * Parsing arguments
        * Querying and manipulating your option parser
        * Conflicts between options
        * Cleanup
        * Other methods
      * Option Callbacks
        * Defining a callback option
        * How callbacks are called
        * Raising errors in a callback
        * Callback example 1: trivial callback
        * Callback example 2: check option order
        * Callback example 3: check option order (generalized)
        * Callback example 4: check arbitrary condition
        * Callback example 5: fixed arguments
        * Callback example 6: variable arguments
      * Extending ``optparse``
        * Adding new types
        * Adding new actions
    * ``getopt`` --- Parser for command line options
    * ``logging`` --- Logging facility for Python
      * Logging tutorial
        * Simple examples
        * Loggers
        * Handlers
        * Formatters
        * Configuring Logging
        * Configuring Logging for a Library
      * Logging Levels
      * Useful Handlers
      * Module-Level Functions
      * Logger Objects
      * Basic example
      * Logging to multiple destinations
      * Exceptions raised during logging
      * Adding contextual information to your logging output
      * Logging to a single file from multiple processes
      * Sending and receiving logging events across a network
      * Using arbitrary objects as messages
      * Optimization
      * Handler Objects
        * StreamHandler
        * FileHandler
        * WatchedFileHandler
        * RotatingFileHandler
        * TimedRotatingFileHandler
        * SocketHandler
        * DatagramHandler
        * SysLogHandler
        * NTEventLogHandler
        * SMTPHandler
        * MemoryHandler
        * HTTPHandler
      * Formatter Objects
      * Filter Objects
      * LogRecord Objects
      * LoggerAdapter Objects
      * Thread Safety
      * Configuration
        * Configuration functions
        * Configuration file format
        * Configuration server example
      * More examples
        * Multiple handlers and formatters
        * Using logging in multiple modules
    * ``getpass`` --- Portable password input
    * ``curses`` --- Terminal handling for character-cell displays
      * Functions
      * Window Objects
      * Constants
    * ``curses.textpad`` --- Text input widget for curses programs
      * Textbox objects
    * ``curses.wrapper`` --- Terminal handler for curses programs
    * ``curses.ascii`` --- Utilities for ASCII characters
    * ``curses.panel`` --- A panel stack extension for curses
      * Functions
      * Panel Objects
    * ``platform`` ---  Access to underlying platform's identifying
      data
      * Cross Platform
      * Java Platform
      * Windows Platform
        * Win95/98 specific
      * Mac OS Platform
      * Unix Platforms
    * ``errno`` --- Standard errno system symbols
    * ``ctypes`` --- A foreign function library for Python
      * ctypes tutorial
        * Loading dynamic link libraries
        * Accessing functions from loaded dlls
        * Calling functions
        * Fundamental data types
        * Calling functions, continued
        * Calling functions with your own custom data types
        * Specifying the required argument types (function prototypes)
        * Return types
        * Passing pointers (or: passing parameters by reference)
        * Structures and unions
        * Structure/union alignment and byte order
        * Bit fields in structures and unions
        * Arrays
        * Pointers
        * Type conversions
        * Incomplete Types
        * Callback functions
        * Accessing values exported from dlls
        * Surprises
        * Variable-sized data types
      * ctypes reference
        * Finding shared libraries
        * Loading shared libraries
        * Foreign functions
        * Function prototypes
        * Utility functions
        * Data types
        * Fundamental data types
        * Structured data types
        * Arrays and pointers
  * Optional Operating System Services
    * ``select`` --- Waiting for I/O completion
      * Edge and Level Trigger Polling (epoll) Objects
      * Polling Objects
      * Kqueue Objects
      * Kevent Objects
    * ``threading`` --- Higher-level threading interface
      * Thread Objects
      * Lock Objects
      * RLock Objects
      * Condition Objects
      * Semaphore Objects
        * ``Semaphore`` Example
      * Event Objects
      * Timer Objects
      * Using locks, conditions, and semaphores in the ``with``
        statement
      * Importing in threaded code
    * ``thread`` --- Multiple threads of control
    * ``dummy_threading`` --- Drop-in replacement for the
      ``threading`` module
    * ``dummy_thread`` --- Drop-in replacement for the ``thread``
      module
    * ``multiprocessing`` --- Process-based "threading" interface
      * Introduction
        * The ``Process`` class
        * Exchanging objects between processes
        * Synchronization between processes
        * Sharing state between processes
        * Using a pool of workers
      * Reference
        * ``Process`` and exceptions
        * Pipes and Queues
        * Miscellaneous
        * Connection Objects
        * Synchronization primitives
        * Shared ``ctypes`` Objects
          * The ``multiprocessing.sharedctypes`` module
        * Managers
          * Namespace objects
          * Customized managers
          * Using a remote manager
        * Proxy Objects
          * Cleanup
        * Process Pools
        * Listeners and Clients
          * Address Formats
        * Authentication keys
        * Logging
        * The ``multiprocessing.dummy`` module
      * Programming guidelines
        * All platforms
        * Windows
      * Examples
    * ``mmap`` --- Memory-mapped file support
    * ``readline`` --- GNU readline interface
      * Example
    * ``rlcompleter`` --- Completion function for GNU readline
      * Completer Objects
  * Interprocess Communication and Networking
    * ``subprocess`` --- Subprocess management
      * Using the subprocess Module
        * Convenience Functions
        * Exceptions
        * Security
      * Popen Objects
      * Replacing Older Functions with the subprocess Module
        * Replacing /bin/sh shell backquote
        * Replacing shell pipeline
        * Replacing ``os.system()``
        * Replacing the ``os.spawn`` family
        * Replacing ``os.popen()``, ``os.popen2()``, ``os.popen3()``
        * Replacing functions from the ``popen2`` module
    * ``socket`` --- Low-level networking interface
      * Socket Objects
      * Example
    * ``ssl`` --- SSL wrapper for socket objects
      * Functions, Constants, and Exceptions
      * SSLSocket Objects
      * Certificates
      * Examples
        * Testing for SSL support
        * Client-side operation
        * Server-side operation
    * ``signal`` --- Set handlers for asynchronous events
      * Example
    * ``popen2`` --- Subprocesses with accessible I/O streams
      * Popen3 and Popen4 Objects
      * Flow Control Issues
    * ``asyncore`` --- Asynchronous socket handler
      * asyncore Example basic HTTP client
    * ``asynchat`` --- Asynchronous socket command/response handler
      * asynchat - Auxiliary Classes
      * asynchat Example
  * Internet Data Handling
    * ``email`` --- An email and MIME handling package
      * ``email``: Representing an email message
      * ``email``: Parsing email messages
        * FeedParser API
        * Parser class API
        * Additional notes
      * ``email``: Generating MIME documents
      * ``email``: Creating email and MIME objects from scratch
      * ``email``: Internationalized headers
      * ``email``: Representing character sets
      * ``email``: Encoders
      * ``email``: Exception and Defect classes
      * ``email``: Miscellaneous utilities
      * ``email``: Iterators
      * ``email``: Examples
      * Package History
      * Differences from ``mimelib``
    * ``json`` --- JSON encoder and decoder
      * Basic Usage
      * Encoders and decoders
    * ``mailcap`` --- Mailcap file handling
    * ``mailbox`` --- Manipulate mailboxes in various formats
      * ``Mailbox`` objects
        * ``Maildir``
        * ``mbox``
        * ``MH``
        * ``Babyl``
        * ``MMDF``
      * ``Message`` objects
        * ``MaildirMessage``
        * ``mboxMessage``
        * ``MHMessage``
        * ``BabylMessage``
        * ``MMDFMessage``
      * Exceptions
      * Deprecated classes and methods
      * Examples
    * ``mhlib`` --- Access to MH mailboxes
      * MH Objects
      * Folder Objects
      * Message Objects
    * ``mimetools`` --- Tools for parsing MIME messages
      * Additional Methods of Message Objects
    * ``mimetypes`` --- Map filenames to MIME types
      * MimeTypes Objects
    * ``MimeWriter`` --- Generic MIME file writer
      * MimeWriter Objects
    * ``mimify`` --- MIME processing of mail messages
    * ``multifile`` --- Support for files containing distinct parts
      * MultiFile Objects
      * ``MultiFile`` Example
    * ``rfc822`` --- Parse RFC 2822 mail headers
      * Message Objects
      * AddressList Objects
    * ``base64`` --- RFC 3548: Base16, Base32, Base64 Data Encodings
    * ``binhex`` --- Encode and decode binhex4 files
      * Notes
    * ``binascii`` --- Convert between binary and ASCII
    * ``quopri`` --- Encode and decode MIME quoted-printable data
    * ``uu`` --- Encode and decode uuencode files
  * Structured Markup Processing Tools
    * ``HTMLParser`` --- Simple HTML and XHTML parser
      * Example HTML Parser Application
    * ``sgmllib`` --- Simple SGML parser
    * ``htmllib`` --- A parser for HTML documents
      * HTMLParser Objects
    * ``htmlentitydefs`` --- Definitions of HTML general entities
    * ``xml.parsers.expat`` --- Fast XML parsing using Expat
      * XMLParser Objects
      * ExpatError Exceptions
      * Example
      * Content Model Descriptions
      * Expat error constants
    * ``xml.dom`` --- The Document Object Model API
      * Module Contents
      * Objects in the DOM
        * DOMImplementation Objects
        * Node Objects
        * NodeList Objects
        * DocumentType Objects
        * Document Objects
        * Element Objects
        * Attr Objects
        * NamedNodeMap Objects
        * Comment Objects
        * Text and CDATASection Objects
        * ProcessingInstruction Objects
        * Exceptions
      * Conformance
        * Type Mapping
        * Accessor Methods
    * ``xml.dom.minidom`` --- Lightweight DOM implementation
      * DOM Objects
      * DOM Example
      * minidom and the DOM standard
    * ``xml.dom.pulldom`` --- Support for building partial DOM trees
      * DOMEventStream Objects
    * ``xml.sax`` --- Support for SAX2 parsers
      * SAXException Objects
    * ``xml.sax.handler`` --- Base classes for SAX handlers
      * ContentHandler Objects
      * DTDHandler Objects
      * EntityResolver Objects
      * ErrorHandler Objects
    * ``xml.sax.saxutils`` --- SAX Utilities
    * ``xml.sax.xmlreader`` --- Interface for XML parsers
      * XMLReader Objects
      * IncrementalParser Objects
      * Locator Objects
      * InputSource Objects
      * The ``Attributes`` Interface
      * The ``AttributesNS`` Interface
    * ``xml.etree.ElementTree`` --- The ElementTree XML API
      * Functions
      * The Element Interface
      * ElementTree Objects
      * QName Objects
      * TreeBuilder Objects
      * XMLTreeBuilder Objects
  * Internet Protocols and Support
    * ``webbrowser`` --- Convenient Web-browser controller
      * Browser Controller Objects
    * ``cgi`` --- Common Gateway Interface support
      * Introduction
      * Using the cgi module
      * Higher Level Interface
      * Old classes
      * Functions
      * Caring about security
      * Installing your CGI script on a Unix system
      * Testing your CGI script
      * Debugging CGI scripts
      * Common problems and solutions
    * ``cgitb`` --- Traceback manager for CGI scripts
    * ``wsgiref`` --- WSGI Utilities and Reference Implementation
      * ``wsgiref.util`` -- WSGI environment utilities
      * ``wsgiref.headers`` -- WSGI response header tools
      * ``wsgiref.simple_server`` -- a simple WSGI HTTP server
      * ``wsgiref.validate`` --- WSGI conformance checker
      * ``wsgiref.handlers`` -- server/gateway base classes
      * Examples
    * ``urllib`` --- Open arbitrary resources by URL
      * High-level interface
      * Utility functions
      * URL Opener objects
      * ``urllib`` Restrictions
      * Examples
    * ``urllib2`` --- extensible library for opening URLs
      * Request Objects
      * OpenerDirector Objects
      * BaseHandler Objects
      * HTTPRedirectHandler Objects
      * HTTPCookieProcessor Objects
      * ProxyHandler Objects
      * HTTPPasswordMgr Objects
      * AbstractBasicAuthHandler Objects
      * HTTPBasicAuthHandler Objects
      * ProxyBasicAuthHandler Objects
      * AbstractDigestAuthHandler Objects
      * HTTPDigestAuthHandler Objects
      * ProxyDigestAuthHandler Objects
      * HTTPHandler Objects
      * HTTPSHandler Objects
      * FileHandler Objects
      * FTPHandler Objects
      * CacheFTPHandler Objects
      * UnknownHandler Objects
      * HTTPErrorProcessor Objects
      * Examples
    * ``httplib`` --- HTTP protocol client
      * HTTPConnection Objects
      * HTTPResponse Objects
      * Examples
    * ``ftplib`` --- FTP protocol client
      * FTP Objects
    * ``poplib`` --- POP3 protocol client
      * POP3 Objects
      * POP3 Example
    * ``imaplib`` --- IMAP4 protocol client
      * IMAP4 Objects
      * IMAP4 Example
    * ``nntplib`` --- NNTP protocol client
      * NNTP Objects
    * ``smtplib`` --- SMTP protocol client
      * SMTP Objects
      * SMTP Example
    * ``smtpd`` --- SMTP Server
      * SMTPServer Objects
      * DebuggingServer Objects
      * PureProxy Objects
      * MailmanProxy Objects
    * ``telnetlib`` --- Telnet client
      * Telnet Objects
      * Telnet Example
    * ``uuid`` --- UUID objects according to RFC 4122
      * Example
    * ``urlparse`` --- Parse URLs into components
      * Results of ``urlparse()`` and ``urlsplit()``
    * ``SocketServer`` --- A framework for network servers
      * Server Creation Notes
      * Server Objects
      * RequestHandler Objects
      * Examples
        * ``SocketServer.TCPServer`` Example
        * ``SocketServer.UDPServer`` Example
        * Asynchronous Mixins
    * ``BaseHTTPServer`` --- Basic HTTP server
      * More examples
    * ``SimpleHTTPServer`` --- Simple HTTP request handler
    * ``CGIHTTPServer`` --- CGI-capable HTTP request handler
    * ``cookielib`` --- Cookie handling for HTTP clients
      * CookieJar and FileCookieJar Objects
      * FileCookieJar subclasses and co-operation with web browsers
      * CookiePolicy Objects
      * DefaultCookiePolicy Objects
      * Cookie Objects
      * Examples
    * ``Cookie`` --- HTTP state management
      * Cookie Objects
      * Morsel Objects
      * Example
    * ``xmlrpclib`` --- XML-RPC client access
      * ServerProxy Objects
      * Boolean Objects
      * DateTime Objects
      * Binary Objects
      * Fault Objects
      * ProtocolError Objects
      * MultiCall Objects
      * Convenience Functions
      * Example of Client Usage
      * Example of Client and Server Usage
    * ``SimpleXMLRPCServer`` --- Basic XML-RPC server
      * SimpleXMLRPCServer Objects
        * SimpleXMLRPCServer Example
      * CGIXMLRPCRequestHandler
    * ``DocXMLRPCServer`` --- Self-documenting XML-RPC server
      * DocXMLRPCServer Objects
      * DocCGIXMLRPCRequestHandler
  * Multimedia Services
    * ``audioop`` --- Manipulate raw audio data
    * ``imageop`` --- Manipulate raw image data
    * ``aifc`` --- Read and write AIFF and AIFC files
    * ``sunau`` --- Read and write Sun AU files
      * AU_read Objects
      * AU_write Objects
    * ``wave`` --- Read and write WAV files
      * Wave_read Objects
      * Wave_write Objects
    * ``chunk`` --- Read IFF chunked data
    * ``colorsys`` --- Conversions between color systems
    * ``imghdr`` --- Determine the type of an image
    * ``sndhdr`` --- Determine type of sound file
    * ``ossaudiodev`` --- Access to OSS-compatible audio devices
      * Audio Device Objects
      * Mixer Device Objects
  * Internationalization
    * ``gettext`` --- Multilingual internationalization services
      * GNU **gettext** API
      * Class-based API
        * The ``NullTranslations`` class
        * The ``GNUTranslations`` class
        * Solaris message catalog support
        * The Catalog constructor
      * Internationalizing your programs and modules
        * Localizing your module
        * Localizing your application
        * Changing languages on the fly
        * Deferred translations
        * ``gettext()`` vs. ``lgettext()``
      * Acknowledgements
    * ``locale`` --- Internationalization services
      * Background, details, hints, tips and caveats
      * For extension writers and programs that embed Python
      * Access to message catalogs
  * Program Frameworks
    * ``cmd`` --- Support for line-oriented command interpreters
      * Cmd Objects
    * ``shlex`` --- Simple lexical analysis
      * shlex Objects
      * Parsing Rules
  * Graphical User Interfaces with Tk
    * ``Tkinter`` --- Python interface to Tcl/Tk
      * Tkinter Modules
      * Tkinter Life Preserver
        * How To Use This Section
        * A Simple Hello World Program
      * A (Very) Quick Look at Tcl/Tk
      * Mapping Basic Tk into Tkinter
      * How Tk and Tkinter are Related
      * Handy Reference
        * Setting Options
        * The Packer
        * Packer Options
        * Coupling Widget Variables
        * The Window Manager
        * Tk Option Data Types
        * Bindings and Events
        * The index Parameter
        * Images
    * ``Tix`` --- Extension widgets for Tk
      * Using Tix
      * Tix Widgets
        * Basic Widgets
        * File Selectors
        * Hierarchical ListBox
        * Tabular ListBox
        * Manager Widgets
        * Image Types
        * Miscellaneous Widgets
        * Form Geometry Manager
      * Tix Commands
    * ``ScrolledText`` --- Scrolled Text Widget
    * ``turtle`` --- Turtle graphics for Tk
      * Introduction
      * Overview over available Turtle and Screen methods
        * Turtle methods
        * Methods of TurtleScreen/Screen
      * Methods of RawTurtle/Turtle and corresponding functions
        * Turtle motion
        * Tell Turtle's state
        * Settings for measurement
        * Pen control
          * Drawing state
          * Color control
          * Filling
          * More drawing control
        * Turtle state
          * Visibility
          * Appearance
        * Using events
        * Special Turtle methods
        * Excursus about the use of compound shapes
      * Methods of TurtleScreen/Screen and corresponding functions
        * Window control
        * Animation control
        * Using screen events
        * Settings and special methods
        * Methods specific to Screen, not inherited from TurtleScreen
      * The public classes of the module ``turtle``
      * Help and configuration
        * How to use help
        * Translation of docstrings into different languages
        * How to configure Screen and Turtles
      * Demo scripts
    * IDLE
      * Menus
        * File menu
        * Edit menu
        * Windows menu
        * Debug menu (in the Python Shell window only)
      * Basic editing and navigation
        * Automatic indentation
        * Python Shell window
      * Syntax colors
      * Startup
        * Command line usage
    * Other Graphical User Interface Packages
  * Development Tools
    * ``pydoc`` --- Documentation generator and online help system
    * ``doctest`` --- Test interactive Python examples
      * Simple Usage: Checking Examples in Docstrings
      * Simple Usage: Checking Examples in a Text File
      * How It Works
        * Which Docstrings Are Examined?
        * How are Docstring Examples Recognized?
        * What's the Execution Context?
        * What About Exceptions?
        * Option Flags and Directives
        * Warnings
      * Basic API
      * Unittest API
      * Advanced API
        * DocTest Objects
        * Example Objects
        * DocTestFinder objects
        * DocTestParser objects
        * DocTestRunner objects
        * OutputChecker objects
      * Debugging
      * Soapbox
    * ``unittest`` --- Unit testing framework
      * Basic example
      * Organizing test code
      * Re-using old test code
      * Classes and functions
      * TestCase Objects
      * TestSuite Objects
      * TestResult Objects
      * TestLoader Objects
    * 2to3 - Automated Python 2 to 3 code translation
      * Using 2to3
      * Fixers
      * ``lib2to3`` - 2to3's library
    * ``test`` --- Regression tests package for Python
      * Writing Unit Tests for the ``test`` package
      * Running tests using ``test.regrtest``
    * ``test.test_support`` --- Utility functions for tests
  * Debugging and Profiling
    * ``bdb`` --- Debugger framework
    * ``pdb`` --- The Python Debugger
    * Debugger Commands
    * The Python Profilers
      * Introduction to the profilers
      * Instant User's Manual
      * What Is Deterministic Profiling?
      * Reference Manual -- ``profile`` and ``cProfile``
        * The ``Stats`` Class
      * Limitations
      * Calibration
      * Extensions --- Deriving Better Profilers
    * ``hotshot`` --- High performance logging profiler
      * Profile Objects
      * Using hotshot data
      * Example Usage
    * ``timeit`` --- Measure execution time of small code snippets
      * Command Line Interface
      * Examples
    * ``trace`` --- Trace or track Python statement execution
      * Command Line Usage
        * Meta-options
        * Main options
        * Modifiers
        * Filters
      * Programming Interface
  * Python Runtime Services
    * ``sys`` --- System-specific parameters and functions
    * ``__builtin__`` --- Built-in objects
    * ``future_builtins`` --- Python 3 builtins
    * ``__main__`` --- Top-level script environment
    * ``warnings`` --- Warning control
      * Warning Categories
      * The Warnings Filter
      * Temporarily Suppressing Warnings
      * Testing Warnings
      * Available Functions
      * Available Context Managers
    * ``contextlib`` --- Utilities for ``with``-statement contexts
    * ``abc`` --- Abstract Base Classes
    * ``atexit`` --- Exit handlers
      * ``atexit`` Example
    * ``traceback`` --- Print or retrieve a stack traceback
      * Traceback Examples
    * ``__future__`` --- Future statement definitions
    * ``gc`` --- Garbage Collector interface
    * ``inspect`` --- Inspect live objects
      * Types and members
      * Retrieving source code
      * Classes and functions
      * The interpreter stack
    * ``site`` --- Site-specific configuration hook
    * ``user`` --- User-specific configuration hook
    * ``fpectl`` --- Floating point exception control
      * Example
      * Limitations and other considerations
    * ``distutils`` --- Building and installing Python modules
  * Custom Python Interpreters
    * ``code`` --- Interpreter base classes
      * Interactive Interpreter Objects
      * Interactive Console Objects
    * ``codeop`` --- Compile Python code
  * Restricted Execution
    * ``rexec`` --- Restricted execution framework
      * RExec Objects
      * Defining restricted environments
      * An example
    * ``Bastion`` --- Restricting access to objects
  * Importing Modules
    * ``imp`` --- Access the ``import`` internals
      * Examples
    * ``imputil`` --- Import utilities
      * Examples
    * ``zipimport`` --- Import modules from Zip archives
      * zipimporter Objects
      * Examples
    * ``pkgutil`` --- Package extension utility
    * ``modulefinder`` --- Find modules used by a script
      * Example usage of ``ModuleFinder``
    * ``runpy`` --- Locating and executing Python modules
  * Python Language Services
    * ``parser`` --- Access Python parse trees
      * Creating ST Objects
      * Converting ST Objects
      * Queries on ST Objects
      * Exceptions and Error Handling
      * ST Objects
      * Examples
        * Emulation of ``compile()``
        * Information Discovery
    * Abstract Syntax Trees
      * Node classes
      * Abstract Grammar
      * ``ast`` Helpers
    * ``symtable`` --- Access to the compiler's symbol tables
      * Generating Symbol Tables
      * Examining Symbol Tables
    * ``symbol`` --- Constants used with Python parse trees
    * ``token`` --- Constants used with Python parse trees
    * ``keyword`` --- Testing for Python keywords
    * ``tokenize`` --- Tokenizer for Python source
    * ``tabnanny`` --- Detection of ambiguous indentation
    * ``pyclbr`` --- Python class browser support
      * Class Objects
      * Function Objects
    * ``py_compile`` --- Compile Python source files
    * ``compileall`` --- Byte-compile Python libraries
    * ``dis`` --- Disassembler for Python bytecode
      * Python Bytecode Instructions
    * ``pickletools`` --- Tools for pickle developers
  * Python compiler package
    * The basic interface
    * Limitations
    * Python Abstract Syntax
      * AST Nodes
      * Assignment nodes
      * Examples
    * Using Visitors to Walk ASTs
    * Bytecode Generation
  * Miscellaneous Services
    * ``formatter`` --- Generic output formatting
      * The Formatter Interface
      * Formatter Implementations
      * The Writer Interface
      * Writer Implementations
  * MS Windows Specific Services
    * ``msilib`` --- Read and write Microsoft Installer files
      * Database Objects
      * View Objects
      * Summary Information Objects
      * Record Objects
      * Errors
      * CAB Objects
      * Directory Objects
      * Features
      * GUI classes
      * Precomputed tables
    * ``msvcrt`` -- Useful routines from the MS VC++ runtime
      * File Operations
      * Console I/O
      * Other Functions
    * ``_winreg`` -- Windows registry access
      * Constants
        * HKEY_* Constants
        * Access Rights
          * 64-bit Specific
        * Value Types
      * Registry Handle Objects
    * ``winsound`` --- Sound-playing interface for Windows
  * Unix Specific Services
    * ``posix`` --- The most common POSIX system calls
      * Large File Support
      * Notable Module Contents
    * ``pwd`` --- The password database
    * ``spwd`` --- The shadow password database
    * ``grp`` --- The group database
    * ``crypt`` --- Function to check Unix passwords
    * ``dl`` --- Call C functions in shared objects
      * Dl Objects
    * ``termios`` --- POSIX style tty control
      * Example
    * ``tty`` --- Terminal control functions
    * ``pty`` --- Pseudo-terminal utilities
    * ``fcntl`` --- The ``fcntl()`` and ``ioctl()`` system calls
    * ``pipes`` --- Interface to shell pipelines
      * Template Objects
    * ``posixfile`` --- File-like objects with locking support
    * ``resource`` --- Resource usage information
      * Resource Limits
      * Resource Usage
    * ``nis`` --- Interface to Sun's NIS (Yellow Pages)
    * ``syslog`` --- Unix syslog library routines
    * ``commands`` --- Utilities for running commands
  * Mac OS X specific services
    * ``ic`` --- Access to the Mac OS X Internet Config
      * IC Objects
    * ``MacOS`` --- Access to Mac OS interpreter features
    * ``macostools`` --- Convenience routines for file manipulation
    * ``findertools`` --- The **finder**'s Apple Events interface
    * ``EasyDialogs`` --- Basic Macintosh dialogs
      * ProgressBar Objects
    * ``FrameWork`` --- Interactive application framework
      * Application Objects
      * Window Objects
      * ControlsWindow Object
      * ScrolledWindow Object
      * DialogWindow Objects
    * ``autoGIL`` --- Global Interpreter Lock handling in event loops
    * Mac OS Toolbox Modules
      * ``Carbon.AE`` --- Apple Events
      * ``Carbon.AH`` --- Apple Help
      * ``Carbon.App`` --- Appearance Manager
      * ``Carbon.Appearance`` --- Appearance Manager constants
      * ``Carbon.CF`` --- Core Foundation
      * ``Carbon.CG`` --- Core Graphics
      * ``Carbon.CarbonEvt`` --- Carbon Event Manager
      * ``Carbon.CarbonEvents`` --- Carbon Event Manager constants
      * ``Carbon.Cm`` --- Component Manager
      * ``Carbon.Components`` --- Component Manager constants
      * ``Carbon.ControlAccessor`` --- Control Manager accssors
      * ``Carbon.Controls`` --- Control Manager constants
      * ``Carbon.CoreFounation`` --- CoreFounation constants
      * ``Carbon.CoreGraphics`` --- CoreGraphics constants
      * ``Carbon.Ctl`` --- Control Manager
      * ``Carbon.Dialogs`` --- Dialog Manager constants
      * ``Carbon.Dlg`` --- Dialog Manager
      * ``Carbon.Drag`` --- Drag and Drop Manager
      * ``Carbon.Dragconst`` --- Drag and Drop Manager constants
      * ``Carbon.Events`` --- Event Manager constants
      * ``Carbon.Evt`` --- Event Manager
      * ``Carbon.File`` --- File Manager
      * ``Carbon.Files`` --- File Manager constants
      * ``Carbon.Fm`` --- Font Manager
      * ``Carbon.Folder`` --- Folder Manager
      * ``Carbon.Folders`` --- Folder Manager constants
      * ``Carbon.Fonts`` --- Font Manager constants
      * ``Carbon.Help`` --- Help Manager
      * ``Carbon.IBCarbon`` --- Carbon InterfaceBuilder
      * ``Carbon.IBCarbonRuntime`` --- Carbon InterfaceBuilder
        constants
      * ``Carbon.Icn`` --- Carbon Icon Manager
      * ``Carbon.Icons`` --- Carbon Icon Manager constants
      * ``Carbon.Launch`` --- Carbon Launch Services
      * ``Carbon.LaunchServices`` --- Carbon Launch Services constants
      * ``Carbon.List`` --- List Manager
      * ``Carbon.Lists`` --- List Manager constants
      * ``Carbon.MacHelp`` --- Help Manager constants
      * ``Carbon.MediaDescr`` --- Parsers and generators for Quicktime
        Media descriptors
      * ``Carbon.Menu`` --- Menu Manager
      * ``Carbon.Menus`` --- Menu Manager constants
      * ``Carbon.Mlte`` --- MultiLingual Text Editor
      * ``Carbon.OSA`` --- Carbon OSA Interface
      * ``Carbon.OSAconst`` --- Carbon OSA Interface constants
      * ``Carbon.QDOffscreen`` --- QuickDraw Offscreen constants
      * ``Carbon.Qd`` --- QuickDraw
      * ``Carbon.Qdoffs`` --- QuickDraw Offscreen
      * ``Carbon.Qt`` --- QuickTime
      * ``Carbon.QuickDraw`` --- QuickDraw constants
      * ``Carbon.QuickTime`` --- QuickTime constants
      * ``Carbon.Res`` --- Resource Manager and Handles
      * ``Carbon.Resources`` --- Resource Manager and Handles
        constants
      * ``Carbon.Scrap`` --- Scrap Manager
      * ``Carbon.Snd`` --- Sound Manager
      * ``Carbon.Sound`` --- Sound Manager constants
      * ``Carbon.TE`` --- TextEdit
      * ``Carbon.TextEdit`` --- TextEdit constants
      * ``Carbon.Win`` --- Window Manager
      * ``Carbon.Windows`` --- Window Manager constants
    * ``ColorPicker`` --- Color selection dialog
  * MacPython OSA Modules
    * ``gensuitemodule`` --- Generate OSA stub packages
    * ``aetools`` --- OSA client support
    * ``aepack`` --- Conversion between Python variables and
      AppleEvent data containers
    * ``aetypes`` --- AppleEvent objects
    * ``MiniAEFrame`` --- Open Scripting Architecture server support
      * AEServer Objects
  * SGI IRIX Specific Services
    * ``al`` --- Audio functions on the SGI
      * Configuration Objects
      * Port Objects
    * ``AL`` --- Constants used with the ``al`` module
    * ``cd`` --- CD-ROM access on SGI systems
      * Player Objects
      * Parser Objects
    * ``fl`` --- FORMS library for graphical user interfaces
      * Functions Defined in Module ``fl``
      * Form Objects
      * FORMS Objects
    * ``FL`` --- Constants used with the ``fl`` module
    * ``flp`` --- Functions for loading stored FORMS designs
    * ``fm`` --- *Font Manager* interface
    * ``gl`` --- *Graphics Library* interface
    * ``DEVICE`` --- Constants used with the ``gl`` module
    * ``GL`` --- Constants used with the ``gl`` module
    * ``imgfile`` --- Support for SGI imglib files
    * ``jpeg`` --- Read and write JPEG files
  * SunOS Specific Services
    * ``sunaudiodev`` --- Access to Sun audio hardware
      * Audio Device Objects
    * ``SUNAUDIODEV`` --- Constants used with ``sunaudiodev``
  * Undocumented Modules
    * Miscellaneous useful utilities
    * Platform specific modules
    * Multimedia
    * Undocumented Mac OS modules
      * ``applesingle`` --- AppleSingle decoder
      * ``buildtools`` --- Helper module for BuildApplet and Friends
      * ``cfmfile`` --- Code Fragment Resource module
      * ``icopen`` --- Internet Config replacement for ``open()``
      * ``macerrors`` --- Mac OS Errors
      * ``macresource`` --- Locate script resources
      * ``Nav`` --- NavServices calls
      * ``PixMapWrapper`` --- Wrapper for PixMap objects
      * ``videoreader`` --- Read QuickTime movies
      * ``W`` --- Widgets built on ``FrameWork``
    * Obsolete
    * SGI-specific Extension modules
* Extending and Embedding the Python Interpreter
  * Extending Python with C or C++
    * A Simple Example
    * Intermezzo: Errors and Exceptions
    * Back to the Example
    * The Module's Method Table and Initialization Function
    * Compilation and Linkage
    * Calling Python Functions from C
    * Extracting Parameters in Extension Functions
    * Keyword Parameters for Extension Functions
    * Building Arbitrary Values
    * Reference Counts
      * Reference Counting in Python
      * Ownership Rules
      * Thin Ice
      * NULL Pointers
    * Writing Extensions in C++
    * Providing a C API for an Extension Module
  * Defining New Types
    * The Basics
      * Adding data and methods to the Basic example
      * Providing finer control over data attributes
      * Supporting cyclic garbage collection
      * Subclassing other types
    * Type Methods
      * Finalization and De-allocation
      * Object Presentation
      * Attribute Management
        * Generic Attribute Management
        * Type-specific Attribute Management
      * Object Comparison
      * Abstract Protocol Support
      * Weak Reference Support
      * More Suggestions
  * Building C and C++ Extensions with distutils
    * Distributing your extension modules
  * Building C and C++ Extensions on Windows
    * A Cookbook Approach
    * Differences Between Unix and Windows
    * Using DLLs in Practice
  * Embedding Python in Another Application
    * Very High Level Embedding
    * Beyond Very High Level Embedding: An overview
    * Pure Embedding
    * Extending Embedded Python
    * Embedding Python in C++
    * Linking Requirements
* Python/C API Reference Manual
  * Introduction
    * Include Files
    * Objects, Types and Reference Counts
      * Reference Counts
        * Reference Count Details
      * Types
    * Exceptions
    * Embedding Python
    * Debugging Builds
  * The Very High Level Layer
  * Reference Counting
  * Exception Handling
    * Recursion Control
    * Standard Exceptions
    * Deprecation of String Exceptions
  * Utilities
    * Operating System Utilities
    * System Functions
    * Process Control
    * Importing Modules
    * Data marshalling support
    * Parsing arguments and building values
    * String conversion and formatting
    * Reflection
  * Abstract Objects Layer
    * Object Protocol
    * Number Protocol
    * Sequence Protocol
    * Mapping Protocol
    * Iterator Protocol
    * Old Buffer Protocol
  * Concrete Objects Layer
    * Fundamental Objects
      * Type Objects
      * The None Object
    * Numeric Objects
      * Plain Integer Objects
      * Boolean Objects
      * Long Integer Objects
      * Floating Point Objects
      * Complex Number Objects
        * Complex Numbers as C Structures
        * Complex Numbers as Python Objects
    * Sequence Objects
      * Byte Array Objects
        * Type check macros
        * Direct API functions
        * Macros
      * String/Bytes Objects
      * Unicode Objects and Codecs
        * Unicode Objects
          * Unicode Type
          * Unicode Character Properties
          * Plain Py_UNICODE
          * wchar_t Support
        * Built-in Codecs
          * Generic Codecs
          * UTF-8 Codecs
          * UTF-32 Codecs
          * UTF-16 Codecs
          * UTF-7 Codecs
          * Unicode-Escape Codecs
          * Raw-Unicode-Escape Codecs
          * Latin-1 Codecs
          * ASCII Codecs
          * Character Map Codecs
          * MBCS codecs for Windows
          * Methods & Slots
        * Methods and Slot Functions
      * Buffer Objects
        * The new-style Py_buffer struct
        * Buffer related functions
        * Old-style buffer objects
      * Tuple Objects
      * List Objects
    * Mapping Objects
      * Dictionary Objects
    * Other Objects
      * Class and Instance Objects
      * Function Objects
      * Method Objects
      * File Objects
      * Module Objects
      * Iterator Objects
      * Descriptor Objects
      * Slice Objects
      * Weak Reference Objects
      * CObjects
      * Cell Objects
      * Generator Objects
      * DateTime Objects
      * Set Objects
  * Initialization, Finalization, and Threads
    * Thread State and the Global Interpreter Lock
    * Profiling and Tracing
    * Advanced Debugger Support
  * Memory Management
    * Overview
    * Memory Interface
    * Examples
  * Object Implementation Support
    * Allocating Objects on the Heap
    * Common Object Structures
    * Type Objects
    * Number Object Structures
    * Mapping Object Structures
    * Sequence Object Structures
    * Buffer Object Structures
    * Supporting Cyclic Garbage Collection
* Distributing Python Modules
  * An Introduction to Distutils
    * Concepts & Terminology
    * A Simple Example
    * General Python terminology
    * Distutils-specific terminology
  * Writing the Setup Script
    * Listing whole packages
    * Listing individual modules
    * Describing extension modules
      * Extension names and packages
      * Extension source files
      * Preprocessor options
      * Library options
      * Other options
    * Relationships between Distributions and Packages
    * Installing Scripts
    * Installing Package Data
    * Installing Additional Files
    * Additional meta-data
    * Debugging the setup script
  * Writing the Setup Configuration File
  * Creating a Source Distribution
    * Specifying the files to distribute
    * Manifest-related options
  * Creating Built Distributions
    * Creating dumb built distributions
    * Creating RPM packages
    * Creating Windows Installers
    * Cross-compiling on Windows
      * The Postinstallation script
    * Vista User Access Control (UAC)
  * Registering with the Package Index
    * The .pypirc file
  * Uploading Packages to the Package Index
  * Examples
    * Pure Python distribution (by module)
    * Pure Python distribution (by package)
    * Single extension module
  * Extending Distutils
    * Integrating new commands
    * Adding new distribution types
  * Command Reference
    * Installing modules: the **install** command family
      * **install_data**
      * **install_scripts**
    * Creating a source distribution: the **sdist** command
  * API Reference
    * ``distutils.core`` --- Core Distutils functionality
    * ``distutils.ccompiler`` --- CCompiler base class
    * ``distutils.unixccompiler`` --- Unix C Compiler
    * ``distutils.msvccompiler`` --- Microsoft Compiler
    * ``distutils.bcppcompiler`` --- Borland Compiler
    * ``distutils.cygwincompiler`` --- Cygwin Compiler
    * ``distutils.emxccompiler`` --- OS/2 EMX Compiler
    * ``distutils.mwerkscompiler`` --- Metrowerks CodeWarrior support
    * ``distutils.archive_util`` ---  Archiving utilities
    * ``distutils.dep_util`` --- Dependency checking
    * ``distutils.dir_util`` --- Directory tree operations
    * ``distutils.file_util`` --- Single file operations
    * ``distutils.util`` --- Miscellaneous other utility functions
    * ``distutils.dist`` --- The Distribution class
    * ``distutils.extension`` --- The Extension class
    * ``distutils.debug`` --- Distutils debug mode
    * ``distutils.errors`` --- Distutils exceptions
    * ``distutils.fancy_getopt`` --- Wrapper around the standard
      getopt module
    * ``distutils.filelist`` --- The FileList class
    * ``distutils.log`` --- Simple PEP 282-style logging
    * ``distutils.spawn`` --- Spawn a sub-process
    * ``distutils.sysconfig`` --- System configuration information
    * ``distutils.text_file`` --- The TextFile class
    * ``distutils.version`` --- Version number classes
    * ``distutils.cmd`` --- Abstract base class for Distutils commands
    * ``distutils.command`` --- Individual Distutils commands
    * ``distutils.command.bdist`` --- Build a binary installer
    * ``distutils.command.bdist_packager`` --- Abstract base class for
      packagers
    * ``distutils.command.bdist_dumb`` --- Build a "dumb" installer
    * ``distutils.command.bdist_msi`` --- Build a Microsoft Installer
      binary package
    * ``distutils.command.bdist_rpm`` --- Build a binary distribution
      as a Redhat RPM and SRPM
    * ``distutils.command.bdist_wininst`` --- Build a Windows
      installer
    * ``distutils.command.sdist`` --- Build a source distribution
    * ``distutils.command.build`` --- Build all files of a package
    * ``distutils.command.build_clib`` --- Build any C libraries in a
      package
    * ``distutils.command.build_ext`` --- Build any extensions in a
      package
    * ``distutils.command.build_py`` --- Build the .py/.pyc files of a
      package
    * ``distutils.command.build_scripts`` --- Build the scripts of a
      package
    * ``distutils.command.clean`` --- Clean a package build area
    * ``distutils.command.config`` --- Perform package configuration
    * ``distutils.command.install`` --- Install a package
    * ``distutils.command.install_data`` --- Install data files from a
      package
    * ``distutils.command.install_headers`` --- Install C/C++ header
      files from a package
    * ``distutils.command.install_lib`` --- Install library files from
      a package
    * ``distutils.command.install_scripts`` --- Install script files
      from a package
    * ``distutils.command.register`` --- Register a module with the
      Python Package Index
    * Creating a new Distutils command
* Installing Python Modules
  * Introduction
    * Best case: trivial installation
    * The new standard: Distutils
  * Standard Build and Install
    * Platform variations
    * Splitting the job up
    * How building works
    * How installation works
  * Alternate Installation
    * Alternate installation: the home scheme
    * Alternate installation: Unix (the prefix scheme)
    * Alternate installation: Windows (the prefix scheme)
  * Custom Installation
    * Modifying Python's Search Path
  * Distutils Configuration Files
    * Location and names of config files
    * Syntax of config files
  * Building Extensions: Tips and Tricks
    * Tweaking compiler/linker flags
    * Using non-Microsoft compilers on Windows
      * Borland/CodeGear C++
      * GNU C / Cygwin / MinGW
* Documenting Python
  * Introduction
  * Style Guide
  * reStructuredText Primer
    * Paragraphs
    * Inline markup
    * Lists and Quotes
    * Source Code
    * Hyperlinks
      * External links
      * Internal links
    * Sections
    * Explicit Markup
    * Directives
    * Footnotes
    * Comments
    * Source encoding
    * Gotchas
  * Additional Markup Constructs
    * Meta-information markup
    * Module-specific markup
    * Information units
    * Showing code examples
    * Inline markup
    * Cross-linking markup
    * Paragraph-level markup
    * Table-of-contents markup
    * Index-generating markup
    * Grammar production displays
    * Substitutions
  * Differences to the LaTeX markup
    * Inline markup
    * Information units
    * Structure
  * Building the documentation
    * Using make
    * Without make
* Python HOWTOs
  * Python Advocacy HOWTO
    * Reasons to Use Python
      * Programmability
      * Prototyping
      * Simplicity and Ease of Understanding
      * Java Integration
    * Arguments and Rebuttals
    * Useful Resources
  * Porting Extension Modules to 3.0
    * Conditional compilation
    * Changes to Object APIs
      * str/unicode Unification
      * long/int Unification
    * Module initialization and state
    * Other options
  * Curses Programming with Python
    * What is curses?
      * The Python curses module
    * Starting and ending a curses application
    * Windows and Pads
    * Displaying Text
      * Attributes and Color
    * User Input
    * For More Information
  * Descriptor HowTo Guide
    * Abstract
    * Definition and Introduction
    * Descriptor Protocol
    * Invoking Descriptors
    * Descriptor Example
    * Properties
    * Functions and Methods
    * Static Methods and Class Methods
  * Idioms and Anti-Idioms in Python
    * Language Constructs You Should Not Use
      * from module import *
        * Inside Function Definitions
        * At Module Level
        * When It Is Just Fine
      * Unadorned ``exec``, ``execfile()`` and friends
      * from module import name1, name2
      * except:
    * Exceptions
    * Using the Batteries
    * Using Backslash to Continue Statements
  * Functional Programming HOWTO
    * Introduction
      * Formal provability
      * Modularity
      * Ease of debugging and testing
      * Composability
    * Iterators
      * Data Types That Support Iterators
    * Generator expressions and list comprehensions
    * Generators
      * Passing values into a generator
    * Built-in functions
    * Small functions and the lambda expression
    * The itertools module
      * Creating new iterators
      * Calling functions on elements
      * Selecting elements
      * Grouping elements
    * The functools module
      * The operator module
      * The functional module
    * Revision History and Acknowledgements
    * References
      * General
      * Python-specific
      * Python documentation
  * Regular Expression HOWTO
    * Introduction
    * Simple Patterns
      * Matching Characters
      * Repeating Things
    * Using Regular Expressions
      * Compiling Regular Expressions
      * The Backslash Plague
      * Performing Matches
      * Module-Level Functions
      * Compilation Flags
    * More Pattern Power
      * More Metacharacters
      * Grouping
      * Non-capturing and Named Groups
      * Lookahead Assertions
    * Modifying Strings
      * Splitting Strings
      * Search and Replace
    * Common Problems
      * Use String Methods
      * match() versus search()
      * Greedy versus Non-Greedy
      * Not Using re.VERBOSE
    * Feedback
  * Socket Programming HOWTO
    * Sockets
      * History
    * Creating a Socket
      * IPC
    * Using a Socket
      * Binary Data
    * Disconnecting
      * When Sockets Die
    * Non-blocking Sockets
      * Performance
  * Sorting HOW TO
    * Sorting Basics
    * Key Functions
    * Operator Module Functions
    * Ascending and Descending
    * Sort Stability and Complex Sorts
    * The Old Way Using Decorate-Sort-Undecorate
    * The Old Way Using the *cmp* Parameter
    * Odd and Ends
  * Unicode HOWTO
    * Introduction to Unicode
      * History of Character Codes
      * Definitions
      * Encodings
      * References
    * Python's Unicode Support
      * The Unicode Type
      * Unicode Literals in Python Source Code
      * Unicode Properties
      * References
    * Reading and Writing Unicode Data
      * Unicode filenames
      * Tips for Writing Unicode-aware Programs
      * References
    * Revision History and Acknowledgements
  * HOWTO Fetch Internet Resources Using urllib2
    * Introduction
    * Fetching URLs
      * Data
      * Headers
    * Handling Exceptions
      * URLError
      * HTTPError
        * Error Codes
      * Wrapping it Up
        * Number 1
        * Number 2
    * info and geturl
    * Openers and Handlers
    * Basic Authentication
    * Proxies
    * Sockets and Layers
    * Footnotes
  * HOWTO Use Python in the web
    * The Low-Level View
      * Common Gateway Interface
        * Simple script for testing CGI
        * Setting up CGI on your own server
        * Common problems with CGI scripts
      * mod_python
      * FastCGI and SCGI
        * Setting up FastCGI
      * mod_wsgi
    * Step back: WSGI
      * WSGI Servers
      * Case study: MoinMoin
    * Model-View-Controller
    * Ingredients for Websites
      * Templates
      * Data persistence
    * Frameworks
      * Some notable frameworks
        * Django
        * TurboGears
        * Zope
        * Other notable frameworks
* Python Frequently Asked Questions
  * General Python FAQ
    * General Information
    * Python in the real world
    * Upgrading Python
  * Programming FAQ
    * General Questions
    * Core Language
    * Numbers and strings
    * Sequences (Tuples/Lists)
    * Dictionaries
    * Objects
    * Modules
  * Design and History FAQ
    * Why does Python use indentation for grouping of statements?
    * Why am I getting strange results with simple arithmetic
      operations?
    * Why are floating point calculations so inaccurate?
    * Why are Python strings immutable?
    * Why must 'self' be used explicitly in method definitions and
      calls?
    * Why can't I use an assignment in an expression?
    * Why does Python use methods for some functionality (e.g.
      list.index()) but functions for other (e.g. len(list))?
    * Why is join() a string method instead of a list or tuple method?
    * How fast are exceptions?
    * Why isn't there a switch or case statement in Python?
    * Can't you emulate threads in the interpreter instead of relying
      on an OS-specific thread implementation?
    * Why can't lambda forms contain statements?
    * Can Python be compiled to machine code, C or some other
      language?
    * How does Python manage memory?
    * Why isn't all memory freed when Python exits?
    * Why are there separate tuple and list data types?
    * How are lists implemented?
    * How are dictionaries implemented?
    * Why must dictionary keys be immutable?
    * Why doesn't list.sort() return the sorted list?
    * How do you specify and enforce an interface spec in Python?
    * Why are default values shared between objects?
    * Why is there no goto?
    * Why can't raw strings (r-strings) end with a backslash?
    * Why doesn't Python have a "with" statement for attribute
      assignments?
    * Why are colons required for the if/while/def/class statements?
    * Why does Python allow commas at the end of lists and tuples?
  * Library and Extension FAQ
    * General Library Questions
    * Common tasks
    * Threads
    * Input and Output
    * Network/Internet Programming
    * Databases
    * Mathematics and Numerics
  * Extending/Embedding FAQ
    * Can I create my own functions in C?
    * Can I create my own functions in C++?
    * Writing C is hard; are there any alternatives?
    * How can I execute arbitrary Python statements from C?
    * How can I evaluate an arbitrary Python expression from C?
    * How do I extract C values from a Python object?
    * How do I use Py_BuildValue() to create a tuple of arbitrary
      length?
    * How do I call an object's method from C?
    * How do I catch the output from PyErr_Print() (or anything that
      prints to stdout/stderr)?
    * How do I access a module written in Python from C?
    * How do I interface to C++ objects from Python?
    * I added a module using the Setup file and the make fails; why?
    * How do I debug an extension?
    * I want to compile a Python module on my Linux system, but some
      files are missing. Why?
    * What does "SystemError: _PyImport_FixupExtension: module
      yourmodule not loaded" mean?
    * How do I tell "incomplete input" from "invalid input"?
    * How do I find undefined g++ symbols __builtin_new or
      __pure_virtual?
    * Can I create an object class with some methods implemented in C
      and others in Python (e.g. through inheritance)?
    * When importing module X, why do I get "undefined symbol:
      PyUnicodeUCS2*"?
  * Python on Windows FAQ
    * How do I run a Python program under Windows?
    * How do I make Python scripts executable?
    * Why does Python sometimes take so long to start?
    * Where is Freeze for Windows?
    * Is a ``*.pyd`` file the same as a DLL?
    * How can I embed Python into a Windows application?
    * How do I use Python for CGI?
    * How do I keep editors from inserting tabs into my Python source?
    * How do I check for a keypress without blocking?
    * How do I emulate os.kill() in Windows?
    * Why does os.path.isdir() fail on NT shared directories?
    * cgi.py (or other CGI programming) doesn't work sometimes on NT
      or win95!
    * Why doesn't os.popen() work in PythonWin on NT?
    * Why doesn't os.popen()/win32pipe.popen() work on Win9x?
    * PyRun_SimpleFile() crashes on Windows but not on Unix; why?
    * Importing _tkinter fails on Windows 95/98: why?
    * How do I extract the downloaded documentation on Windows?
    * Missing cw3215mt.dll (or missing cw3215.dll)
    * Warning about CTL3D32 version from installer
  * Graphic User Interface FAQ
    * General GUI Questions
    * Tkinter questions
  * "Why is Python Installed on my Computer?" FAQ
    * What is Python?
    * Why is Python installed on my machine?
    * Can I delete Python?
* Glossary
* About these documents
  * Contributors to the Python Documentation
* Reporting Bugs
  * Documentation bugs
  * Using the Python issue tracker
* Copyright
* History and License
  * History of the software
  * Terms and conditions for accessing or otherwise using Python
  * Licenses and Acknowledgements for Incorporated Software
    * Mersenne Twister
    * Sockets
    * Floating point exception control
    * MD5 message digest algorithm
    * Asynchronous socket services
    * Cookie management
    * Execution tracing
    * UUencode and UUdecode functions
    * XML Remote Procedure Calls
    * test_epoll
    * Select kqueue