documentation.HELP! IronPython Documentation

IronPython v2.7.4a1 documentation

IronPython

Table of contents

• IronPython v2.7.4a1 documentation
• Global Module Index
• What's New in Python
  • What's New in Python 2.7
    • The Future for Python 2.x
    • Python 3.1 Features
    • PEP 372: Adding an Ordered Dictionary to collections
    • PEP 378: Format Specifier for Thousands Separator
    • PEP 389: The argparse Module for Parsing Command Lines
    • PEP 391: Dictionary-Based Configuration For Logging
    • PEP 3106: Dictionary Views
    • PEP 3137: The memoryview Object
    • Other Language Changes
      • Interpreter Changes
      • Optimizations
    • New and Improved Modules
      • New module: importlib
      • New module: sysconfig
      • ttk: Themed Widgets for Tk
      • Updated module: unittest
      • Updated module: ElementTree 1.3
    • Build and C API Changes
      • Capsules
      • Port-Specific Changes: Windows
      • Port-Specific Changes: Mac OS X
      • Port-Specific Changes: FreeBSD
    • Other Changes and Fixes
    • Porting to Python 2.7
    • Acknowledgements
  • What's New in Python 2.6
    • Python 3.0
      • 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 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 3119: Abstract Base Classes
    • PEP 3127: Integer Literal Support and Syntax
    • PEP 3129: Class Decorators
    • PEP 3141: A Type Hierarchy for Numbers
      • The fractions Module
    • Other Language Changes
      • Optimizations
      • Interpreter Changes
    • New and Improved Modules
      • The future_builtins module
      • The json module: JavaScript Object Notation
      • The plistlib module: A Property-List Parser
      • ctypes Enhancements
      • Improved SSL Support
    • Deprecations and Removals
    • Acknowledgements
  • What's New in Python 2.5 (IronPython 2.0)
    • 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 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
      • Port-Specific Changes
    • Porting to IronPython 2.0
    • Acknowledgements
• The Python Tutorial
  • Whetting Your Appetite
  • Using the Python Interpreter
    • Invoking the Interpreter
      • Argument Passing
      • Interactive Mode
    • The Interpreter and Its Environment
      • Error Handling
      • Executable Python Scripts
      • Source Code Encoding
      • The Interactive Startup File
  • An Informal Introduction to Python
    • Using Python as a Calculator
      • Numbers
      • Strings
      • Unicode Strings
      • Lists
    • First Steps Towards Programming
  • More Control Flow Tools
    • if Statements
    • for Statements
    • The range() Function
    • break and continue Statements, and else Clauses on Loops
    • pass Statements
    • Defining Functions
    • More on Defining Functions
      • Default Argument Values
      • Keyword Arguments
      • Arbitrary Argument Lists
      • Unpacking Argument Lists
      • Lambda Forms
      • Documentation Strings
    • Intermezzo: Coding Style
  • Data Structures
    • More on Lists
      • Using Lists as Stacks
      • Using Lists as Queues
      • Functional Programming Tools
      • List Comprehensions
      • Nested List Comprehensions
    • The del statement
    • Tuples and Sequences
    • Sets
    • Dictionaries
    • Looping Techniques
    • More on Conditions
    • Comparing Sequences and Other Types
  • Modules
    • More on Modules
      • Executing modules as scripts
      • The Module Search Path
      • "Compiled" Python files
    • Standard Modules
    • The dir() Function
    • Packages
      • Importing * From a Package
      • Intra-package References
      • Packages in Multiple Directories
  • Input and Output
    • Fancier Output Formatting
      • Old string formatting
    • Reading and Writing Files
      • Methods of File Objects
      • The pickle Module
  • Errors and Exceptions
    • Syntax Errors
    • Exceptions
    • Handling Exceptions
    • Raising Exceptions
    • User-defined Exceptions
    • Defining Clean-up Actions
    • Predefined Clean-up Actions
  • Classes
    • A Word About Names and Objects
    • Python Scopes and Namespaces
    • A First Look at Classes
      • Class Definition Syntax
      • Class Objects
      • Instance Objects
      • Method Objects
    • Random Remarks
    • Inheritance
      • Multiple Inheritance
    • Private Variables
    • Odds and Ends
    • Exceptions Are Classes Too
    • Iterators
    • Generators
    • Generator Expressions
  • Brief Tour of the Standard Library
    • Operating System Interface
    • File Wildcards
    • Command Line Arguments
    • Error Output Redirection and Program Termination
    • String Pattern Matching
    • Mathematics
    • Internet Access
    • Dates and Times
    • Data Compression
    • Performance Measurement
    • Quality Control
    • Batteries Included
  • Brief Tour of the Standard Library -- Part II
    • Output Formatting
    • Templating
    • Working with Binary Data Record Layouts
    • Multi-threading
    • Logging
    • Weak References
    • Tools for Working with Lists
    • Decimal Floating Point Arithmetic
  • What Now?
  • Interactive Input Editing and History Substitution
    • Line Editing
    • History Substitution
    • Key Bindings
    • Alternatives to the Interactive Interpreter
  • Floating Point Arithmetic: Issues and Limitations
    • Representation Error
