Product Documentation

ActivePython User Guide

• Installation Guide
• What's Included
• Release Notes
• ActivePython License
• Getting Started
• Getting Started with PyPM
• FAQ

What's New

• What's new in Python 2.6?
• What's new in Python 2.5?
  • Contents
  • 1 PEP 308: Conditional Expressions
  • 2 PEP 309: Partial Function Application
  • 3 PEP 314: Metadata for Python Software Packages v1.1
  • 4 PEP 328: Absolute and Relative Imports
  • 5 PEP 338: Executing Modules as Scripts
  • 6 PEP 341: Unified try/except/finally
  • 7 PEP 342: New Generator Features
  • 8 PEP 343: The 'with' statement
    • 8.1 Writing Context Managers
    • 8.2 The contextlib module
  • 9 PEP 352: Exceptions as New-Style Classes
  • 10 PEP 353: Using ssize_t as the index type
  • 11 PEP 357: The '__index__' method
  • 12 Other Language Changes
    • 12.1 Interactive Interpreter Changes
    • 12.2 Optimizations
  • 13 New, Improved, and Removed Modules
    • 13.1 The ctypes package
    • 13.2 The ElementTree package
    • 13.3 The hashlib package
    • 13.4 The sqlite3 package
    • 13.5 The wsgiref package
  • 14 Build and C API Changes
    • 14.1 Port-Specific Changes
  • 15 Porting to Python 2.5
  • 16 Acknowledgements
  • About this document ...
• What's new in Python 2.4?
  • Contents
  • 1 PEP 218: Built-In Set Objects
  • 2 PEP 237: Unifying Long Integers and Integers
  • 3 PEP 289: Generator Expressions
  • 4 PEP 292: Simpler String Substitutions
  • 5 PEP 318: Decorators for Functions and Methods
  • 6 PEP 322: Reverse Iteration
  • 7 PEP 324: New subprocess Module
  • 8 PEP 327: Decimal Data Type
    • 8.1 Why is Decimal needed?
    • 8.2 The Decimal type
    • 8.3 The Context type
  • 9 PEP 328: Multi-line Imports
  • 10 PEP 331: Locale-Independent Float/String Conversions
  • 11 Other Language Changes
    • 11.1 Optimizations
  • 12 New, Improved, and Deprecated Modules
    • 12.1 cookielib
    • 12.2 doctest
  • 13 Build and C API Changes
    • 13.1 Port-Specific Changes
  • 14 Porting to Python 2.4
  • 15 Acknowledgements
  • About this document ...
• What's new in Python 2.3?
  • Contents
  • 1 PEP 218: A Standard Set Datatype
  • 2 PEP 255: Simple Generators
  • 3 PEP 263: Source Code Encodings
  • 4 PEP 273: Importing Modules from Zip Archives
  • 5 PEP 277: Unicode file name support for Windows NT
  • 6 PEP 278: Universal Newline Support
  • 7 PEP 279: enumerate()
  • 8 PEP 282: The logging Package
  • 9 PEP 285: A Boolean Type
  • 10 PEP 293: Codec Error Handling Callbacks
  • 11 PEP 301: Package Index and Metadata for Distutils
  • 12 PEP 302: New Import Hooks
  • 13 PEP 305: Comma-separated Files
  • 14 PEP 307: Pickle Enhancements
  • 15 Extended Slices
  • 16 Other Language Changes
    • 16.1 String Changes
    • 16.2 Optimizations
  • 17 New, Improved, and Deprecated Modules
    • 17.1 Date/Time Type
    • 17.2 The optparse Module
  • 18 Pymalloc: A Specialized Object Allocator
  • 19 Build and C API Changes
    • 19.1 Port-Specific Changes
  • 20 Other Changes and Fixes
  • 21 Porting to Python 2.3
  • 22 Acknowledgements
  • About this document ...
• What's new in Python 2.2?
• What's new in Python 2.1?
• What's new in Python 2.0?
• The NEWS file
• The HISTORY file

Python Documentation

• Python v2.6.4 documentation
• Global Module Index
• 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, Improved, and Deprecated 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
    • 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 Terminology
    • Python Scopes and Name Spaces
    • 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
    • Commentary
  • Floating Point Arithmetic: Issues and Limitations
    • Representation Error
• Using Python
  • Command line and environment
    • Command line
      • Interface options
      • Generic options
      • Miscellaneous options
    • 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
      • 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
    • 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 Objects
  • 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
    • 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
      • 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
      • Struct Objects
    • 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() 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
      • 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
      • Logger Objects
      • Basic example
      • Logging to multiple destinations
      • Adding contextual information to your logging output
      • Sending and receiving logging events across a network
      • 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 and Functions
      • 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
      • 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
      • 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
  • 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.
    • distutils --- Building and installing Python modules
  • 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
      • 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
    • 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
        • Built-in Codecs
        • 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
• 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
  • 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
  • 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 web sites
      • Templates
      • Data persistence
    • Frameworks
      • Some notable frameworks
        • Django
        • TurboGears
        • Other notable frameworks
• Glossary
• About these documents
  • Contributors to the Python Documentation
• Reporting Bugs in Python
• 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
    • Profiling
    • Execution tracing
    • UUencode and UUdecode functions
    • XML Remote Procedure Calls
    • test_epoll
    • Select kqueue

Helpful Resources

• Non-Programmer's Tutorial for Python
  • Front Matter
  • Contents
  • Intro
    • First things first
    • Installing Python
    • Interactive Mode
    • Creating and Running Programs
    • Using Python from the command line
  • Hello, World
    • What you should know
    • Printing
    • Expressions
    • Talking to humans (and other intelligent beings)
    • Examples
    • Exercises
  • Who Goes There?
    • Input and Variables
    • Examples
    • Exercises
  • Count to 10
    • While loops
    • Examples
  • Decisions
    • If statement
    • Examples
    • Exercises
  • Debugging
    • What is debugging?
    • What should the program do?
    • What does the program do?
    • How do I fix the program?
  • Defining Functions
    • Creating Functions
    • Variables in functions
    • Function walkthrough
    • Examples
    • Exercises
  • Lists
    • Variables with more than one value
    • More features of lists
    • Examples
    • Exercises
  • For Loops
  • Boolean Expressions
    • Examples
    • Exercises
  • Dictionaries
  • Using Modules
    • Exercises
  • More on Lists
  • Revenge of the Strings
    • Examples
  • File IO
    • Exercises
  • Dealing with the imperfect (or how to handle errors)
    • Exercises
  • The End
  • FAQ
  • About this document ...
