documentation.HELP! Python 2.7 Documentation

21. Multimedia Services

Python 2.7

previous page next page

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python v2.7 documentation »
  • The Python Standard Library »

21. Multimedia Services

The modules described in this chapter implement various algorithms or interfaces that are mainly useful for multimedia applications. They are available at the discretion of the installation. Here’s an overview:

  • 21.1. audioop — Manipulate raw audio data
  • 21.2. imageop — Manipulate raw image data
  • 21.3. aifc — Read and write AIFF and AIFC files
  • 21.4. sunau — Read and write Sun AU files
    • 21.4.1. AU_read Objects
    • 21.4.2. AU_write Objects
  • 21.5. wave — Read and write WAV files
    • 21.5.1. Wave_read Objects
    • 21.5.2. Wave_write Objects
  • 21.6. chunk — Read IFF chunked data
  • 21.7. colorsys — Conversions between color systems
  • 21.8. imghdr — Determine the type of an image
  • 21.9. sndhdr — Determine type of sound file
  • 21.10. ossaudiodev — Access to OSS-compatible audio devices
    • 21.10.1. Audio Device Objects
    • 21.10.2. Mixer Device Objects

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python v2.7 documentation »
  • The Python Standard Library »
© Copyright 1990-2010, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Jul 04, 2010. Found a bug?
Created using Sphinx 0.6.3.
previous page start next page

Menu

  • Homepage