• Using Python
  • Command line and environment
    • Command line
      • Interface options
      • Generic options
      • Miscellaneous options
      • Options you shouldn't use
    • Environment variables
      • Debug-mode variables
• The Python Language Reference
  • Introduction
    • Alternate Implementations
    • Notation
  • Lexical analysis
    • Line structure
      • Logical lines
      • Physical lines
      • Comments
      • Encoding declarations
      • Explicit line joining
      • Implicit line joining
      • Blank lines
      • Indentation
      • Whitespace between tokens
    • Other tokens
    • Identifiers and keywords
      • Keywords
      • Reserved classes of identifiers
    • Literals
      • String literals
      • String literal concatenation
      • Numeric literals
      • Integer and long integer literals
      • Floating point literals
      • Imaginary literals
    • Operators
    • Delimiters
  • Data model
    • Objects, values and types
    • The standard type hierarchy
    • New-style and classic classes
    • Special method names
      • Basic customization
      • Customizing attribute access
        • More attribute access for new-style classes
        • Implementing Descriptors
        • Invoking Descriptors
        • __slots__
      • Customizing class creation
      • Customizing instance and subclass checks
      • Emulating callable objects
      • Emulating container types
      • Additional methods for emulation of sequence types
      • Emulating numeric types
      • Coercion rules
      • With Statement Context Managers
      • Special method lookup for old-style classes
      • Special method lookup for new-style classes
  • Execution model
    • Naming and binding
      • Interaction with dynamic features
    • Exceptions
  • Expressions
    • Arithmetic conversions
    • Atoms
      • Identifiers (Names)
      • Literals
      • Parenthesized forms
      • List displays
      • Displays for sets and dictionaries
      • Generator expressions
      • Dictionary displays
      • Set displays
      • String conversions
      • Yield expressions
    • Primaries
      • Attribute references
      • Subscriptions
      • Slicings
      • Calls
    • The power operator
    • Unary arithmetic and bitwise operations
    • Binary arithmetic operations
    • Shifting operations
    • Binary bitwise operations
    • Comparisons
    • Boolean operations
    • Conditional Expressions
    • Lambdas
    • Expression lists
    • Evaluation order
    • Summary
  • Simple statements
    • Expression statements
    • Assignment statements
      • Augmented assignment statements
    • The assert statement
    • The pass statement
    • The del statement
    • The print statement
    • The return statement
    • The yield statement
    • The raise statement
    • The break statement
    • The continue statement
    • The import statement
      • Future statements
    • The global statement
    • The exec statement
  • Compound statements
    • The if statement
    • The while statement
    • The for statement
    • The try statement
    • The with statement
    • Function definitions
    • Class definitions
  • Top-level components
    • Complete Python programs
    • File input
    • Interactive input
    • Expression input
  • Full Grammar specification
