documentation.HELP! Python 2.6 Documentation

Index

Python 2.6

previous page next page

Navigation

  • index
  • modules |
  • Python v2.6 documentation »

Index – Symbols

!=
operator
% formatting
% interpolation
%PATH%
%PYTHONPATH%
*
statement, [1]
**
statement, [1]
--help
command line option
--version
command line option
-3
command line option
-B
command line option
-c <command>
command line option
-d
command line option
-E
command line option
-h
command line option
-i
command line option
-m <module-name>
command line option
-O
command line option
-OO
command line option
-Q <arg>
command line option
-S
command line option
-s
command line option
-t
command line option
-u
command line option
-V
command line option
-v
command line option
-W arg
command line option
-x
command line option
...
.ini
file
.pdbrc
file
.pythonrc.py
file
2to3
<
operator
<=
operator
<protocol>_proxy
==
operator
>
operator
>=
operator
>>>
@
statement

Navigation

  • index
  • modules |
  • Python v2.6 documentation »
© Copyright 1990-2008, Python Software Foundation. Last updated on Oct 02, 2008. Created using Sphinx 0.5.
previous page start next page

Menu

  • Homepage

Table of contents

  • Python v2.6 documentation
  • Global Module Index
  • 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
  • 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
        • Unknown
      • 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 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
    • 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
      • cmath --- Mathematical functions for complex numbers
        • Complex coordinates
        • cmath functions
      • 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
      • 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
        • 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 pysqlite 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
          • Standard option actions
          • Option attributes
          • 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
        • Lock Objects
        • RLock Objects
        • Condition Objects
        • Semaphore Objects
          • Semaphore Example
        • Event Objects
        • Thread 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
        • 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 pipe line
          • Replacing os.system()
          • Replacing os.spawn*
          • Replacing os.popen*
          • Replacing popen2.*
      • 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
      • 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
          • 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
      • How It Works
      • 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.CF --- Core Foundation
        • Carbon.CG --- Core Graphics
        • Carbon.CarbonEvt --- Carbon Event Manager
        • Carbon.Cm --- Component Manager
        • Carbon.Ctl --- Control Manager
        • Carbon.Dlg --- Dialog Manager
        • Carbon.Evt --- Event Manager
        • Carbon.Fm --- Font Manager
        • Carbon.Folder --- Folder Manager
        • Carbon.Help --- Help Manager
        • Carbon.List --- List Manager
        • Carbon.Menu --- Menu Manager
        • Carbon.Mlte --- MultiLingual Text Editor
        • Carbon.Qd --- QuickDraw
        • Carbon.Qdoffs --- QuickDraw Offscreen
        • Carbon.Qt --- QuickTime
        • Carbon.Res --- Resource Manager and Handles
        • Carbon.Scrap --- Scrap Manager
        • Carbon.Snd --- Sound Manager
        • Carbon.TE --- TextEdit
        • Carbon.Win --- Window Manager
      • 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
      • 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
        • String/Bytes Objects
        • Unicode Objects and Codecs
          • Unicode Objects
          • Built-in Codecs
          • Methods and Slot Functions
        • 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
      • 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
      • File-wide metadata
      • 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
    • The Sphinx build system
      • The build configuration file
        • Builder-specific variables
  • 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

Get in touch

Submit feedback about this site to:

  • [email protected]

© documentation.help. Design: rehmann.co.