• Dive Into Python
  • 1. Installing Python
    • 1.1. Which Python is right for you?
    • 1.2. Python on Windows
    • 1.3. Python on Mac OS X
    • 1.4. Python on Mac OS 9
    • 1.5. Python on RedHat Linux
    • 1.6. Python on Debian GNU/Linux
    • 1.7. Python Installation from Source
    • 1.8. The Interactive Shell
    • 1.9. Summary
  • 2. Your First Python Program
    • 2.1. Diving in
    • 2.2. Declaring Functions
      • 2.2.1. How Python's Datatypes Compare to Other Programming Languages
    • 2.3. Documenting Functions
    • 2.4. Everything Is an Object
      • 2.4.1. The Import Search Path
      • 2.4.2. What's an Object?
    • 2.5. Indenting Code
    • 2.6. Testing Modules
  • 3. Native Datatypes
    • 3.1. Introducing Dictionaries
      • 3.1.1. Defining Dictionaries
      • 3.1.2. Modifying Dictionaries
      • 3.1.3. Deleting Items From Dictionaries
    • 3.2. Introducing Lists
      • 3.2.1. Defining Lists
      • 3.2.2. Adding Elements to Lists
      • 3.2.3. Searching Lists
      • 3.2.4. Deleting List Elements
      • 3.2.5. Using List Operators
    • 3.3. Introducing Tuples
    • 3.4. Declaring variables
      • 3.4.1. Referencing Variables
      • 3.4.2. Assigning Multiple Values at Once
    • 3.5. Formatting Strings
    • 3.6. Mapping Lists
    • 3.7. Joining Lists and Splitting Strings
      • 3.7.1. Historical Note on String Methods
    • 3.8. Summary
  • 4. The Power Of Introspection
    • 4.1. Diving In
    • 4.2. Using Optional and Named Arguments
    • 4.3. Using type, str, dir, and Other Built-In Functions
      • 4.3.1. The type Function
      • 4.3.2. The str Function
      • 4.3.3. Built-In Functions
    • 4.4. Getting Object References With getattr
      • 4.4.1. getattr with Modules
      • 4.4.2. getattr As a Dispatcher
    • 4.5. Filtering Lists
    • 4.6. The Peculiar Nature of and and or
      • 4.6.1. Using the and-or Trick
    • 4.7. Using lambda Functions
      • 4.7.1. Real-World lambda Functions
    • 4.8. Putting It All Together
    • 4.9. Summary
  • 5. Objects and Object-Orientation
    • 5.1. Diving In
    • 5.2. Importing Modules Using from module import
    • 5.3. Defining Classes
      • 5.3.1. Initializing and Coding Classes
      • 5.3.2. Knowing When to Use self and __init__
    • 5.4. Instantiating Classes
      • 5.4.1. Garbage Collection
    • 5.5. Exploring UserDict: A Wrapper Class
    • 5.6. Special Class Methods
      • 5.6.1. Getting and Setting Items
    • 5.7. Advanced Special Class Methods
    • 5.8. Introducing Class Attributes
    • 5.9. Private Functions
    • 5.10. Summary
  • 6. Exceptions and File Handling
    • 6.1. Handling Exceptions
      • 6.1.1. Using Exceptions For Other Purposes
    • 6.2. Working with File Objects
      • 6.2.1. Reading Files
      • 6.2.2. Closing Files
      • 6.2.3. Handling I/O Errors
      • 6.2.4. Writing to Files
    • 6.3. Iterating with for Loops
    • 6.4. Using sys.modules
    • 6.5. Working with Directories
    • 6.6. Putting It All Together
    • 6.7. Summary
  • 7. Regular Expressions
    • 7.1. Diving In
    • 7.2. Case Study: Street Addresses
    • 7.3. Case Study: Roman Numerals
      • 7.3.1. Checking for Thousands
      • 7.3.2. Checking for Hundreds
    • 7.4. Using the {n,m} Syntax
      • 7.4.1. Checking for Tens and Ones
    • 7.5. Verbose Regular Expressions
    • 7.6. Case study: Parsing Phone Numbers
    • 7.7. Summary
  • 8. HTML Processing
    • 8.1. Diving in
    • 8.2. Introducing sgmllib.py
    • 8.3. Extracting data from HTML documents
    • 8.4. Introducing BaseHTMLProcessor.py
    • 8.5. locals and globals
    • 8.6. Dictionary-based string formatting
    • 8.7. Quoting attribute values
    • 8.8. Introducing dialect.py
    • 8.9. Putting it all together
    • 8.10. Summary
  • 9. XML Processing
    • 9.1. Diving in
    • 9.2. Packages
    • 9.3. Parsing XML
    • 9.4. Unicode
    • 9.5. Searching for elements
    • 9.6. Accessing element attributes
    • 9.7. Segue
  • 10. Scripts and Streams
    • 10.1. Abstracting input sources
    • 10.2. Standard input, output, and error
    • 10.3. Caching node lookups
    • 10.4. Finding direct children of a node
    • 10.5. Creating separate handlers by node type
    • 10.6. Handling command-line arguments
    • 10.7. Putting it all together
    • 10.8. Summary
  • 11. HTTP Web Services
    • 11.1. Diving in
    • 11.2. How not to fetch data over HTTP
    • 11.3. Features of HTTP
      • 11.3.1. User-Agent
      • 11.3.2. Redirects
      • 11.3.3. Last-Modified/If-Modified-Since
      • 11.3.4. ETag/If-None-Match
      • 11.3.5. Compression
    • 11.4. Debugging HTTP web services
    • 11.5. Setting the User-Agent
    • 11.6. Handling Last-Modified and ETag
    • 11.7. Handling redirects
    • 11.8. Handling compressed data
    • 11.9. Putting it all together
    • 11.10. Summary
  • 12. SOAP Web Services
    • 12.1. Diving In
    • 12.2. Installing the SOAP Libraries
      • 12.2.1. Installing PyXML
      • 12.2.2. Installing fpconst
      • 12.2.3. Installing SOAPpy
    • 12.3. First Steps with SOAP
    • 12.4. Debugging SOAP Web Services
    • 12.5. Introducing WSDL
    • 12.6. Introspecting SOAP Web Services with WSDL
    • 12.7. Searching Google
    • 12.8. Troubleshooting SOAP Web Services
    • 12.9. Summary
  • 13. Unit Testing
    • 13.1. Introduction to Roman numerals
    • 13.2. Diving in
    • 13.3. Introducing romantest.py
    • 13.4. Testing for success
    • 13.5. Testing for failure
    • 13.6. Testing for sanity
  • 14. Test-First Programming
    • 14.1. roman.py, stage 1
    • 14.2. roman.py, stage 2
    • 14.3. roman.py, stage 3
    • 14.4. roman.py, stage 4
    • 14.5. roman.py, stage 5
  • 15. Refactoring
    • 15.1. Handling bugs
    • 15.2. Handling changing requirements
    • 15.3. Refactoring
    • 15.4. Postscript
    • 15.5. Summary
  • 16. Functional Programming
    • 16.1. Diving in
    • 16.2. Finding the path
    • 16.3. Filtering lists revisited
    • 16.4. Mapping lists revisited
    • 16.5. Data-centric programming
    • 16.6. Dynamically importing modules
    • 16.7. Putting it all together
    • 16.8. Summary
  • 17. Dynamic functions
    • 17.1. Diving in
    • 17.2. plural.py, stage 1
    • 17.3. plural.py, stage 2
    • 17.4. plural.py, stage 3
    • 17.5. plural.py, stage 4
    • 17.6. plural.py, stage 5
    • 17.7. plural.py, stage 6
    • 17.8. Summary
  • 18. Performance Tuning
    • 18.1. Diving in
    • 18.2. Using the timeit Module
    • 18.3. Optimizing Regular Expressions
    • 18.4. Optimizing Dictionary Lookups
    • 18.5. Optimizing List Operations
    • 18.6. Optimizing String Manipulation
    • 18.7. Summary
  • A. Further reading
  • B. A 5-minute review
  • C. Tips and tricks
  • D. List of examples
  • E. Revision history
  • F. About the book
  • G. GNU Free Documentation License
    • G.0. Preamble
    • G.1. Applicability and definitions
    • G.2. Verbatim copying
    • G.3. Copying in quantity
    • G.4. Modifications
    • G.5. Combining documents
    • G.6. Collections of documents
    • G.7. Aggregation with independent works
    • G.8. Translation
    • G.9. Termination
    • G.10. Future revisions of this license
    • G.11. How to use this License for your documents
  • H. Python license
    • H.A. History of the software
    • H.B. Terms and conditions for accessing or otherwise using Python
      • H.B.1. PSF license agreement
      • H.B.2. BeOpen Python open source license agreement version 1
      • H.B.3. CNRI open source GPL-compatible license agreement
      • H.B.4. CWI permissions statement and disclaimer