• The Python Standard Library
  • Introduction
  • Built-in Functions
  • Non-essential Built-in Functions
  • Built-in Constants
    • Constants added by the site module
  • Built-in Types
    • Truth Value Testing
    • Boolean Operations --- and, or, not
    • Comparisons
    • Numeric Types --- int, float, long, complex
      • Bit-string Operations on Integer Types
      • Additional Methods on Integer Types
      • Additional Methods on Float
    • Iterator Types
      • Generator Types
    • Sequence Types --- str, unicode, list, tuple, buffer, xrange
      • String Methods
      • String Formatting Operations
      • XRange Type
      • Mutable Sequence Types
    • Set Types --- set, frozenset
    • Mapping Types --- dict
      • Dictionary view objects
    • File Objects
    • memoryview type
    • Context Manager Types
    • Other Built-in Types
      • Modules
      • Classes and Class Instances
      • Functions
      • Methods
      • Code Objects
      • Type Objects
      • The Null Object
      • The Ellipsis Object
      • Boolean Values
      • Internal Objects
    • Special Attributes
  • Built-in Exceptions
    • Exception hierarchy
  • String Services
    • string --- Common string operations
      • String constants
      • String Formatting
      • Format String Syntax
        • Format Specification Mini-Language
        • Format examples
      • Template strings
      • String functions
      • Deprecated string functions
    • re --- Regular expression operations
      • Regular Expression Syntax
      • Matching vs Searching
      • Module Contents
      • Regular Expression Objects
      • Match Objects
      • Examples
        • Checking For a Pair
        • Simulating scanf()
        • Avoiding recursion
        • search() vs. match()
        • Making a Phonebook
        • Text Munging
        • Finding all Adverbs
        • Finding all Adverbs and their Positions
        • Raw String Notation
    • struct --- Interpret strings as packed binary data
      • Functions and Exceptions
      • Format Strings
        • Byte Order, Size, and Alignment
        • Format Characters
        • Examples
      • Classes
    • difflib --- Helpers for computing deltas
      • SequenceMatcher Objects
      • SequenceMatcher Examples
      • Differ Objects
      • Differ Example
      • A command-line interface to difflib
    • StringIO --- Read and write strings as files
    • cStringIO --- Faster version of StringIO
    • textwrap --- Text wrapping and filling
    • codecs --- Codec registry and base classes
      • Codec Base Classes
        • Codec Objects
        • IncrementalEncoder Objects
        • IncrementalDecoder Objects
        • StreamWriter Objects
        • StreamReader Objects
        • StreamReaderWriter Objects
        • StreamRecoder Objects
      • Encodings and Unicode
      • Standard Encodings
      • encodings.idna --- Internationalized Domain Names in Applications
      • encodings.utf_8_sig --- UTF-8 codec with BOM signature
    • unicodedata --- Unicode Database
    • stringprep --- Internet String Preparation
    • fpformat --- Floating point conversions
  • Data Types
    • datetime --- Basic date and time types
      • Available Types
      • timedelta Objects
      • date Objects
      • datetime Objects
      • time Objects
      • tzinfo Objects
      • strftime() and strptime() Behavior
    • calendar --- General calendar-related functions
    • collections --- High-performance container datatypes
      • ABCs - abstract base classes
      • Counter objects
      • deque objects
        • deque Recipes
      • defaultdict objects
        • defaultdict Examples
      • namedtuple() Factory Function for Tuples with Named Fields
      • OrderedDict objects
    • 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
      • Special 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
      • 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
      • Directory and files operations
        • copytree example
      • Archives operations
        • Archiving example
    • dircache --- Cached directory listings
  • 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
    • dbhash --- DBM-style interface to the BSD database library
      • Database Objects
    • dumbdbm --- Portable DBM implementation
      • Dumbdbm Objects
    • sqlite3 --- DB-API 2.0 interface for SQLite databases
      • Module functions and constants
      • Connection Objects
      • Cursor Objects
      • Row Objects
      • SQLite and Python types
        • Introduction
        • Using adapters to store additional Python types in SQLite databases
          • Letting your object adapt itself
          • Registering an adapter callable
        • Converting SQLite values to custom Python types
        • Default adapters and converters
      • Controlling Transactions
      • Using sqlite3 efficiently
        • Using shortcut methods
        • Accessing columns by name instead of by index
        • Using the connection as a context manager
  • Data Compression and Archiving
    • zlib --- Compression compatible with gzip
    • gzip --- Support for gzip files
      • Examples of usage
    • bz2 --- Compression compatible with bzip2
      • (De)compression of files
      • Sequential (de)compression
      • One-shot (de)compression
    • zipfile --- Work with ZIP archives
      • ZipFile Objects
      • PyZipFile Objects
      • ZipInfo Objects
    • tarfile --- Read and write tar archive files
      • TarFile Objects
      • TarInfo Objects
      • Examples
      • Supported tar formats
      • Unicode issues
  • File Formats
    • csv --- CSV File Reading and Writing
      • Module Contents
      • Dialects and Formatting Parameters
      • Reader Objects
      • Writer Objects
      • Examples
    • ConfigParser --- Configuration file parser
      • RawConfigParser Objects
      • ConfigParser Objects
      • SafeConfigParser Objects
      • Examples
    • robotparser --- Parser for robots.txt
    • netrc --- netrc file processing
      • netrc Objects
    • xdrlib --- Encode and decode XDR data
      • Packer Objects
      • Unpacker Objects
      • Exceptions
    • plistlib --- Generate and parse Mac OS X .plist files
      • Examples
  • Cryptographic Services
    • hashlib --- Secure hashes and message digests
    • hmac --- Keyed-Hashing for Message Authentication
    • md5 --- MD5 message digest algorithm
    • sha --- SHA-1 message digest algorithm
  • Generic Operating System Services
    • os --- Miscellaneous operating system interfaces
      • Process Parameters
      • File Object Creation
      • File Descriptor Operations
        • open() flag constants
      • Files and Directories
      • Process Management
      • Miscellaneous System Information
      • Miscellaneous Functions
    • io --- Core tools for working with streams
      • Module Interface
      • I/O Base Classes
      • Raw File I/O
      • Buffered Streams
      • Text I/O
    • time --- Time access and conversions
    • argparse -- Parser for command line options, arguments and sub-commands
      • Example
        • Creating a parser
        • Adding arguments
        • Parsing arguments
      • ArgumentParser objects
        • description
        • epilog
        • add_help
        • prefix_chars
        • fromfile_prefix_chars
        • argument_default
        • parents
        • formatter_class
        • conflict_handler
        • prog
        • usage
      • The add_argument() method
        • name or flags
        • action
        • nargs
        • const
        • default
        • type
        • choices
        • required
        • help
        • metavar
        • dest
      • The parse_args() method
        • Option value syntax
        • Invalid arguments
        • Arguments containing "-"
        • Argument abbreviations
        • Beyond sys.argv
        • Custom namespaces
      • Other utilities
        • Sub-commands
        • FileType objects
        • Argument groups
        • Mutual exclusion
        • Parser defaults
        • Printing help
        • Partial parsing
        • Customizing file parsing
      • Upgrading optparse code
    • optparse --- Parser for command line options
      • 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 --- C-style parser for command line options
    • logging --- Logging facility for Python
      • Logging tutorial
        • Simple examples
        • Loggers
        • Handlers
        • Formatters
        • Configuring Logging
        • Configuring Logging for a Library
      • Logging Levels
      • Useful Handlers
      • Module-Level Functions
      • Logger Objects
      • Basic example
      • Logging to multiple destinations
      • Exceptions raised during logging
      • Adding contextual information to your logging output
      • Logging to a single file from multiple processes
      • Sending and receiving logging events across a network
      • Using arbitrary objects as messages
      • Optimization
      • Handler Objects
        • StreamHandler
        • FileHandler
        • NullHandler
        • WatchedFileHandler
        • RotatingFileHandler
        • TimedRotatingFileHandler
        • SocketHandler
        • DatagramHandler
        • SysLogHandler
        • NTEventLogHandler
        • SMTPHandler
        • MemoryHandler
        • HTTPHandler
      • Formatter Objects
      • Filter Objects
      • LogRecord Objects
      • LoggerAdapter Objects
      • Thread Safety
      • Integration with the warnings module
      • Configuration
        • Configuration functions
        • Configuration dictionary schema
          • Dictionary Schema Details
          • Incremental Configuration
          • Object connections
          • User-defined objects
          • Access to external objects
          • Access to internal objects
        • 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
    • rlcompleter --- Completion function for GNU readline
      • Completer Objects
  • Interprocess Communication and Networking
    • subprocess --- Subprocess management
      • Using the subprocess Module
        • Convenience Functions
        • Exceptions
        • Security
      • Popen Objects
      • Replacing Older Functions with the subprocess Module
        • Replacing /bin/sh shell backquote
        • Replacing shell pipeline
        • Replacing os.system()
        • Replacing the os.spawn family
        • Replacing os.popen(), os.popen2(), os.popen3()
        • Replacing functions from the popen2 module
    • socket --- Low-level networking interface
      • Socket Objects
      • Example
    • ssl --- SSL wrapper for socket objects
      • Functions, Constants, and Exceptions
      • SSLSocket Objects
      • Certificates
      • Examples
        • Testing for SSL support
        • Client-side operation
        • Server-side operation
    • signal --- Set handlers for asynchronous events
      • Example
    • popen2 --- Subprocesses with accessible I/O streams
      • Popen3 and Popen4 Objects
      • Flow Control Issues
    • asyncore --- Asynchronous socket handler
      • asyncore Example basic HTTP client
    • asynchat --- Asynchronous socket command/response handler
      • asynchat - Auxiliary Classes
      • asynchat Example
  • Internet Data Handling
    • email --- An email and MIME handling package
      • email: Representing an email message
      • email: Parsing email messages
        • FeedParser API
        • Parser class API
        • Additional notes
      • email: Generating MIME documents
      • email: Creating email and MIME objects from scratch
      • email: Internationalized headers
      • email: Representing character sets
      • email: Encoders
      • email: Exception and Defect classes
      • email: Miscellaneous utilities
      • email: Iterators
      • email: Examples
      • Package History
      • Differences from mimelib
    • json --- JSON encoder and decoder
      • Basic Usage
      • Encoders and decoders
    • mailcap --- Mailcap file handling
    • mailbox --- Manipulate mailboxes in various formats
      • Mailbox objects
        • Maildir
        • mbox
        • MH
        • Babyl
        • MMDF
      • Message objects
        • MaildirMessage
        • mboxMessage
        • MHMessage
        • BabylMessage
        • MMDFMessage
      • Exceptions
      • Deprecated classes and methods
      • Examples
    • mhlib --- Access to MH mailboxes
      • MH Objects
      • Folder Objects
      • Message Objects
    • mimetools --- Tools for parsing MIME messages
      • Additional Methods of Message Objects
    • mimetypes --- Map filenames to MIME types
      • MimeTypes Objects
    • MimeWriter --- Generic MIME file writer
      • MimeWriter Objects
    • mimify --- MIME processing of mail messages
    • multifile --- Support for files containing distinct parts
      • MultiFile Objects
      • MultiFile Example
    • rfc822 --- Parse RFC 2822 mail headers
      • Message Objects
      • AddressList Objects
    • base64 --- RFC 3548: Base16, Base32, Base64 Data Encodings
    • binhex --- Encode and decode binhex4 files
      • Notes
    • binascii --- Convert between binary and ASCII
    • quopri --- Encode and decode MIME quoted-printable data
    • uu --- Encode and decode uuencode files
  • Structured Markup Processing Tools
    • HTMLParser --- Simple HTML and XHTML parser
      • Example HTML Parser Application
    • sgmllib --- Simple SGML parser
    • htmllib --- A parser for HTML documents
      • HTMLParser Objects
    • htmlentitydefs --- Definitions of HTML general entities
    • xml.parsers.expat --- Fast XML parsing using Expat
      • XMLParser Objects
      • ExpatError Exceptions
      • Example
      • Content Model Descriptions
      • Expat error constants
    • xml.dom --- The Document Object Model API
      • Module Contents
      • Objects in the DOM
        • DOMImplementation Objects
        • Node Objects
        • NodeList Objects
        • DocumentType Objects
        • Document Objects
        • Element Objects
        • Attr Objects
        • NamedNodeMap Objects
        • Comment Objects
        • Text and CDATASection Objects
        • ProcessingInstruction Objects
        • Exceptions
      • Conformance
        • Type Mapping
        • Accessor Methods
    • xml.dom.minidom --- Lightweight DOM implementation
      • DOM Objects
      • DOM Example
      • minidom and the DOM standard
    • xml.dom.pulldom --- Support for building partial DOM trees
      • DOMEventStream Objects
    • xml.sax --- Support for SAX2 parsers
      • SAXException Objects
    • xml.sax.handler --- Base classes for SAX handlers
      • ContentHandler Objects
      • DTDHandler Objects
      • EntityResolver Objects
      • ErrorHandler Objects
    • xml.sax.saxutils --- SAX Utilities
    • xml.sax.xmlreader --- Interface for XML parsers
      • XMLReader Objects
      • IncrementalParser Objects
      • Locator Objects
      • InputSource Objects
      • The Attributes Interface
      • The AttributesNS Interface
    • xml.etree.ElementTree --- The ElementTree XML API
      • Functions
      • Element Objects
      • ElementTree Objects
      • QName Objects
      • TreeBuilder Objects
      • XMLParser 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
      • FTP_TLS 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
  • 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
  • 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
      • Command Line Interface
        • failfast, catch and buffer command line options
      • Test Discovery
      • Organizing test code
      • Re-using old test code
      • Skipping tests and expected failures
      • Classes and functions
        • Test cases
        • Grouping tests
        • Loading and running tests
          • load_tests Protocol
      • Class and Module Fixtures
        • setUpClass and tearDownClass
        • setUpModule and tearDownModule
      • Signal Handling
    • 2to3 - Automated Python 2 to 3 code translation
      • Using 2to3
      • Fixers
      • lib2to3 - 2to3's library
    • test --- Regression tests package for Python
      • Writing Unit Tests for the test package
      • Running tests using test.regrtest
    • test.test_support --- Utility functions for tests
  • Debugging and Profiling
    • bdb --- Debugger framework
    • pdb --- The Python Debugger
    • Debugger Commands
    • The Python Profilers
      • Introduction to the profilers
      • Instant User's Manual
      • What Is Deterministic Profiling?
      • Reference Manual -- profile and cProfile
        • The Stats Class
      • Limitations
      • Calibration
      • Extensions --- Deriving Better Profilers
    • hotshot --- High performance logging profiler
      • Profile Objects
      • Using hotshot data
      • Example Usage
    • timeit --- Measure execution time of small code snippets
      • Command Line Interface
      • Examples
    • trace --- Trace or track Python statement execution
      • Command Line Usage
      • Programming Interface
  • Python Runtime Services
    • sys --- System-specific parameters and functions
    • sysconfig --- Provide access to Python's configuration information
      • Configuration variables
      • Installation paths
      • Other 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
      • Updating Code For New Versions of Python
      • 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
    • distutils --- Building and installing Python modules
  • Custom Python Interpreters
    • code --- Interpreter base classes
      • Interactive Interpreter Objects
      • Interactive Console Objects
    • codeop --- Compile Python code
  • Restricted Execution
    • rexec --- Restricted execution framework
      • RExec Objects
      • Defining restricted environments
      • An example
    • Bastion --- Restricting access to objects
  • Importing Modules
    • imp --- Access the import internals
      • Examples
    • importlib -- Convenience wrappers for __import__()
    • imputil --- Import utilities
      • Examples
    • zipimport --- Import modules from Zip archives
      • zipimporter Objects
      • Examples
    • pkgutil --- Package extension utility
    • modulefinder --- Find modules used by a script
      • Example usage of ModuleFinder
    • runpy --- Locating and executing Python modules
  • Python Language Services
    • parser --- Access Python parse trees
      • Creating ST Objects
      • Converting ST Objects
      • Queries on ST Objects
      • Exceptions and Error Handling
      • ST Objects
      • Examples
        • Emulation of compile()
        • Information Discovery
    • Abstract Syntax Trees
      • Node classes
      • Abstract Grammar
      • ast Helpers
    • symtable --- Access to the compiler's symbol tables
      • Generating Symbol Tables
      • Examining Symbol Tables
    • symbol --- Constants used with Python parse trees
    • token --- Constants used with Python parse trees
    • keyword --- Testing for Python keywords
    • tokenize --- Tokenizer for Python source
    • tabnanny --- Detection of ambiguous indentation
    • pyclbr --- Python class browser support
      • Class Objects
      • Function Objects
    • py_compile --- Compile Python source files
    • compileall --- Byte-compile Python libraries
    • dis --- Disassembler for Python bytecode
      • Python Bytecode Instructions
    • pickletools --- Tools for pickle developers
  • Python compiler package
    • The basic interface
    • Limitations
    • Python Abstract Syntax
      • AST Nodes
      • Assignment nodes
      • Examples
    • Using Visitors to Walk ASTs
    • Bytecode Generation
  • Miscellaneous Services
    • formatter --- Generic output formatting
      • The Formatter Interface
      • Formatter Implementations
      • The Writer Interface
      • Writer Implementations
  • MS Windows Specific Services
    • _winreg -- Windows registry access
      • Constants
        • HKEY_* Constants
        • Access Rights
          • 64-bit Specific
        • Value Types
      • Registry Handle Objects
  • Undocumented Modules
    • Miscellaneous useful utilities
    • Platform specific modules
    • Multimedia
    • Obsolete
    • SGI-specific Extension modules