Table of contents

  • Python v2.7 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
      • Changes to the Development Process
        • New Issue Tracker: Roundup
        • New Documentation Format: reStructuredText Using Sphinx
      • PEP 343: The 'with' statement
        • Writing Context Managers
        • The contextlib module
      • PEP 366: Explicit Relative Imports From a Main Module
      • PEP 370: Per-user site-packages Directory
      • PEP 371: The multiprocessing Package
      • PEP 3101: Advanced String Formatting
      • PEP 3105: print As a Function
      • PEP 3110: Exception-Handling Changes
      • PEP 3112: Byte Literals
      • PEP 3116: New I/O Library
      • PEP 3118: Revised Buffer Protocol
      • PEP 3119: Abstract Base Classes
      • PEP 3127: Integer Literal Support and Syntax
      • PEP 3129: Class Decorators
      • PEP 3141: A Type Hierarchy for Numbers
        • The fractions Module
      • Other Language Changes
        • Optimizations
        • Interpreter Changes
      • New and Improved Modules
        • The ast module
        • The future_builtins module
        • The json module: JavaScript Object Notation
        • The plistlib module: A Property-List Parser
        • ctypes Enhancements
        • Improved SSL Support
      • Deprecations and Removals
      • Build and C API Changes
        • Port-Specific Changes: Windows
        • Port-Specific Changes: Mac OS X
        • Port-Specific Changes: IRIX
      • Porting to Python 2.6
      • Acknowledgements
    • What's New in Python 2.5
      • PEP 308: Conditional Expressions
      • PEP 309: Partial Function Application
      • PEP 314: Metadata for Python Software Packages v1.1
      • PEP 328: Absolute and Relative Imports
      • PEP 338: Executing Modules as Scripts
      • PEP 341: Unified try/except/finally
      • PEP 342: New Generator Features
      • PEP 343: The 'with' statement
        • Writing Context Managers
        • The contextlib module
      • PEP 352: Exceptions as New-Style Classes
      • PEP 353: Using ssize_t as the index type
      • PEP 357: The '__index__' method
      • Other Language Changes
        • Interactive Interpreter Changes
        • Optimizations
      • New, Improved, and Removed Modules
        • The ctypes package
        • The ElementTree package
        • The hashlib package
        • The sqlite3 package
        • The wsgiref package
      • Build and C API Changes
        • Port-Specific Changes
      • Porting to Python 2.5
      • Acknowledgements
    • What's New in Python 2.4
      • PEP 218: Built-In Set Objects
      • PEP 237: Unifying Long Integers and Integers
      • PEP 289: Generator Expressions
      • PEP 292: Simpler String Substitutions
      • PEP 318: Decorators for Functions and Methods
      • PEP 322: Reverse Iteration
      • PEP 324: New subprocess Module
      • PEP 327: Decimal Data Type
        • Why is Decimal needed?
        • The Decimal type
        • The Context type
      • PEP 328: Multi-line Imports
      • PEP 331: Locale-Independent Float/String Conversions
      • Other Language Changes
        • Optimizations
      • New, Improved, and Deprecated Modules
        • cookielib
        • doctest
      • Build and C API Changes
        • Port-Specific Changes
      • Porting to Python 2.4
      • Acknowledgements
    • What's New in Python 2.3
      • PEP 218: A Standard Set Datatype
      • PEP 255: Simple Generators
      • PEP 263: Source Code Encodings
      • PEP 273: Importing Modules from ZIP Archives
      • PEP 277: Unicode file name support for Windows NT
      • PEP 278: Universal Newline Support
      • PEP 279: enumerate()
      • PEP 282: The logging Package
      • PEP 285: A Boolean Type
      • PEP 293: Codec Error Handling Callbacks
      • PEP 301: Package Index and Metadata for Distutils
      • PEP 302: New Import Hooks
      • PEP 305: Comma-separated Files
      • PEP 307: Pickle Enhancements
      • Extended Slices
      • Other Language Changes
        • String Changes
        • Optimizations
      • New, Improved, and Deprecated Modules
        • Date/Time Type
        • The optparse Module
      • Pymalloc: A Specialized Object Allocator
      • Build and C API Changes
        • Port-Specific Changes
      • Other Changes and Fixes
      • Porting to Python 2.3
      • Acknowledgements
    • What's New in Python 2.2
      • Introduction
      • PEPs 252 and 253: Type and Class Changes
        • Old and New Classes
        • Descriptors
        • Multiple Inheritance: The Diamond Rule
        • Attribute Access
        • Related Links
      • PEP 234: Iterators
      • PEP 255: Simple Generators
      • PEP 237: Unifying Long Integers and Integers
      • PEP 238: Changing the Division Operator
      • Unicode Changes
      • PEP 227: Nested Scopes
      • New and Improved Modules
      • Interpreter Changes and Fixes
      • Other Changes and Fixes
      • Acknowledgements
    • What's New in Python 2.1
      • Introduction
      • PEP 227: Nested Scopes
      • PEP 236: __future__ Directives
      • PEP 207: Rich Comparisons
      • PEP 230: Warning Framework
      • PEP 229: New Build System
      • PEP 205: Weak References
      • PEP 232: Function Attributes
      • PEP 235: Importing Modules on Case-Insensitive Platforms
      • PEP 217: Interactive Display Hook
      • PEP 208: New Coercion Model
      • PEP 241: Metadata in Python Packages
      • New and Improved Modules
      • Other Changes and Fixes
      • Acknowledgements
    • What's New in Python 2.0
      • Introduction
      • What About Python 1.6?
      • New Development Process
      • Unicode
      • List Comprehensions
      • Augmented Assignment
      • String Methods
      • Garbage Collection of Cycles
      • Other Core Changes
        • Minor Language Changes
        • Changes to Built-in Functions
      • Porting to 2.0
      • Extending/Embedding Changes
      • Distutils: Making Modules Easy to Install
      • XML Modules
        • SAX2 Support
        • DOM Support
        • Relationship to PyXML
      • Module changes
      • New modules
      • IDLE Improvements
      • Deleted and Deprecated Modules
      • Acknowledgements
  • The Python Tutorial
    • Whetting Your Appetite
    • Using the Python Interpreter
      • Invoking the Interpreter
        • Argument Passing
        • Interactive Mode
      • The Interpreter and Its Environment
        • Error Handling
        • Executable Python Scripts
        • Source Code Encoding
        • The Interactive Startup File
    • An Informal Introduction to Python
      • Using Python as a Calculator
        • Numbers
        • Strings
        • Unicode Strings
        • Lists
      • First Steps Towards Programming
    • More Control Flow Tools
      • if Statements
      • for Statements
      • The range() Function
      • break and continue Statements, and else Clauses on Loops
      • pass Statements
      • Defining Functions
      • More on Defining Functions
        • Default Argument Values
        • Keyword Arguments
        • Arbitrary Argument Lists
        • Unpacking Argument Lists
        • Lambda Forms
        • Documentation Strings
      • Intermezzo: Coding Style
    • Data Structures
      • More on Lists
        • Using Lists as Stacks
        • Using Lists as Queues
        • Functional Programming Tools
        • List Comprehensions
        • Nested List Comprehensions
      • The del statement
      • Tuples and Sequences
      • Sets
      • Dictionaries
      • Looping Techniques
      • More on Conditions
      • Comparing Sequences and Other Types
    • Modules
      • More on Modules
        • Executing modules as scripts
        • The Module Search Path
        • "Compiled" Python files
      • Standard Modules
      • The dir() Function
      • Packages
        • Importing * From a Package
        • Intra-package References
        • Packages in Multiple Directories
    • Input and Output
      • Fancier Output Formatting
        • Old string formatting
      • Reading and Writing Files
        • Methods of File Objects
        • The pickle Module
    • Errors and Exceptions
      • Syntax Errors
      • Exceptions
      • Handling Exceptions
      • Raising Exceptions
      • User-defined Exceptions
      • Defining Clean-up Actions
      • Predefined Clean-up Actions
    • Classes
      • A Word About Names and Objects
      • Python Scopes and Namespaces
      • A First Look at Classes
        • Class Definition Syntax
        • Class Objects
        • Instance Objects
        • Method Objects
      • Random Remarks
      • Inheritance
        • Multiple Inheritance
      • Private Variables
      • Odds and Ends
      • Exceptions Are Classes Too
      • Iterators
      • Generators
      • Generator Expressions
    • Brief Tour of the Standard Library
      • Operating System Interface
      • File Wildcards
      • Command Line Arguments
      • Error Output Redirection and Program Termination
      • String Pattern Matching
      • Mathematics
      • Internet Access
      • Dates and Times
      • Data Compression
      • Performance Measurement
      • Quality Control
      • Batteries Included
    • Brief Tour of the Standard Library -- Part II
      • Output Formatting
      • Templating
      • Working with Binary Data Record Layouts
      • Multi-threading
      • Logging
      • Weak References
      • Tools for Working with Lists
      • Decimal Floating Point Arithmetic
    • What Now?
    • Interactive Input Editing and History Substitution
      • Line Editing
      • History Substitution
      • Key Bindings
      • Alternatives to the Interactive Interpreter
    • Floating Point Arithmetic: Issues and Limitations
      • Representation Error
  • Using Python
    • Command line and environment
      • Command line
        • Interface options
        • Generic options
        • Miscellaneous options
        • Options you shouldn't use
      • Environment variables
        • Debug-mode variables
    • Using Python on Unix platforms
      • Getting and installing the latest version of Python
        • On Linux
        • On FreeBSD and OpenBSD
        • On OpenSolaris
      • Building Python
      • Python-related paths and files
      • Miscellaneous
      • Editors
    • Using Python on Windows
      • Installing Python
      • Alternative bundles
      • Configuring Python
        • Excursus: Setting environment variables
        • Finding the Python executable
        • Finding modules
        • Executing scripts
      • Additional modules
        • PyWin32
        • Py2exe
        • WConio
      • Compiling Python on Windows
      • Other resources
    • Using Python on a Macintosh
      • Getting and Installing MacPython
        • How to run a Python script
        • Running scripts with a GUI
        • Configuration
      • The IDE
      • Installing Additional Python Packages
      • GUI Programming on the Mac
      • Distributing Python Applications on the Mac
      • Application Scripting
      • Other Resources
  • The Python Language Reference
    • Introduction
      • Alternate Implementations
      • Notation
    • Lexical analysis
      • Line structure
        • Logical lines
        • Physical lines
        • Comments
        • Encoding declarations
        • Explicit line joining
        • Implicit line joining
        • Blank lines
        • Indentation
        • Whitespace between tokens
      • Other tokens
      • Identifiers and keywords
        • Keywords
        • Reserved classes of identifiers
      • Literals
        • String literals
        • String literal concatenation
        • Numeric literals
        • Integer and long integer literals
        • Floating point literals
        • Imaginary literals
      • Operators
      • Delimiters
    • Data model
      • Objects, values and types
      • The standard type hierarchy
      • New-style and classic classes
      • Special method names
        • Basic customization
        • Customizing attribute access
          • More attribute access for new-style classes
          • Implementing Descriptors
          • Invoking Descriptors
          • __slots__
        • Customizing class creation
        • Customizing instance and subclass checks
        • Emulating callable objects
        • Emulating container types
        • Additional methods for emulation of sequence types
        • Emulating numeric types
        • Coercion rules
        • With Statement Context Managers
        • Special method lookup for old-style classes
        • Special method lookup for new-style classes
    • Execution model
      • Naming and binding
        • Interaction with dynamic features
      • Exceptions
    • Expressions
      • Arithmetic conversions
      • Atoms
        • Identifiers (Names)
        • Literals
        • Parenthesized forms
        • List displays
        • 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
      • macpath --- Mac OS 9 path manipulation functions
    • Data Persistence
      • pickle --- Python object serialization
        • Relationship to other Python modules
        • Data stream format
        • Usage
        • What can be pickled and unpickled?
        • The pickle protocol
          • Pickling and unpickling normal class instances
          • Pickling and unpickling extension types
          • Pickling and unpickling external objects
        • Subclassing Unpicklers
        • Example
      • cPickle --- A faster pickle
      • copy_reg --- Register pickle support functions
      • shelve --- Python object persistence
        • Restrictions
        • Example
      • marshal --- Internal Python object serialization
      • anydbm --- Generic access to DBM-style databases
      • whichdb --- Guess which DBM module created a database
      • dbm --- Simple "database" interface
      • gdbm --- GNU's reinterpretation of dbm
      • dbhash --- DBM-style interface to the BSD database library
        • Database Objects
      • bsddb --- Interface to Berkeley DB library
        • Hash, BTree and Record Objects
      • dumbdbm --- Portable DBM implementation
        • Dumbdbm Objects
      • sqlite3 --- DB-API 2.0 interface for SQLite databases
        • Module functions and constants
        • Connection Objects
        • Cursor Objects
        • Row Objects
        • SQLite and Python types
          • Introduction
          • Using adapters to store additional Python types in SQLite databases
            • Letting your object adapt itself
            • Registering an adapter callable
          • Converting SQLite values to custom Python types
          • Default adapters and converters
        • Controlling Transactions
        • Using sqlite3 efficiently
          • Using shortcut methods
          • Accessing columns by name instead of by index
          • Using the connection as a context manager
    • Data Compression and Archiving
      • zlib --- Compression compatible with gzip
      • gzip --- Support for gzip files
        • Examples of usage
      • bz2 --- Compression compatible with bzip2
        • (De)compression of files
        • Sequential (de)compression
        • One-shot (de)compression
      • zipfile --- Work with ZIP archives
        • ZipFile Objects
        • PyZipFile Objects
        • ZipInfo Objects
      • tarfile --- Read and write tar archive files
        • TarFile Objects
        • TarInfo Objects
        • Examples
        • Supported tar formats
        • Unicode issues
    • File Formats
      • csv --- CSV File Reading and Writing
        • Module Contents
        • Dialects and Formatting Parameters
        • Reader Objects
        • Writer Objects
        • Examples
      • ConfigParser --- Configuration file parser
        • RawConfigParser Objects
        • ConfigParser Objects
        • SafeConfigParser Objects
        • Examples
      • robotparser --- Parser for robots.txt
      • netrc --- netrc file processing
        • netrc Objects
      • xdrlib --- Encode and decode XDR data
        • Packer Objects
        • Unpacker Objects
        • Exceptions
      • plistlib --- Generate and parse Mac OS X .plist files
        • Examples
    • Cryptographic Services
      • hashlib --- Secure hashes and message digests
      • hmac --- Keyed-Hashing for Message Authentication
      • md5 --- MD5 message digest algorithm
      • sha --- SHA-1 message digest algorithm
    • Generic Operating System Services
      • os --- Miscellaneous operating system interfaces
        • Process Parameters
        • File Object Creation
        • File Descriptor Operations
          • open() flag constants
        • Files and Directories
        • Process Management
        • Miscellaneous System Information
        • Miscellaneous Functions
      • io --- Core tools for working with streams
        • Module Interface
        • I/O Base Classes
        • Raw File I/O
        • Buffered Streams
        • Text I/O
      • time --- Time access and conversions
      • 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
      • mmap --- Memory-mapped file support
      • readline --- GNU readline interface
        • Example
      • rlcompleter --- Completion function for GNU readline
        • Completer Objects
    • Interprocess Communication and Networking
      • subprocess --- Subprocess management
        • Using the subprocess Module
          • Convenience Functions
          • Exceptions
          • Security
        • Popen Objects
        • Replacing Older Functions with the subprocess Module
          • Replacing /bin/sh shell backquote
          • Replacing shell pipeline
          • Replacing os.system()
          • Replacing the os.spawn family
          • Replacing os.popen(), os.popen2(), os.popen3()
          • Replacing functions from the popen2 module
      • socket --- Low-level networking interface
        • Socket Objects
        • Example
      • ssl --- SSL wrapper for socket objects
        • Functions, Constants, and Exceptions
        • SSLSocket Objects
        • Certificates
        • Examples
          • Testing for SSL support
          • Client-side operation
          • Server-side operation
      • signal --- Set handlers for asynchronous events
        • Example
      • popen2 --- Subprocesses with accessible I/O streams
        • Popen3 and Popen4 Objects
        • Flow Control Issues
      • asyncore --- Asynchronous socket handler
        • asyncore Example basic HTTP client
      • asynchat --- Asynchronous socket command/response handler
        • asynchat - Auxiliary Classes
        • asynchat Example
    • Internet Data Handling
      • email --- An email and MIME handling package
        • email: Representing an email message
        • email: Parsing email messages
          • FeedParser API
          • Parser class API
          • Additional notes
        • email: Generating MIME documents
        • email: Creating email and MIME objects from scratch
        • email: Internationalized headers
        • email: Representing character sets
        • email: Encoders
        • email: Exception and Defect classes
        • email: Miscellaneous utilities
        • email: Iterators
        • email: Examples
        • Package History
        • Differences from mimelib
      • json --- JSON encoder and decoder
        • Basic Usage
        • Encoders and decoders
      • mailcap --- Mailcap file handling
      • mailbox --- Manipulate mailboxes in various formats
        • Mailbox objects
          • Maildir
          • mbox
          • MH
          • Babyl
          • MMDF
        • Message objects
          • MaildirMessage
          • mboxMessage
          • MHMessage
          • BabylMessage
          • MMDFMessage
        • Exceptions
        • Deprecated classes and methods
        • Examples
      • mhlib --- Access to MH mailboxes
        • MH Objects
        • Folder Objects
        • Message Objects
      • mimetools --- Tools for parsing MIME messages
        • Additional Methods of Message Objects
      • mimetypes --- Map filenames to MIME types
        • MimeTypes Objects
      • MimeWriter --- Generic MIME file writer
        • MimeWriter Objects
      • mimify --- MIME processing of mail messages
      • multifile --- Support for files containing distinct parts
        • MultiFile Objects
        • MultiFile Example
      • rfc822 --- Parse RFC 2822 mail headers
        • Message Objects
        • AddressList Objects
      • base64 --- RFC 3548: Base16, Base32, Base64 Data Encodings
      • binhex --- Encode and decode binhex4 files
        • Notes
      • binascii --- Convert between binary and ASCII
      • quopri --- Encode and decode MIME quoted-printable data
      • uu --- Encode and decode uuencode files
    • Structured Markup Processing Tools
      • HTMLParser --- Simple HTML and XHTML parser
        • Example HTML Parser Application
      • sgmllib --- Simple SGML parser
      • htmllib --- A parser for HTML documents
        • HTMLParser Objects
      • htmlentitydefs --- Definitions of HTML general entities
      • xml.parsers.expat --- Fast XML parsing using Expat
        • XMLParser Objects
        • ExpatError Exceptions
        • Example
        • Content Model Descriptions
        • Expat error constants
      • xml.dom --- The Document Object Model API
        • Module Contents
        • Objects in the DOM
          • DOMImplementation Objects
          • Node Objects
          • NodeList Objects
          • DocumentType Objects
          • Document Objects
          • Element Objects
          • Attr Objects
          • NamedNodeMap Objects
          • Comment Objects
          • Text and CDATASection Objects
          • ProcessingInstruction Objects
          • Exceptions
        • Conformance
          • Type Mapping
          • Accessor Methods
      • xml.dom.minidom --- Lightweight DOM implementation
        • DOM Objects
        • DOM Example
        • minidom and the DOM standard
      • xml.dom.pulldom --- Support for building partial DOM trees
        • DOMEventStream Objects
      • xml.sax --- Support for SAX2 parsers
        • SAXException Objects
      • xml.sax.handler --- Base classes for SAX handlers
        • ContentHandler Objects
        • DTDHandler Objects
        • EntityResolver Objects
        • ErrorHandler Objects
      • xml.sax.saxutils --- SAX Utilities
      • xml.sax.xmlreader --- Interface for XML parsers
        • XMLReader Objects
        • IncrementalParser Objects
        • Locator Objects
        • InputSource Objects
        • The Attributes Interface
        • The AttributesNS Interface
      • xml.etree.ElementTree --- The ElementTree XML API
        • Functions
        • 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
      • 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
      • ttk --- Tk themed widgets
        • Using Ttk
        • Ttk Widgets
        • Widget
          • Standard Options
          • Scrollable Widget Options
          • Label Options
          • Compatibility Options
          • Widget States
          • ttk.Widget
        • Combobox
          • Options
          • Virtual events
          • ttk.Combobox
        • Notebook
          • Options
          • Tab Options
          • Tab Identifiers
          • Virtual Events
          • ttk.Notebook
        • Progressbar
          • Options
          • ttk.Progressbar
        • Separator
          • Options
        • Sizegrip
          • Platform-specific notes
          • Bugs
        • Treeview
          • Options
          • Item Options
          • Tag Options
          • Column Identifiers
          • Virtual Events
          • ttk.Treeview
        • Ttk Styling
          • Layouts
      • Tix --- Extension widgets for Tk
        • Using Tix
        • Tix Widgets
          • Basic Widgets
          • File Selectors
          • Hierarchical ListBox
          • Tabular ListBox
          • Manager Widgets
          • Image Types
          • Miscellaneous Widgets
          • Form Geometry Manager
        • Tix Commands
      • ScrolledText --- Scrolled Text Widget
      • turtle --- Turtle graphics for Tk
        • Introduction
        • Overview over available Turtle and Screen methods
          • Turtle methods
          • Methods of TurtleScreen/Screen
        • Methods of RawTurtle/Turtle and corresponding functions
          • Turtle motion
          • Tell Turtle's state
          • Settings for measurement
          • Pen control
            • Drawing state
            • Color control
            • Filling
            • More drawing control
          • Turtle state
            • Visibility
            • Appearance
          • Using events
          • Special Turtle methods
          • Excursus about the use of compound shapes
        • Methods of TurtleScreen/Screen and corresponding functions
          • Window control
          • Animation control
          • Using screen events
          • Settings and special methods
          • Methods specific to Screen, not inherited from TurtleScreen
        • The public classes of the module turtle
        • Help and configuration
          • How to use help
          • Translation of docstrings into different languages
          • How to configure Screen and Turtles
        • Demo scripts
      • IDLE
        • Menus
          • File menu
          • Edit menu
          • Windows menu
          • Debug menu (in the Python Shell window only)
        • Basic editing and navigation
          • Automatic indentation
          • Python Shell window
        • Syntax colors
        • Startup
          • Command line usage
      • Other Graphical User Interface Packages
    • Development Tools
      • pydoc --- Documentation generator and online help system
      • doctest --- Test interactive Python examples
        • Simple Usage: Checking Examples in Docstrings
        • Simple Usage: Checking Examples in a Text File
        • How It Works
          • Which Docstrings Are Examined?
          • How are Docstring Examples Recognized?
          • What's the Execution Context?
          • What About Exceptions?
          • Option Flags and Directives
          • Warnings
        • Basic API
        • Unittest API
        • Advanced API
          • DocTest Objects
          • Example Objects
          • DocTestFinder objects
          • DocTestParser objects
          • DocTestRunner objects
          • OutputChecker objects
        • Debugging
        • Soapbox
      • unittest --- Unit testing framework
        • Basic example
        • 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
      • fpectl --- Floating point exception control
        • Example
        • Limitations and other considerations
      • distutils --- Building and installing Python modules
    • Custom Python Interpreters
      • code --- Interpreter base classes
        • Interactive Interpreter Objects
        • Interactive Console Objects
      • codeop --- Compile Python code
    • Restricted Execution
      • rexec --- Restricted execution framework
        • RExec Objects
        • Defining restricted environments
        • An example
      • Bastion --- Restricting access to objects
    • Importing Modules
      • imp --- Access the import internals
        • Examples
      • 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
      • msilib --- Read and write Microsoft Installer files
        • Database Objects
        • View Objects
        • Summary Information Objects
        • Record Objects
        • Errors
        • CAB Objects
        • Directory Objects
        • Features
        • GUI classes
        • Precomputed tables
      • msvcrt -- Useful routines from the MS VC++ runtime
        • File Operations
        • Console I/O
        • Other Functions
      • _winreg -- Windows registry access
        • Constants
          • HKEY_* Constants
          • Access Rights
            • 64-bit Specific
          • Value Types
        • Registry Handle Objects
      • winsound --- Sound-playing interface for Windows
    • Unix Specific Services
      • posix --- The most common POSIX system calls
        • Large File Support
        • Notable Module Contents
      • pwd --- The password database
      • spwd --- The shadow password database
      • grp --- The group database
      • crypt --- Function to check Unix passwords
      • dl --- Call C functions in shared objects
        • Dl Objects
      • termios --- POSIX style tty control
        • Example
      • tty --- Terminal control functions
      • pty --- Pseudo-terminal utilities
      • fcntl --- The fcntl() and ioctl() system calls
      • pipes --- Interface to shell pipelines
        • Template Objects
      • posixfile --- File-like objects with locking support
      • resource --- Resource usage information
        • Resource Limits
        • Resource Usage
      • nis --- Interface to Sun's NIS (Yellow Pages)
      • syslog --- Unix syslog library routines
        • Examples
          • Simple example
      • commands --- Utilities for running commands
    • Mac OS X specific services
      • ic --- Access to the Mac OS X Internet Config
        • IC Objects
      • MacOS --- Access to Mac OS interpreter features
      • macostools --- Convenience routines for file manipulation
      • findertools --- The finder's Apple Events interface
      • EasyDialogs --- Basic Macintosh dialogs
        • ProgressBar Objects
      • FrameWork --- Interactive application framework
        • Application Objects
        • Window Objects
        • ControlsWindow Object
        • ScrolledWindow Object
        • DialogWindow Objects
      • autoGIL --- Global Interpreter Lock handling in event loops
      • Mac OS Toolbox Modules
        • Carbon.AE --- Apple Events
        • Carbon.AH --- Apple Help
        • Carbon.App --- Appearance Manager
        • Carbon.Appearance --- Appearance Manager constants
        • Carbon.CF --- Core Foundation
        • Carbon.CG --- Core Graphics
        • Carbon.CarbonEvt --- Carbon Event Manager
        • Carbon.CarbonEvents --- Carbon Event Manager constants
        • Carbon.Cm --- Component Manager
        • Carbon.Components --- Component Manager constants
        • Carbon.ControlAccessor --- Control Manager accssors
        • Carbon.Controls --- Control Manager constants
        • Carbon.CoreFounation --- CoreFounation constants
        • Carbon.CoreGraphics --- CoreGraphics constants
        • Carbon.Ctl --- Control Manager
        • Carbon.Dialogs --- Dialog Manager constants
        • Carbon.Dlg --- Dialog Manager
        • Carbon.Drag --- Drag and Drop Manager
        • Carbon.Dragconst --- Drag and Drop Manager constants
        • Carbon.Events --- Event Manager constants
        • Carbon.Evt --- Event Manager
        • Carbon.File --- File Manager
        • Carbon.Files --- File Manager constants
        • Carbon.Fm --- Font Manager
        • Carbon.Folder --- Folder Manager
        • Carbon.Folders --- Folder Manager constants
        • Carbon.Fonts --- Font Manager constants
        • Carbon.Help --- Help Manager
        • Carbon.IBCarbon --- Carbon InterfaceBuilder
        • Carbon.IBCarbonRuntime --- Carbon InterfaceBuilder constants
        • Carbon.Icn --- Carbon Icon Manager
        • Carbon.Icons --- Carbon Icon Manager constants
        • Carbon.Launch --- Carbon Launch Services
        • Carbon.LaunchServices --- Carbon Launch Services constants
        • Carbon.List --- List Manager
        • Carbon.Lists --- List Manager constants
        • Carbon.MacHelp --- Help Manager constants
        • Carbon.MediaDescr --- Parsers and generators for Quicktime Media descriptors
        • Carbon.Menu --- Menu Manager
        • Carbon.Menus --- Menu Manager constants
        • Carbon.Mlte --- MultiLingual Text Editor
        • Carbon.OSA --- Carbon OSA Interface
        • Carbon.OSAconst --- Carbon OSA Interface constants
        • Carbon.QDOffscreen --- QuickDraw Offscreen constants
        • Carbon.Qd --- QuickDraw
        • Carbon.Qdoffs --- QuickDraw Offscreen
        • Carbon.Qt --- QuickTime
        • Carbon.QuickDraw --- QuickDraw constants
        • Carbon.QuickTime --- QuickTime constants
        • Carbon.Res --- Resource Manager and Handles
        • Carbon.Resources --- Resource Manager and Handles constants
        • Carbon.Scrap --- Scrap Manager
        • Carbon.Snd --- Sound Manager
        • Carbon.Sound --- Sound Manager constants
        • Carbon.TE --- TextEdit
        • Carbon.TextEdit --- TextEdit constants
        • Carbon.Win --- Window Manager
        • Carbon.Windows --- Window Manager constants
      • ColorPicker --- Color selection dialog
    • MacPython OSA Modules
      • gensuitemodule --- Generate OSA stub packages
      • aetools --- OSA client support
      • aepack --- Conversion between Python variables and AppleEvent data containers
      • aetypes --- AppleEvent objects
      • MiniAEFrame --- Open Scripting Architecture server support
        • AEServer Objects
    • SGI IRIX Specific Services
      • al --- Audio functions on the SGI
        • Configuration Objects
        • Port Objects
      • AL --- Constants used with the al module
      • cd --- CD-ROM access on SGI systems
        • Player Objects
        • Parser Objects
      • fl --- FORMS library for graphical user interfaces
        • Functions Defined in Module fl
        • Form Objects
        • FORMS Objects
      • FL --- Constants used with the fl module
      • flp --- Functions for loading stored FORMS designs
      • fm --- Font Manager interface
      • gl --- Graphics Library interface
      • DEVICE --- Constants used with the gl module
      • GL --- Constants used with the gl module
      • imgfile --- Support for SGI imglib files
      • jpeg --- Read and write JPEG files
    • SunOS Specific Services
      • sunaudiodev --- Access to Sun audio hardware
        • Audio Device Objects
      • SUNAUDIODEV --- Constants used with sunaudiodev
    • Undocumented Modules
      • Miscellaneous useful utilities
      • Platform specific modules
      • Multimedia
      • Undocumented Mac OS modules
        • applesingle --- AppleSingle decoder
        • buildtools --- Helper module for BuildApplet and Friends
        • cfmfile --- Code Fragment Resource module
        • icopen --- Internet Config replacement for open()
        • macerrors --- Mac OS Errors
        • macresource --- Locate script resources
        • Nav --- NavServices calls
        • PixMapWrapper --- Wrapper for PixMap objects
        • videoreader --- Read QuickTime movies
        • W --- Widgets built on FrameWork
      • Obsolete
      • SGI-specific Extension modules
  • Extending and Embedding the Python Interpreter
    • Extending Python with C or C++
      • A Simple Example
      • Intermezzo: Errors and Exceptions
      • Back to the Example
      • The Module's Method Table and Initialization Function
      • Compilation and Linkage
      • Calling Python Functions from C
      • Extracting Parameters in Extension Functions
      • Keyword Parameters for Extension Functions
      • Building Arbitrary Values
      • Reference Counts
        • Reference Counting in Python
        • Ownership Rules
        • Thin Ice
        • NULL Pointers
      • Writing Extensions in C++
      • Providing a C API for an Extension Module
    • Defining New Types
      • The Basics
        • Adding data and methods to the Basic example
        • Providing finer control over data attributes
        • Supporting cyclic garbage collection
        • Subclassing other types
      • Type Methods
        • Finalization and De-allocation
        • Object Presentation
        • Attribute Management
          • Generic Attribute Management
          • Type-specific Attribute Management
        • Object Comparison
        • Abstract Protocol Support
        • Weak Reference Support
        • More Suggestions
    • Building C and C++ Extensions with distutils
      • Distributing your extension modules
    • Building C and C++ Extensions on Windows
      • A Cookbook Approach
      • Differences Between Unix and Windows
      • Using DLLs in Practice
    • Embedding Python in Another Application
      • Very High Level Embedding
      • Beyond Very High Level Embedding: An overview
      • Pure Embedding
      • Extending Embedded Python
      • Embedding Python in C++
      • Linking Requirements
  • Python/C API Reference Manual
    • Introduction
      • Include Files
      • Objects, Types and Reference Counts
        • Reference Counts
          • Reference Count Details
        • Types
      • Exceptions
      • Embedding Python
      • Debugging Builds
    • The Very High Level Layer
    • Reference Counting
    • Exception Handling
      • Recursion Control
      • Standard Exceptions
      • Deprecation of String Exceptions
    • Utilities
      • Operating System Utilities
      • System Functions
      • Process Control
      • Importing Modules
      • Data marshalling support
      • Parsing arguments and building values
      • String conversion and formatting
      • Reflection
    • Abstract Objects Layer
      • Object Protocol
      • Number Protocol
      • Sequence Protocol
      • Mapping Protocol
      • Iterator Protocol
      • Old Buffer Protocol
    • Concrete Objects Layer
      • Fundamental Objects
        • Type Objects
        • The None Object
      • Numeric Objects
        • Plain Integer Objects
        • Boolean Objects
        • Long Integer Objects
        • Floating Point Objects
        • Complex Number Objects
          • Complex Numbers as C Structures
          • Complex Numbers as Python Objects
      • Sequence Objects
        • Byte Array Objects
          • Type check macros
          • Direct API functions
          • Macros
        • String/Bytes Objects
        • Unicode Objects and Codecs
          • Unicode Objects
            • Unicode Type
            • Unicode Character Properties
            • Plain Py_UNICODE
            • wchar_t Support
          • Built-in Codecs
            • Generic Codecs
            • UTF-8 Codecs
            • UTF-32 Codecs
            • UTF-16 Codecs
            • Unicode-Escape Codecs
            • Raw-Unicode-Escape Codecs
            • Latin-1 Codecs
            • ASCII Codecs
            • Character Map Codecs
            • MBCS codecs for Windows
            • Methods & Slots
          • Methods and Slot Functions
        • Buffers and Memoryview Objects
          • The new-style Py_buffer struct
          • Buffer related functions
          • MemoryView objects
          • Old-style buffer objects
        • Tuple Objects
        • List Objects
      • Mapping Objects
        • Dictionary Objects
      • Other Objects
        • Class and Instance Objects
        • Function Objects
        • Method Objects
        • File Objects
        • Module Objects
        • Iterator Objects
        • Descriptor Objects
        • Slice Objects
        • Weak Reference Objects
        • Capsules
        • CObjects
        • Cell Objects
        • Generator Objects
        • DateTime Objects
        • Set Objects
        • Code Objects
    • Initialization, Finalization, and Threads
      • Thread State and the Global Interpreter Lock
      • Asynchronous Notifications
      • 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
      • 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
  • 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 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
      • strtod and dtoa

Get in touch

Submit feedback about this site to:

  • [email protected]

© documentation.help. Design: rehmann.co.