• Python FAQs
  • General Programming FAQ
  • Programming FAQ
  • Library and Extension FAQ
  • Extending/Embedding FAQ
  • Windows FAQ
  • GUI Programming FAQ
  • "Why is Python Installed on my Computer?" FAQ
• Python Enhancement Proposals (PEPs)
  • PEP 0 -- Index of Python Enhancement Proposals (PEPs)
  • PEP 1 -- PEP Purpose and Guidelines
  • PEP 2 -- Procedure for Adding New Modules
  • PEP 3 -- Guidelines for Handling Bug Reports
  • PEP 4 -- Deprecation of Standard Modules
  • PEP 5 -- Guidelines for Language Evolution
  • PEP 6 -- Bug Fix Releases
  • PEP 7 -- Style Guide for C Code
  • PEP 8 -- Style Guide for Python Code
  • PEP 9 -- Sample Plaintext PEP Template
  • PEP 10 -- Voting Guidelines
  • PEP 11 -- Removing support for little used platforms
  • PEP 12 -- Sample reStructuredText PEP Template
  • PEP 20 -- The Zen of Python
  • PEP 42 -- Feature Requests
  • PEP 100 -- Python Unicode Integration
  • PEP 101 -- Doing Python Releases 101
  • PEP 102 -- Doing Python Micro Releases
  • PEP 160 -- Python 1.6 Release Schedule
  • PEP 200 -- Python 2.0 Release Schedule
  • PEP 201 -- Lockstep Iteration
  • PEP 202 -- List Comprehensions
  • PEP 203 -- Augmented Assignments
  • PEP 204 -- Range Literals
  • PEP 205 -- Weak References
  • PEP 206 -- Python Advanced Library
  • PEP 207 -- Rich Comparisons
  • PEP 208 -- Reworking the Coercion Model
  • PEP 209 -- Multi-dimensional Arrays
  • PEP 210 -- Decoupling the Interpreter Loop
  • PEP 211 -- Adding A New Outer Product Operator
  • PEP 212 -- Loop Counter Iteration
  • PEP 213 -- Attribute Access Handlers
  • PEP 214 -- Extended Print Statement
  • PEP 215 -- String Interpolation
  • PEP 216 -- Docstring Format
  • PEP 217 -- Display Hook for Interactive Use
  • PEP 218 -- Adding a Built-In Set Object Type
  • PEP 219 -- Stackless Python
  • PEP 220 -- Coroutines, Generators, Continuations
  • PEP 221 -- Import As
  • PEP 222 -- Web Library Enhancements
  • PEP 223 -- Change the Meaning of \x Escapes
  • PEP 224 -- Attribute Docstrings
  • PEP 225 -- Elementwise/Objectwise Operators
  • PEP 226 -- Python 2.1 Release Schedule
  • PEP 227 -- Statically Nested Scopes
  • PEP 228 -- Reworking Python's Numeric Model
  • PEP 229 -- Using Distutils to Build Python
  • PEP 230 -- Warning Framework
  • PEP 231 -- __findattr__()
  • PEP 232 -- Function Attributes
  • PEP 233 -- Python Online Help
  • PEP 234 -- Iterators
  • PEP 235 -- Import on Case-Insensitive Platforms
  • PEP 236 -- Back to the __future__
  • PEP 237 -- Unifying Long Integers and Integers
  • PEP 238 -- Changing the Division Operator
  • PEP 239 -- Adding a Rational Type to Python
  • PEP 240 -- Adding a Rational Literal to Python
  • PEP 241 -- Metadata for Python Software Packages
  • PEP 242 -- Numeric Kinds
  • PEP 243 -- Module Repository Upload Mechanism
  • PEP 244 -- The `directive' statement
  • PEP 245 -- Python Interface Syntax
  • PEP 246 -- Object Adaptation
  • PEP 247 -- API for Cryptographic Hash Functions
  • PEP 248 -- Python Database API Specification v1.0
  • PEP 249 -- Python Database API Specification v2.0
  • PEP 250 -- Using site-packages on Windows
  • PEP 251 -- Python 2.2 Release Schedule
  • PEP 252 -- Making Types Look More Like Classes
  • PEP 253 -- Subtyping Built-in Types
  • PEP 254 -- Making Classes Look More Like Types
  • PEP 255 -- Simple Generators
  • PEP 256 -- Docstring Processing System Framework
  • PEP 257 -- Docstring Conventions
  • PEP 258 -- Docutils Design Specification
  • PEP 259 -- Omit printing newline after newline
  • PEP 260 -- Simplify xrange()
  • PEP 261 -- Support for "wide" Unicode characters
  • PEP 262 -- A Database of Installed Python Packages
  • PEP 0263 -- Defining Python Source Code Encodings
  • PEP 264 -- Future statements in simulated shells
  • PEP 265 -- Sorting Dictionaries by Value
  • PEP 266 -- Optimizing Global Variable/Attribute Access
  • PEP 267 -- Optimized Access to Module Namespaces
  • PEP 268 -- Extended HTTP functionality and WebDAV
  • PEP 269 -- Pgen Module for Python
  • PEP 270 -- uniq method for list objects
  • PEP 271 -- Prefixing sys.path by command line option
  • PEP 272 -- API for Block Encryption Algorithms v1.0
  • PEP 273 -- Import Modules from Zip Archives
  • PEP 274 -- Dict Comprehensions
  • PEP 0275 -- Switching on Multiple Values
  • PEP 276 -- Simple Iterator for ints
  • PEP 277 -- Unicode file name support for Windows NT
  • PEP 278 -- Universal Newline Support
  • PEP 279 -- The enumerate() built-in function
  • PEP 280 -- Optimizing access to globals
  • PEP 281 -- Loop Counter Iteration with range and xrange
  • PEP 282 -- A Logging System
  • PEP 283 -- Python 2.3 Release Schedule
  • PEP 284 -- Integer for-loops
  • PEP 285 -- Adding a bool type
  • PEP 286 -- Enhanced Argument Tuples
  • PEP 287 -- reStructuredText Docstring Format
  • PEP 288 -- Generators Attributes and Exceptions
  • PEP 289 -- Generator Expressions
  • PEP 290 -- Code Migration and Modernization
  • PEP 291 -- Backward Compatibility for Standard Library
  • PEP 292 -- Simpler String Substitutions
  • PEP 293 -- Codec Error Handling Callbacks
  • PEP 294 -- Type Names in the types Module
  • PEP 295 -- Interpretation of multiline string constants
  • PEP 296 -- Adding a bytes Object Type
  • PEP 297 -- Support for System Upgrades
  • PEP 298 -- The Locked Buffer Interface
  • PEP 299 -- Special __main__() function in modules
  • PEP 301 -- Package Index and Metadata for Distutils
  • PEP 302 -- New Import Hooks
  • PEP 303 -- Extend divmod() for Multiple Divisors
  • PEP 304 -- Controlling Generation of Bytecode Files
  • PEP 305 -- CSV File API
  • PEP 306 -- How to Change Python's Grammar
  • PEP 307 -- Extensions to the pickle protocol
  • PEP 308 -- Conditional Expressions
  • PEP 309 -- Partial Function Application
  • PEP 310 -- Reliable Acquisition/Release Pairs
  • PEP 311 -- Simplified Global Interpreter Lock Acquisition for Extensions
  • PEP 312 -- Simple Implicit Lambda
  • PEP 313 -- Adding Roman Numeral Literals to Python
  • PEP 314 -- Metadata for Python Software Packages v1.1
  • PEP 315 -- Enhanced While Loop
  • PEP 316 -- Programming by Contract for Python
  • PEP 317 -- Eliminate Implicit Exception Instantiation
  • PEP 318 -- Decorators for Functions and Methods
  • PEP 319 -- Python Synchronize/Asynchronize Block
  • PEP 320 -- Python 2.4 Release Schedule
  • PEP 321 -- Date/Time Parsing and Formatting
  • PEP 322 -- Reverse Iteration
  • PEP 323 -- Copyable Iterators
  • PEP 324 -- subprocess - New process module
  • PEP 325 -- Resource-Release Support for Generators
  • PEP 326 -- A Case for Top and Bottom Values
  • PEP 327 -- Decimal Data Type
  • PEP 328 -- Imports: Multi-Line and Absolute/Relative
  • PEP 329 -- Treating Builtins as Constants in the Standard Library
  • PEP 330 -- Python Bytecode Verification
  • PEP 331 -- Locale-Independent Float/String Conversions
  • PEP 332 -- Byte vectors and String/Unicode Unification
  • PEP 333 -- Python Web Server Gateway Interface v1.0
  • PEP 334 -- Simple Coroutines via SuspendIteration
  • PEP 335 -- Overloadable Boolean Operators
  • PEP 336 -- Make None Callable
  • PEP 337 -- Logging Usage in the Standard Library
  • PEP 338 -- Executing modules as scripts
  • PEP 339 -- Design of the CPython Compiler
  • PEP 340 -- Anonymous Block Statements
  • PEP 341 -- Unifying try-except and try-finally
  • PEP 342 -- Coroutines via Enhanced Generators
  • PEP 343 -- The "with" Statement
  • PEP 344 -- Exception Chaining and Embedded Tracebacks
  • PEP 345 -- Metadata for Python Software Packages 1.2
  • PEP 346 -- User Defined ("with") Statements
  • PEP 347 -- Migrating the Python CVS to Subversion
  • PEP 348 -- Exception Reorganization for Python 3.0
  • PEP 349 -- Allow str() to return unicode strings
  • PEP 350 -- Codetags
  • PEP 351 -- The freeze protocol
  • PEP 352 -- Required Superclass for Exceptions
  • PEP 353 -- Using ssize_t as the index type
  • PEP 354 -- Enumerations in Python
  • PEP 355 -- Path - Object oriented filesystem paths
  • PEP 356 -- Python 2.5 Release Schedule
  • PEP 357 -- Allowing Any Object to be Used for Slicing
  • PEP 358 -- The "bytes" Object
  • PEP 359 -- The "make" Statement
  • PEP 360 -- Externally Maintained Packages
  • PEP 361 -- Python 2.6 and 3.0 Release Schedule
  • PEP 362 -- Function Signature Object
  • PEP 363 -- Syntax For Dynamic Attribute Access
  • PEP 364 -- Transitioning to the Py3K Standard Library
  • PEP 365 -- Adding the pkg_resources module
  • PEP 366 -- Main module explicit relative imports
  • PEP 367 -- New Super
  • PEP 368 -- Standard image protocol and class
  • PEP 369 -- Post import hooks
  • PEP 370 -- Per user site-packages directory
  • PEP 371 -- Addition of the multiprocessing package to the standard library
  • PEP 372 -- Adding an ordered dictionary to collections
  • PEP 666 -- Reject Foolish Indentation
  • PEP 754 -- IEEE 754 Floating Point Special Values
  • PEP 3000 -- Python 3000
  • PEP 3001 -- Procedure for reviewing and improving standard library modules
  • PEP 3002 -- Procedure for Backwards-Incompatible Changes
  • PEP 3099 -- Things that will Not Change in Python 3000
  • PEP 3100 -- Miscellaneous Python 3.0 Plans
  • PEP 3101 -- Advanced String Formatting
  • PEP 3102 -- Keyword-Only Arguments
  • PEP 3103 -- A Switch/Case Statement
  • PEP 3104 -- Access to Names in Outer Scopes
  • PEP 3105 -- Make print a function
  • PEP 3106 -- Revamping dict.keys(), .values() and .items()
  • PEP 3107 -- Function Annotations
  • PEP 3108 -- Standard Library Reorganization
  • PEP 3109 -- Raising Exceptions in Python 3000
  • PEP 3110 -- Catching Exceptions in Python 3000
  • PEP 3111 -- Simple input built-in in Python 3000
  • PEP 3112 -- Bytes literals in Python 3000
  • PEP 3113 -- Removal of Tuple Parameter Unpacking
  • PEP 3114 -- Renaming iterator.next() to iterator.__next__()
  • PEP 3115 -- Metaclasses in Python 3000
  • PEP 3116 -- New I/O
  • PEP 3117 -- Postfix type declarations
  • PEP 3118 -- Revising the buffer protocol
  • PEP 3119 -- Introducing Abstract Base Classes
  • PEP 3120 -- Using UTF-8 as the default source encoding
  • PEP 3121 -- Extension Module Initialization and Finalization
  • PEP 3122 -- Delineation of the main module
  • PEP 3123 -- Making PyObject_HEAD conform to standard C
  • PEP 3124 -- Overloading, Generic Functions, Interfaces, and Adaptation
  • PEP 3125 -- Remove Backslash Continuation
  • PEP 3126 -- Remove Implicit String Concatenation
  • PEP 3127 -- Integer Literal Support and Syntax
  • PEP 3128 -- BList: A Faster List-like Type
  • PEP 3129 -- Class Decorators
  • PEP 3130 -- Access to Current Module/Class/Function
  • PEP 3131 -- Supporting Non-ASCII Identifiers
  • PEP 3132 -- Extended Iterable Unpacking
  • PEP 3133 -- Introducing Roles
  • PEP 3134 -- Exception Chaining and Embedded Tracebacks
  • PEP 3135 -- New Super
  • PEP 3136 -- Labeled break and continue
  • PEP 3137 -- Immutable Bytes and Mutable Buffer
  • PEP 3138 -- String representation in Python 3000
  • PEP 3139 -- Cleaning out sys and the "interpreter" module
  • PEP 3140 -- str(container) should call str(item), not repr(item)
  • PEP 3141 -- A Type Hierarchy for Numbers

PyWin32 Documentation

• Win32 API
  • Overviews
    • Recursive directory deletes and special files
    • Windows NT Eventlog
    • Windows NT Eventlog and Threading
    • Windows NT Files -- Locking
    • Windows NT Security -- Impersonation
    • Directory permissions with GetNamedSecurityInfo
    • Getting process info (with some COM thrown it!)
    • Windows NT/2000 Networking with the win32net module
  • Modules
    • _winxptheme
      • CloseThemeData
      • DrawThemeBackground
      • DrawThemeText
      • EnableThemeDialogTexture
      • EnableTheming
      • GetCurrentThemeName
      • GetThemeAppProperties
      • GetThemeBackgroundContentRect
      • GetThemeBackgroundExtent
      • GetWindowTheme
      • IsAppThemed
      • IsThemeActive
      • IsThemeDialogTextureEnabled
      • OpenThemeData
      • SetWindowTheme
    • mmapfile
      • mmapfile
    • odbc
      • SQLDataSources
      • odbc
    • perfmon
      • CounterDefinition
      • LoadPerfCounterTextStrings
      • ObjectType
      • PerfMonManager
      • UnloadPerfCounterTextStrings
    • pywintypes
      • ACL
      • CreateGuid
      • DosDateTimeToTime
      • HANDLE
      • HKEY
      • IID
      • IsTextUnicode
      • OVERLAPPED
      • SECURITY_ATTRIBUTES
      • SECURITY_DESCRIPTOR
      • SID
      • Time
      • Unicode
      • UnicodeFromRaw
      • WAVEFORMATEX
    • servicemanager
      • CoInitializeEx
      • CoUninitialize
      • Debugging
      • Finalize
      • Initialize
      • LogErrorMsg
      • LogInfoMsg
      • LogMsg
      • LogWarningMsg
      • PrepareToHostMultiple
      • PrepareToHostSingle
      • PumpWaitingMessages
      • RegisterServiceCtrlHandler
      • RunningAsService
      • SetEventSourceName
    • timer
      • kill_timer
      • set_timer
    • win2kras
    • win32api
      • AbortSystemShutdown
      • Apply
      • Beep
      • BeginUpdateResource
      • ChangeDisplaySettings
      • ChangeDisplaySettingsEx
      • ClipCursor
      • CloseHandle
      • CopyFile
      • DebugBreak
      • DeleteFile
      • DragFinish
      • DragQueryFile
      • DuplicateHandle
      • EndUpdateResource
      • EnumDisplayDevices
      • EnumDisplayMonitors
      • EnumDisplaySettings
      • EnumDisplaySettingsEx
      • EnumResourceLanguages
      • EnumResourceNames
      • EnumResourceTypes
      • ExitWindows
      • ExitWindowsEx
      • ExpandEnvironmentStrings
      • FindCloseChangeNotification
      • FindExecutable
      • FindFiles
      • FindFirstChangeNotification
      • FindNextChangeNotification
      • FormatMessage
      • FormatMessageW
      • FreeLibrary
      • GenerateConsoleCtrlEvent
      • GetAsyncKeyState
      • GetCommandLine
      • GetComputerName
      • GetComputerNameEx
      • GetComputerObjectName
      • GetConsoleTitle
      • GetCurrentProcess
      • GetCurrentProcessId
      • GetCurrentThread
      • GetCurrentThreadId
      • GetCursorPos
      • GetDateFormat
      • GetDiskFreeSpace
      • GetDiskFreeSpaceEx
      • GetDllDirectory
      • GetDomainName
      • GetEnvironmentVariable
      • GetFileAttributes
      • GetFileVersionInfo
      • GetFocus
      • GetFullPathName
      • GetHandleInformation
      • GetKeyState
      • GetKeyboardLayoutList
      • GetKeyboardState
      • GetLastError
      • GetLocalTime
      • GetLogicalDriveStrings
      • GetLogicalDrives
      • GetLongPathName
      • GetLongPathNameW
      • GetModuleFileName
      • GetModuleFileNameW
      • GetModuleHandle
      • GetMonitorInfo
      • GetProcAddress
      • GetProfileSection
      • GetProfileVal
      • GetShortPathName
      • GetStdHandle
      • GetSysColor
      • GetSystemDefaultLCID
      • GetSystemDefaultLangID
      • GetSystemDirectory
      • GetSystemFileCacheSize
      • GetSystemInfo
      • GetSystemMetrics
      • GetSystemTime
      • GetTempFileName
      • GetTempPath
      • GetThreadLocale
      • GetTickCount
      • GetTimeFormat
      • GetTimeZoneInformation
      • GetUserDefaultLCID
      • GetUserDefaultLangID
      • GetUserName
      • GetUserNameEx
      • GetVersion
      • GetVersionEx
      • GetVolumeInformation
      • GetWindowLong
      • GetWindowsDirectory
      • GlobalMemoryStatus
      • GlobalMemoryStatusEx
      • HIBYTE
      • HIWORD
      • InitiateSystemShutdown
      • LOBYTE
      • LOWORD
      • LoadCursor
      • LoadKeyboardLayout
      • LoadLibrary
      • LoadLibraryEx
      • LoadResource
      • LoadString
      • MAKELANGID
      • MAKELONG
      • MAKEWORD
      • MessageBeep
      • MessageBox
      • MonitorFromPoint
      • MonitorFromRect
      • MonitorFromWindow
      • MoveFile
      • MoveFileEx
      • OpenProcess
      • OutputDebugString
      • PostMessage
      • PostQuitMessage
      • PostThreadMessage
      • RGB
      • RegCloseKey
      • RegConnectRegistry
      • RegCopyTree
      • RegCreateKey
      • RegCreateKeyEx
      • RegDeleteKey
      • RegDeleteKeyEx
      • RegDeleteTree
      • RegDeleteValue
      • RegEnumKey
      • RegEnumKeyEx
      • RegEnumKeyExW
      • RegEnumValue
      • RegFlushKey
      • RegGetKeySecurity
      • RegLoadKey
      • RegNotifyChangeKeyValue
      • RegOpenCurrentUser
      • RegOpenKey
      • RegOpenKeyEx
      • RegOpenKeyTransacted
      • RegOverridePredefKey
      • RegQueryInfoKey
      • RegQueryInfoKeyW
      • RegQueryValue
      • RegQueryValueEx
      • RegRestoreKey
      • RegSaveKey
      • RegSaveKeyEx
      • RegSetKeySecurity
      • RegSetValue
      • RegSetValueEx
      • RegUnLoadKey
      • RegisterWindowMessage
      • SearchPath
      • SendMessage
      • SetClassLong
      • SetClassWord
      • SetConsoleCtrlHandler
      • SetConsoleTitle
      • SetCursor
      • SetCursorPos
      • SetDllDirectory
      • SetEnvironmentVariable
      • SetErrorMode
      • SetFileAttributes
      • SetHandleInformation
      • SetLastError
      • SetLocalTime
      • SetStdHandle
      • SetSysColors
      • SetSystemFileCacheSize
      • SetSystemPowerState
      • SetSystemTime
      • SetThreadLocale
      • SetWindowLong
      • SetWindowWord
      • ShellExecute
      • ShowCursor
      • Sleep
      • TerminateProcess
      • Unicode
      • UpdateResource
      • VkKeyScan
      • VkKeyScan
      • WinExec
      • WinHelp
      • WriteProfileSection
      • WriteProfileVal
      • keybd_event
      • mouse_event
    • win32clipboard
      • ChangeClipboardChain
      • CloseClipboard
      • CountClipboardFormats
      • EmptyClipboard
      • EnumClipboardFormats
      • GetClipboardData
      • GetClipboardDataHandle
      • GetClipboardFormatName
      • GetClipboardOwner
      • GetClipboardSequenceNumber
      • GetClipboardViewer
      • GetGlobalMemory
      • GetOpenClipboardWindow
      • GetPriorityClipboardFormat
      • IsClipboardFormatAvailable
      • OpenClipboard
      • RegisterClipboardFormat
      • SetClipboardData
      • SetClipboardText
      • SetClipboardViewer
    • win32console
      • AddConsoleAlias
      • AllocConsole
      • AttachConsole
      • CreateConsoleScreenBuffer
      • FreeConsole
      • GenerateConsoleCtrlEvent
      • GetConsoleAliasExes
      • GetConsoleAliases
      • GetConsoleCP
      • GetConsoleDisplayMode
      • GetConsoleOutputCP
      • GetConsoleProcessList
      • GetConsoleSelectionInfo
      • GetConsoleTitle
      • GetConsoleWindow
      • GetNumberOfConsoleFonts
      • GetStdHandle
      • SetConsoleCP
      • SetConsoleOutputCP
      • SetConsoleTitle
    • win32cred
      • CredDelete
      • CredEnumerate
      • CredGetTargetInfo
      • CredIsMarshaledCredential
      • CredMarshalCredential
      • CredRead
      • CredReadDomainCredentials
      • CredRename
      • CredUICmdLinePromptForCredentials
      • CredUIConfirmCredentials
      • CredUIParseUserName
      • CredUIPromptForCredentials
      • CredUIReadSSOCredW
      • CredUIStoreSSOCredW
      • CredUnmarshalCredential
      • CredWrite
      • CredWriteDomainCredentials
    • win32crypt
      • CryptProtectData
      • CryptUnprotectData
    • win32event
      • CancelWaitableTimer
      • CreateEvent
      • CreateMutex
      • CreateSemaphore
      • MsgWaitForMultipleObjects
      • MsgWaitForMultipleObjectsEx
      • OpenEvent
      • OpenMutex
      • OpenSemaphore
      • OpenWaitableTimer
      • PulseEvent
      • ReleaseMutex
      • ReleaseSemaphore
      • ResetEvent
      • SetEvent
      • SetWaitableTimer
      • WaitForInputIdle
      • WaitForMultipleObjects
      • WaitForMultipleObjectsEx
      • WaitForSingleObject
      • WaitForSingleObjectEx
    • win32evtlog
      • BackupEventLog
      • ClearEventLog
      • CloseEventLog
      • DeregisterEventSource
      • GetNumberOfEventLogRecords
      • GetOldestEventLogRecord
      • NotifyChangeEventLog
      • OpenBackupEventLog
      • OpenEventLog
      • ReadEventLog
      • RegisterEventSource
      • ReportEvent
    • win32file
      • AcceptEx
      • AddUsersToEncryptedFile
      • AllocateReadBuffer
      • AreFileApisANSI
      • BackupRead
      • BackupSeek
      • BackupWrite
      • BuildCommDCB
      • CancelIo
      • ClearCommBreak
      • ClearCommError
      • CloseEncryptedFileRaw
      • CloseHandle
      • CopyFile
      • CopyFileEx
      • CopyFileW
      • CreateDirectory
      • CreateDirectoryEx
      • CreateDirectoryExW
      • CreateDirectoryW
      • CreateFile
      • CreateFileW
      • CreateHardLink
      • CreateIoCompletionPort
      • CreateMailslot
      • CreateSymbolicLink
      • DecryptFile
      • DefineDosDevice
      • DefineDosDeviceW
      • DeleteFile
      • DeleteFileW
      • DeleteVolumeMountPoint
      • DeviceIoControl
      • DuplicateEncryptionInfoFile
      • EncryptFile
      • EncryptionDisable
      • EscapeCommFunction
      • FILE_NOTIFY_INFORMATION
      • FileEncryptionStatus
      • FindClose
      • FindCloseChangeNotification
      • FindFileNames
      • FindFilesIterator
      • FindFilesW
      • FindFirstChangeNotification
      • FindNextChangeNotification
      • FindStreams
      • FlushFileBuffers
      • GetAcceptExSockaddrs
      • GetBinaryType
      • GetCommMask
      • GetCommModemStatus
      • GetCommState
      • GetCommTimeouts
      • GetCompressedFileSize
      • GetDiskFreeSpace
      • GetDiskFreeSpaceEx
      • GetDriveType
      • GetDriveTypeW
      • GetFileAttributes
      • GetFileAttributesEx
      • GetFileAttributesW
      • GetFileInformationByHandle
      • GetFileSize
      • GetFileTime
      • GetFileType
      • GetFinalPathNameByHandle
      • GetFullPathName
      • GetLogicalDrives
      • GetLongPathName
      • GetMailslotInfo
      • GetOverlappedResult
      • GetQueuedCompletionStatus
      • GetVolumeNameForVolumeMountPoint
      • GetVolumePathName
      • GetVolumePathNamesForVolumeName
      • LockFile
      • LockFileEx
      • MoveFile
      • MoveFileEx
      • MoveFileExW
      • MoveFileW
      • MoveFileWithProgress
      • OpenEncryptedFileRaw
      • PostQueuedCompletionStatus
      • PurgeComm
      • QueryDosDevice
      • QueryRecoveryAgentsOnEncryptedFile
      • QueryUsersOnEncryptedFile
      • ReadDirectoryChangesW
      • ReadEncryptedFileRaw
      • ReadFile
      • RemoveDirectory
      • RemoveUsersFromEncryptedFile
      • ReplaceFile
      • SetCommBreak
      • SetCommMask
      • SetCommState
      • SetCommTimeouts
      • SetCurrentDirectory
      • SetEndOfFile
      • SetFileApisToANSI
      • SetFileApisToOEM
      • SetFileAttributes
      • SetFileAttributesW
      • SetFilePointer
      • SetFileShortName
      • SetFileTime
      • SetMailslotInfo
      • SetVolumeLabel
      • SetVolumeMountPoint
      • SetupComm
      • SfcGetNextProtectedFile
      • SfcIsFileProtected
      • TransmitCommChar
      • UnlockFile
      • UnlockFileEx
      • WSAAsyncSelect
      • WSAEventSelect
      • WSARecv
      • WSASend
      • WaitCommEvent
      • WriteEncryptedFileRaw
      • WriteFile
      • _get_osfhandle
      • _getmaxstdio
      • _open_osfhandle
      • _setmaxstdio
    • win32gui
      • AbortPath
      • AlphaBlend
      • AngleArc
      • AnimateWindow
      • AppendMenu
      • Arc
      • ArcTo
      • BeginPaint
      • BeginPath
      • BitBlt
      • BringWindowToTop
      • CallWindowProc
      • CheckMenuItem
      • CheckMenuRadioItem
      • ChildWindowFromPoint
      • ChildWindowFromPoint
      • Chord
      • ClientToScreen
      • CloseFigure
      • CloseWindow
      • CombineRgn
      • CombineTransform
      • CommDlgExtendedError
      • CopyIcon
      • CreateAcceleratorTable
      • CreateBitmap
      • CreateBrushIndirect
      • CreateCaret
      • CreateCompatibleBitmap
      • CreateCompatibleDC
      • CreateDC
      • CreateDialogIndirect
      • CreateEllipticRgnIndirect
      • CreateFontIndirect
      • CreateHatchBrush
      • CreateIconFromResource
      • CreateIconIndirect
      • CreateMenu
      • CreatePatternBrush
      • CreatePen
      • CreatePolygonRgn
      • CreatePopupMenu
      • CreateRectRgnIndirect
      • CreateRoundRectRgn
      • CreateSolidBrush
      • CreateWindow
      • CreateWindowEx
      • DefWindowProc
      • DeleteDC
      • DeleteMenu
      • DeleteObject
      • DestroyAccleratorTable
      • DestroyCaret
      • DestroyIcon
      • DestroyMenu
      • DestroyWindow
      • DialogBox
      • DialogBoxIndirect
      • DialogBoxIndirectParam
      • DialogBoxIndirectParam
      • DialogBoxParam
      • DispatchMessage
      • DragAcceptFiles
      • DragDetect
      • DrawAnimatedRects
      • DrawEdge
      • DrawFocusRect
      • DrawIcon
      • DrawIconEx
      • DrawMenuBar
      • DrawText
      • DrawTextW
      • Ellipse
      • EnableMenuItem
      • EnableWindow
      • EndDialog
      • EndPaint
      • EndPath
      • EnumChildWindows
      • EnumFontFamilies
      • EnumPropsEx
      • EnumThreadWindows
      • EnumWindows
      • EqualRgn
      • ExtCreatePen
      • ExtFloodFill
      • ExtTextOut
      • ExtractIcon
      • ExtractIconEx
      • FillPath
      • FillRect
      • FillRgn
      • FindWindow
      • FindWindowEx
      • FlashWindow
      • FlashWindowEx
      • FlattenPath
      • FrameRect
      • FrameRgn
      • GetActiveWindow
      • GetArcDirection
      • GetBkColor
      • GetBkMode
      • GetCapture
      • GetCaretPos
      • GetClassLong
      • GetClassName
      • GetClientRect
      • GetCurrentObject
      • GetCurrentPositionEx
      • GetCursor
      • GetCursorInfo
      • GetCursorPos
      • GetDC
      • GetDesktopWindow
      • GetDlgCtrlID
      • GetDlgItem
      • GetDlgItemInt
      • GetDlgItemText
      • GetDoubleClickTime
      • GetFocus
      • GetForegroundWindow
      • GetGraphicsMode
      • GetIconInfo
      • GetLayeredWindowAttributes
      • GetLayout
      • GetMapMode
      • GetMenu
      • GetMenuDefaultItem
      • GetMenuInfo
      • GetMenuItemCount
      • GetMenuItemID
      • GetMenuItemInfo
      • GetMenuItemRect
      • GetMenuState
      • GetMessage
      • GetMiterLimit
      • GetNextDlgGroupItem
      • GetNextDlgTabItem
      • GetObject
      • GetObjectType
      • GetOpenFileName
      • GetOpenFileNameW
      • GetParent
      • GetPath
      • GetPixel
      • GetPolyFillMode
      • GetROP2
      • GetRgnBox
      • GetSaveFileNameW
      • GetScrollInfo
      • GetStockObject
      • GetStretchBltMode
      • GetSubMenu
      • GetSysColor
      • GetSysColorBrush
      • GetSystemMenu
      • GetTextAlign
      • GetTextCharacterExtra
      • GetTextColor
      • GetTextExtentPoint32
      • GetTextFace
      • GetTextMetrics
      • GetUpdateRgn
      • GetViewportExtEx
      • GetViewportOrgEx
      • GetWindow
      • GetWindowDC
      • GetWindowExtEx
      • GetWindowLong
      • GetWindowOrgEx
      • GetWindowPlacement
      • GetWindowRect
      • GetWindowRgn
      • GetWindowRgnBox
      • GetWindowText
      • GetWorldTransform
      • GradientFill
      • HideCaret
      • ImageList_Add
      • ImageList_Create
      • ImageList_Destroy
      • ImageList_Draw
      • ImageList_DrawEx
      • ImageList_GetIcon
      • ImageList_GetImageCount
      • ImageList_LoadBitmap
      • ImageList_LoadImage
      • ImageList_Remove
      • ImageList_Replace
      • ImageList_ReplaceIcon
      • ImageList_SetBkColor
      • ImageList_SetOverlayImage
      • InitCommonControls
      • InitCommonControlsEx
      • InsertMenu
      • InsertMenuItem
      • InvalidateRect
      • InvalidateRgn
      • InvertRect
      • InvertRgn
      • IsChild
      • IsIconic
      • IsWindow
      • IsWindowEnabled
      • IsWindowVisible
      • LOGFONT
      • LineTo
      • ListView_SortItems
      • ListView_SortItemsEx
      • LoadCursor
      • LoadIcon
      • LoadImage
      • LoadMenu
      • MaskBlt
      • MessageBeep
      • MessageBox
      • ModifyMenu
      • ModifyWorldTransform
      • MoveToEx
      • MoveWindow
      • OffsetRgn
      • PaintDesktop
      • PaintRgn
      • PatBlt
      • PathToRegion
      • PeekMessage
      • Pie
      • PlgBlt
      • PolyBezier
      • PolyBezierTo
      • Polygon
      • Polyline
      • PolylineTo
      • PostMessage
      • PostQuitMessage
      • PostThreadMessage
      • PtInRect
      • PtInRegion
      • PumpMessages
      • PumpWaitingMessages
      • PyGetArraySignedLong
      • PyGetBufferAddressAndLen
      • PyGetString
      • PyMakeBuffer
      • PySetMemory
      • PySetString
      • RectInRegion
      • Rectangle
      • RedrawWindow
      • RegisterClass
      • RegisterDeviceNotification
      • RegisterWindowMessage
      • ReleaseCapture
      • ReleaseDC
      • RemoveMenu
      • ReplyMessage
      • RestoreDC
      • RoundRect
      • SaveDC
      • ScreenToClient
      • ScrollWindowEx
      • SelectObject
      • SendMessage
      • SendMessageTimeout
      • SetActiveWindow
      • SetArcDirection
      • SetBkColor
      • SetBkMode
      • SetCapture
      • SetCaretPos
      • SetCursor
      • SetDlgItemInt
      • SetDlgItemText
      • SetDoubleClickTime
      • SetFocus
      • SetForegroundWindow
      • SetGraphicsMode
      • SetLayeredWindowAttributes
      • SetLayout
      • SetMapMode
      • SetMenu
      • SetMenuDefaultItem
      • SetMenuInfo
      • SetMenuItemBitmaps
      • SetMenuItemInfo
      • SetMiterLimit
      • SetParent
      • SetPixel
      • SetPixelV
      • SetPolyFillMode
      • SetROP2
      • SetRectRgn
      • SetScrollInfo
      • SetStretchBltMode
      • SetTextAlign
      • SetTextCharacterExtra
      • SetTextColor
      • SetViewportExtEx
      • SetViewportOrgEx
      • SetWindowExtEx
      • SetWindowLong
      • SetWindowOrgEx
      • SetWindowPlacement
      • SetWindowPos
      • SetWindowRgn
      • SetWindowText
      • SetWorldTransform
      • Shell_NotifyIcon
      • ShowCaret
      • ShowWindow
      • StretchBlt
      • StrokeAndFillPath
      • StrokePath
      • SystemParametersInfo
      • TrackPopupMenu
      • TranslateAccelerator
      • TranslateMessage
      • TransparentBlt
      • UnregisterClass
      • UnregisterDeviceNotification
      • UpdateLayeredWindow
      • UpdateWindow
      • ValidateRgn
      • WaitMessage
      • WidenPath
      • WindowFromDC
      • WindowFromPoint
      • _TrackMouseEvent
      • set_logger
    • win32help
      • HHNTRACK
      • HHN_NOTIFY
      • HH_AKLINK
      • HH_FTS_QUERY
      • HH_POPUP
      • HH_WINTYPE
      • HtmlHelp
      • NMHDR
      • WinHelp
    • win32inet
      • CommitUrlCacheEntry
      • CreateUrlCacheEntry
      • CreateUrlCacheGroup
      • DeleteUrlCacheEntry
      • DeleteUrlCacheGroup
      • FindCloseUrlCache
      • FindFirstUrlCacheEntry
      • FindFirstUrlCacheEntryEx
      • FindFirstUrlCacheGroup
      • FindNextUrlCacheEntry
      • FindNextUrlCacheEntryEx
      • FindNextUrlCacheGroup
      • FtpCommand
      • FtpOpenFile
      • GetUrlCacheEntryInfo
      • GetUrlCacheGroupAttribute
      • InternetAttemptConnect
      • InternetCanonicalizeUrl
      • InternetCheckConnection
      • InternetCloseHandle
      • InternetConnect
      • InternetGetCookie
      • InternetGetLastResponseInfo
      • InternetGoOnline
      • InternetOpen
      • InternetOpenUrl
      • InternetQueryOption
      • InternetReadFile
      • InternetSetCookie
      • InternetSetOption
      • InternetWriteFile
      • SetUrlCacheEntryGroup
      • SetUrlCacheGroupAttribute
    • win32job
      • AssignProcessToJobObject
      • CreateJobObject
      • IsProcessInJob
      • OpenJobObject
      • QueryInformationJobObject
      • SetInformationJobObject
      • TerminateJobObject
      • UserHandleGrantAccess
    • win32lz
      • Close
      • Copy
      • GetExpandedName
      • Init
      • OpenFile
    • win32net
      • NetFileClose
      • NetFileEnum
      • NetFileGetInfo
      • NetGetAnyDCName
      • NetGetDCName
      • NetGetJoinInformation
      • NetGroupAdd
      • NetGroupAdd
      • NetGroupAddUser
      • NetGroupDel
      • NetGroupDel
      • NetGroupDelUser
      • NetGroupEnum
      • NetGroupEnum
      • NetGroupGetInfo
      • NetGroupGetInfo
      • NetGroupGetUsers
      • NetGroupSetInfo
      • NetGroupSetInfo
      • NetGroupSetUsers
      • NetLocalGroupAddMembers
      • NetLocalGroupDelMembers
      • NetLocalGroupGetMembers
      • NetLocalGroupSetMembers
      • NetMessageBufferSend
      • NetMessageNameAdd
      • NetMessageNameDel
      • NetMessageNameEnum
      • NetServerComputerNameAdd
      • NetServerComputerNameDel
      • NetServerDiskEnum
      • NetServerEnum
      • NetServerGetInfo
      • NetServerSetInfo
      • NetSessionDel
      • NetSessionEnum
      • NetSessionGetInfo
      • NetShareAdd
      • NetShareCheck
      • NetShareDel
      • NetShareEnum
      • NetShareGetInfo
      • NetShareSetInfo
      • NetStatisticsGet
      • NetUseAdd
      • NetUseDel
      • NetUseEnum
      • NetUseGetInfo
      • NetUserAdd
      • NetUserChangePassword
      • NetUserDel
      • NetUserEnum
      • NetUserGetGroups
      • NetUserGetInfo
      • NetUserGetLocalGroups
      • NetUserModalsGet
      • NetUserModalsSet
      • NetUserSetInfo
      • NetValidateName
      • NetValidatePasswordPolicy
      • NetWkstaGetInfo
      • NetWkstaSetInfo
      • NetWkstaTransportAdd
      • NetWkstaTransportDel
      • NetWkstaTransportEnum