• IronPython Hosting
  • Getting Started
    • Introduction
    • Samples
      • Hello World
      • Calling Python from C#
      • Exposing Application Object Model
    • Reference
  • DLR Hosting APIs
    • DLR Hosting Overview
      • High-level Hosting Model Concepts
      • Level One -- Script Runtimes, Scopes, and Executing Files and Snippets
        • Code Sample -- Application Programmability
      • Level Two -- Engines, Compiled Code, Sources, and Object Operations
        • Code Sample -- REPL and Merlin Web
      • Level Three -- Full Control, Remoting, Tool Support, and More
    • ScriptRuntime
      • ScriptRuntime Members
    • ScriptScope
      • ScriptScope Members
    • ScriptEngine
      • ScriptEngine Members
    • ScriptSource
      • ScriptSource Members
    • ObjectOperations
      • ObjectOperations Members
    • SourceCodeKind
      • Members
    • ScriptCodeParseResult
      • Members
    • CompiledCode
      • CompiledCode Members
    • ScriptRuntimeSetup
      • ScriptRuntimeSetup Members
      • Configuration Structure
      • Default DLR Configuration
    • LanguageSetup
      • LanguageSetup Members
    • ExceptionOperations
      • ExceptionOperations Members
    • ScriptIO
      • ScriptIO Members
    • ScriptHost
      • ScriptHost Members
    • PlatformAdaptionLayer
      • PlatformAdaptionLayer Members
  • .NET Interop
• 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
    • The MANIFEST.in template
      • Principle
      • Commands
  • 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
    • PyPI package display
  • 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
  • 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.archive_util --- Archiving utilities
    • distutils.dep_util --- Dependency checking
    • distutils.dir_util --- Directory tree operations
    • distutils.file_util --- Single file operations
    • distutils.util --- Miscellaneous other utility functions
    • distutils.dist --- The Distribution class
    • distutils.extension --- The Extension class
    • distutils.debug --- Distutils debug mode
    • distutils.errors --- Distutils exceptions
    • distutils.fancy_getopt --- Wrapper around the standard getopt module
    • distutils.filelist --- The FileList class
    • distutils.log --- Simple PEP 282-style logging
    • distutils.spawn --- Spawn a sub-process
    • distutils.sysconfig --- System configuration information
    • distutils.text_file --- The TextFile class
    • distutils.version --- Version number classes
    • distutils.cmd --- Abstract base class for Distutils commands
    • distutils.command --- Individual Distutils commands
    • distutils.command.bdist --- Build a binary installer
    • distutils.command.bdist_packager --- Abstract base class for packagers
    • distutils.command.bdist_dumb --- Build a "dumb" installer
    • distutils.command.bdist_msi --- Build a Microsoft Installer binary package
    • distutils.command.bdist_rpm --- Build a binary distribution as a Redhat RPM and SRPM
    • distutils.command.bdist_wininst --- Build a Windows installer
    • distutils.command.sdist --- Build a source distribution
    • distutils.command.build --- Build all files of a package
    • distutils.command.build_clib --- Build any C libraries in a package
    • distutils.command.build_ext --- Build any extensions in a package
    • distutils.command.build_py --- Build the .py/.pyc files of a package
    • distutils.command.build_scripts --- Build the scripts of a package
    • distutils.command.clean --- Clean a package build area
    • distutils.command.config --- Perform package configuration
    • distutils.command.install --- Install a package
    • distutils.command.install_data --- Install data files from a package
    • distutils.command.install_headers --- Install C/C++ header files from a package
    • distutils.command.install_lib --- Install library files from a package
    • distutils.command.install_scripts --- Install script files from a package
    • distutils.command.register --- Register a module with the Python Package Index
    • Creating a new Distutils command
• Installing Python Modules
  • Introduction
    • Best case: trivial installation
    • The new standard: Distutils
  • Standard Build and Install
    • Platform variations
    • Splitting the job up
    • How building works
    • How installation works
  • Alternate Installation
    • Alternate installation: the home scheme
    • Alternate installation: Unix (the prefix scheme)
    • Alternate installation: Windows (the prefix scheme)
  • Custom Installation
    • Modifying Python's Search Path
  • Distutils Configuration Files
    • Location and names of config files
    • Syntax of config files
  • Building Extensions: Tips and Tricks
    • Tweaking compiler/linker flags
    • Using non-Microsoft compilers on Windows
      • Borland/CodeGear C++
      • GNU C / Cygwin / MinGW
• Documenting Python
  • Introduction
  • Style Guide
  • reStructuredText Primer
    • Paragraphs
    • Inline markup
    • Lists and Quotes
    • Source Code
    • Hyperlinks
      • External links
      • Internal links
    • Sections
    • Explicit Markup
    • Directives
    • Footnotes
    • Comments
    • Source encoding
    • Gotchas
  • Additional Markup Constructs
    • Meta-information markup
    • Module-specific markup
    • Information units
    • Showing code examples
    • Inline markup
    • Cross-linking markup
    • Paragraph-level markup
    • Table-of-contents markup
    • Index-generating markup
    • Grammar production displays
    • Substitutions
  • Differences to the LaTeX markup
    • Inline markup
    • Information units
    • Structure
  • Building the documentation
    • Using make
    • Without make
• Python HOWTOs
  • Python Advocacy HOWTO
    • Reasons to Use Python
      • Programmability
      • Prototyping
      • Simplicity and Ease of Understanding
      • Java Integration
    • Arguments and Rebuttals
    • Useful Resources
  • Porting Extension Modules to 3.0
    • Conditional compilation
    • Changes to Object APIs
      • str/unicode Unification
      • long/int Unification
    • Module initialization and state
    • Other options
  • Curses Programming with Python
    • What is curses?
      • The Python curses module
    • Starting and ending a curses application
    • Windows and Pads
    • Displaying Text
      • Attributes and Color
    • User Input
    • For More Information
  • Descriptor HowTo Guide
    • Abstract
    • Definition and Introduction
    • Descriptor Protocol
    • Invoking Descriptors
    • Descriptor Example
    • Properties
    • Functions and Methods
    • Static Methods and Class Methods
  • Idioms and Anti-Idioms in Python
    • Language Constructs You Should Not Use
      • from module import *
        • Inside Function Definitions
        • At Module Level
        • When It Is Just Fine
      • Unadorned exec, execfile() and friends
      • from module import name1, name2
      • except:
    • Exceptions
    • Using the Batteries
    • Using Backslash to Continue Statements
  • Functional Programming HOWTO
    • Introduction
      • Formal provability
      • Modularity
      • Ease of debugging and testing
      • Composability
    • Iterators
      • Data Types That Support Iterators
    • Generator expressions and list comprehensions
    • Generators
      • Passing values into a generator
    • Built-in functions
    • Small functions and the lambda expression
    • The itertools module
      • Creating new iterators
      • Calling functions on elements
      • Selecting elements
      • Grouping elements
    • The functools module
      • The operator module
      • The functional module
    • Revision History and Acknowledgements
    • References
      • General
      • Python-specific
      • Python documentation
  • Regular Expression HOWTO
    • Introduction
    • Simple Patterns
      • Matching Characters
      • Repeating Things
    • Using Regular Expressions
      • Compiling Regular Expressions
      • The Backslash Plague
      • Performing Matches
      • Module-Level Functions
      • Compilation Flags
    • More Pattern Power
      • More Metacharacters
      • Grouping
      • Non-capturing and Named Groups
      • Lookahead Assertions
    • Modifying Strings
      • Splitting Strings
      • Search and Replace
    • Common Problems
      • Use String Methods
      • match() versus search()
      • Greedy versus Non-Greedy
      • Not Using re.VERBOSE
    • Feedback
  • Socket Programming HOWTO
    • Sockets
      • History
    • Creating a Socket
      • IPC
    • Using a Socket
      • Binary Data
    • Disconnecting
      • When Sockets Die
    • Non-blocking Sockets
      • Performance
  • Sorting HOW TO
    • Sorting Basics
    • Key Functions
    • Operator Module Functions
    • Ascending and Descending
    • Sort Stability and Complex Sorts
    • The Old Way Using Decorate-Sort-Undecorate
    • The Old Way Using the cmp Parameter
    • Odd and Ends
  • Unicode HOWTO
    • Introduction to Unicode
      • History of Character Codes
      • Definitions
      • Encodings
      • References
    • Python 2.x's Unicode Support
      • The Unicode Type
      • Unicode Literals in Python Source Code
      • Unicode Properties
      • References
    • Reading and Writing Unicode Data
      • Unicode filenames
      • Tips for Writing Unicode-aware Programs
      • References
    • Revision History and Acknowledgements
  • HOWTO Fetch Internet Resources Using urllib2
    • Introduction
    • Fetching URLs
      • Data
      • Headers
    • Handling Exceptions
      • URLError
      • HTTPError
        • Error Codes
      • Wrapping it Up
        • Number 1
        • Number 2
    • info and geturl
    • Openers and Handlers
    • Basic Authentication
    • Proxies
    • Sockets and Layers
    • Footnotes
  • HOWTO Use Python in the web
    • The Low-Level View
      • Common Gateway Interface
        • Simple script for testing CGI
        • Setting up CGI on your own server
        • Common problems with CGI scripts
      • mod_python
      • FastCGI and SCGI
        • Setting up FastCGI
      • mod_wsgi
    • Step back: WSGI
      • WSGI Servers
      • Case study: MoinMoin
    • Model-View-Controller
    • Ingredients for Websites
      • Templates
      • Data persistence
    • Frameworks
      • Some notable frameworks
        • Django
        • TurboGears
        • Zope
        • Other notable frameworks
• IronPython .NET API Reference Manual
  • Extending IronPython with C#
    • A Simple Example
  • Parsing and Tokenizing
• Python Frequently Asked Questions
  • General Python FAQ
    • General Information
    • Python in the real world
    • Upgrading Python
  • Programming FAQ
    • General Questions
    • Core Language
    • Numbers and strings
    • Sequences (Tuples/Lists)
    • Dictionaries
    • Objects
    • Modules
  • Design and History FAQ
    • Why does Python use indentation for grouping of statements?
    • Why am I getting strange results with simple arithmetic operations?
    • Why are floating point calculations so inaccurate?
    • Why are Python strings immutable?
    • Why must 'self' be used explicitly in method definitions and calls?
    • Why can't I use an assignment in an expression?
    • Why does Python use methods for some functionality (e.g. list.index()) but functions for other (e.g. len(list))?
    • Why is join() a string method instead of a list or tuple method?
    • How fast are exceptions?
    • Why isn't there a switch or case statement in Python?
    • Can't you emulate threads in the interpreter instead of relying on an OS-specific thread implementation?
    • Why can't lambda forms contain statements?
    • Can Python be compiled to machine code, C or some other language?
    • How does Python manage memory?
    • Why isn't all memory freed when Python exits?
    • Why are there separate tuple and list data types?
    • How are lists implemented?
    • How are dictionaries implemented?
    • Why must dictionary keys be immutable?
    • Why doesn't list.sort() return the sorted list?
    • How do you specify and enforce an interface spec in Python?
    • Why are default values shared between objects?
    • Why is there no goto?
    • Why can't raw strings (r-strings) end with a backslash?
    • Why doesn't Python have a "with" statement for attribute assignments?
    • Why are colons required for the if/while/def/class statements?
    • Why does Python allow commas at the end of lists and tuples?
  • Library and Extension FAQ
    • General Library Questions
    • Common tasks
    • Threads
    • Input and Output
    • Network/Internet Programming
    • Databases
    • Mathematics and Numerics
  • Extending/Embedding FAQ
    • Can I create my own functions in C?
    • Can I create my own functions in C++?
    • Writing C is hard; are there any alternatives?
    • How can I execute arbitrary Python statements from C?
    • How can I evaluate an arbitrary Python expression from C?
    • How do I extract C values from a Python object?
    • How do I use Py_BuildValue() to create a tuple of arbitrary length?
    • How do I call an object's method from C?
    • How do I catch the output from PyErr_Print() (or anything that prints to stdout/stderr)?
    • How do I access a module written in Python from C?
    • How do I interface to C++ objects from Python?
    • I added a module using the Setup file and the make fails; why?
    • How do I debug an extension?
    • I want to compile a Python module on my Linux system, but some files are missing. Why?
    • What does "SystemError: _PyImport_FixupExtension: module yourmodule not loaded" mean?
    • How do I tell "incomplete input" from "invalid input"?
    • How do I find undefined g++ symbols __builtin_new or __pure_virtual?
    • Can I create an object class with some methods implemented in C and others in Python (e.g. through inheritance)?
    • When importing module X, why do I get "undefined symbol: PyUnicodeUCS2*"?
  • Python on Windows FAQ
    • How do I run a Python program under Windows?
    • How do I make Python scripts executable?
    • Why does Python sometimes take so long to start?
    • Where is Freeze for Windows?
    • Is a *.pyd file the same as a DLL?
    • How can I embed Python into a Windows application?
    • How do I use Python for CGI?
    • How do I keep editors from inserting tabs into my Python source?
    • How do I check for a keypress without blocking?
    • How do I emulate os.kill() in Windows?
    • Why does os.path.isdir() fail on NT shared directories?
    • cgi.py (or other CGI programming) doesn't work sometimes on NT or win95!
    • Why doesn't os.popen() work in PythonWin on NT?
    • Why doesn't os.popen()/win32pipe.popen() work on Win9x?
    • PyRun_SimpleFile() crashes on Windows but not on Unix; why?
    • Importing _tkinter fails on Windows 95/98: why?
    • How do I extract the downloaded documentation on Windows?
    • Missing cw3215mt.dll (or missing cw3215.dll)
    • Warning about CTL3D32 version from installer
  • Graphic User Interface FAQ
    • What platform-independent GUI toolkits exist for Python?
    • What platform-specific GUI toolkits exist for Python?
    • Tkinter questions
  • "Why is Python Installed on my Computer?" FAQ
    • What is Python?
    • Why is Python installed on my machine?
    • Can I delete Python?
• Glossary
• About these documents
  • Contributors to the Python Documentation
• Reporting Bugs
  • Documentation bugs
  • Using the Python issue tracker
• Copyright
• History and License
  • History of the IronPython
  • History of Python
  • IronPython License
  • 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
    • strtod and dtoa

next page

Get in touch

Submit feedback about this site to:

• [email protected]