documentation.HELP! Python 2.7.13 Documentation

Copyright

Python 2.7.13

previous page next page

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python »
  • Python 2.7.13 documentation »

Copyright

Python and this documentation is:

Copyright © 2001-2016 Python Software Foundation. All rights reserved.

Copyright © 2000 BeOpen.com. All rights reserved.

Copyright © 1995-2000 Corporation for National Research Initiatives. All rights reserved.

Copyright © 1991-1995 Stichting Mathematisch Centrum. All rights reserved.

See History and License for complete license and permissions information.

Navigation

  • index
  • modules |
  • next |
  • previous |
  • Python »
  • Python 2.7.13 documentation »
© Copyright 1990-2016, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Dec 17, 2016. Found a bug?
Created using Sphinx 1.4.4.
previous page start next page

Menu

  • Homepage

Table of contents

  • Python 2.7.13 documentation
  • Python Module Index
  • What's New in Python
    • What's New in Python 2.7
      • The Future for Python 2.x
      • Changes to the Handling of Deprecation Warnings
      • 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
      • New Features Added to Python 2.7 Maintenance Releases
        • PEP 434: IDLE Enhancement Exception for All Branches
        • PEP 466: Network Security Enhancements for Python 2.7
        • PEP 477: Backport ensurepip (PEP 453) to Python 2.7
          • Bootstrapping pip By Default
          • Documentation Changes
        • PEP 476: Enabling certificate verification by default for stdlib http clients
        • PEP 493: HTTPS verification migration tools for 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
        • Source Code Encoding
    • 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 Expressions
        • 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
        • Saving structured data with json
    • 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
        • Class and Instance Variables
      • Random Remarks
      • Inheritance
        • Multiple Inheritance
      • Private Variables and Class-local References
      • 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
    • Appendix
      • Interactive Mode
        • Error Handling
        • Executable Python Scripts
        • The Interactive Startup File
        • The Customization Modules
  • Python Setup and Usage
    • 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
      • 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
          • Generator-iterator methods
      • 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
      • Operator precedence
    • 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
        • Bitwise Operations on Integer Types
        • Additional Methods on Integer Types
        • Additional Methods on Float
      • Iterator Types
        • Generator Types
      • Sequence Types --- str, unicode, list, tuple, bytearray, 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
        • The NotImplemented Object
        • Boolean Values
        • Internal Objects
      • Special Attributes
    • Built-in Exceptions
      • Exception hierarchy
    • String Services
      • string --- Common string operations
        • String constants
        • Custom 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
        • Module Contents
        • Regular Expression Objects
        • Match Objects
        • Examples
          • Checking For a Pair
          • Simulating scanf()
          • 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
        • Python Specific 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
        • Counter objects
        • deque objects
          • deque Recipes
        • defaultdict objects
          • defaultdict Examples
        • namedtuple() Factory Function for Tuples with Named Fields
        • OrderedDict objects
          • OrderedDict Examples and Recipes
        • Collections Abstract Base Classes
      • heapq --- Heap queue algorithm
        • Basic Examples
        • Priority Queue Implementation Notes
        • Theory
      • bisect --- Array bisection algorithm
        • Searching Sorted Lists
        • Other 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
        • Archiving 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
        • Example
      • 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
        • Common issues
          • Multithreading
    • 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
        • Command-Line Interface
          • Command-line options
      • 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
        • Key derivation
      • 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
        • Advanced topics
          • Performance
            • Binary I/O
            • Text I/O
          • Multi-threading
          • Reentrancy
      • 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
          • prog
          • usage
          • description
          • epilog
          • parents
          • formatter_class
          • prefix_chars
          • fromfile_prefix_chars
          • argument_default
          • conflict_handler
          • add_help
        • The add_argument() method
          • name or flags
          • action
          • nargs
          • const
          • default
          • type
          • choices
          • required
          • help
          • metavar
          • dest
          • Action classes
        • The parse_args() method
          • Option value syntax
          • Invalid arguments
          • Arguments containing -
          • Argument abbreviations (prefix matching)
          • Beyond sys.argv
          • The Namespace object
        • Other utilities
          • Sub-commands
          • FileType objects
          • Argument groups
          • Mutual exclusion
          • Parser defaults
          • Printing help
          • Partial parsing
          • Customizing file parsing
          • Exiting methods
        • 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
            • Grouping Options
          • 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
        • Logger Objects
        • Logging Levels
        • Handler Objects
        • Formatter Objects
        • Filter Objects
        • LogRecord Objects
        • LogRecord attributes
        • LoggerAdapter Objects
        • Thread Safety
        • Module-Level Functions
        • Integration with the warnings module
      • logging.config --- Logging configuration
        • Configuration functions
        • Configuration dictionary schema
          • Dictionary Schema Details
          • Incremental Configuration
          • Object connections
          • User-defined objects
          • Access to external objects
          • Access to internal objects
          • Import resolution and custom importers
        • Configuration file format
      • logging.handlers --- Logging handlers
        • StreamHandler
        • FileHandler
        • NullHandler
        • WatchedFileHandler
        • RotatingFileHandler
        • TimedRotatingFileHandler
        • SocketHandler
        • DatagramHandler
        • SysLogHandler
        • NTEventLogHandler
        • SMTPHandler
        • MemoryHandler
        • HTTPHandler
      • 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.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
            • 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
        • Init file
        • Line buffer
        • History file
        • History list
        • Startup hooks
        • Completion
        • Example
      • rlcompleter --- Completion function for GNU readline
        • Completer Objects
    • Interprocess Communication and Networking
      • subprocess --- Subprocess management
        • Using the subprocess Module
          • Frequently Used Arguments
          • Popen Constructor
          • Exceptions
          • Security
        • Popen Objects
        • Windows Popen Helpers
          • Constants
        • 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
        • Notes
          • Converting an argument sequence to a string on Windows
      • socket --- Low-level networking interface
        • Socket Objects
        • Example
      • ssl --- TLS/SSL wrapper for socket objects
        • Functions, Constants, and Exceptions
          • Socket creation
          • Context creation
          • Random generation
          • Certificate handling
          • Constants
        • SSL Sockets
        • SSL Contexts
        • Certificates
          • Certificate chains
          • CA certificates
          • Combined key and certificate
          • Self-signed certificates
        • Examples
          • Testing for SSL support
          • Client-side operation
          • Server-side operation
        • Notes on non-blocking sockets
        • Security considerations
          • Best defaults
          • Manual settings
            • Verifying certificates
            • Protocol versions
            • Cipher selection
          • Multi-processing
      • 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
        • asyncore Example basic echo server
      • asynchat --- Asynchronous socket command/response handler
        • asynchat - Auxiliary Classes
        • asynchat Example
    • Internet Data Handling
      • email --- An email and MIME handling package
        • email.message: Representing an email message
        • email.parser: Parsing email messages
          • FeedParser API
          • Parser class API
          • Additional notes
        • email.generator: Generating MIME documents
        • email.mime: Creating email and MIME objects from scratch
        • email.header: Internationalized headers
        • email.charset: Representing character sets
        • email.encoders: Encoders
        • email.errors: Exception and Defect classes
        • email.utils: Miscellaneous utilities
        • email.iterators: Iterators
        • email: Examples
        • Package History
        • Differences from mimelib
      • json --- JSON encoder and decoder
        • Basic Usage
        • Encoders and Decoders
        • Standard Compliance and Interoperability
          • Character Encodings
          • Infinite and NaN Number Values
          • Repeated Names Within an Object
          • Top-level Non-Object, Non-Array Values
          • Implementation Limitations
      • 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
        • HTMLParser Methods
        • Examples
      • sgmllib --- Simple SGML parser
      • htmllib --- A parser for HTML documents
        • HTMLParser Objects
      • htmlentitydefs --- Definitions of HTML general entities
      • XML Processing Modules
      • XML vulnerabilities
        • defused packages
      • xml.etree.ElementTree --- The ElementTree XML API
        • Tutorial
          • XML tree and elements
          • Parsing XML
          • Finding interesting elements
          • Modifying an XML File
          • Building XML documents
          • Parsing XML with Namespaces
          • Additional resources
        • XPath support
          • Example
          • Supported XPath syntax
        • Reference
          • Functions
          • Element Objects
          • ElementTree Objects
          • QName Objects
          • TreeBuilder Objects
          • XMLParser Objects
      • 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 --- Minimal 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.parsers.expat --- Fast XML parsing using Expat
        • XMLParser Objects
        • ExpatError Exceptions
        • Example
        • Content Model Descriptions
        • Expat error constants
    • 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
        • Request Handler 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
        • File Handlers
      • 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 (Shell and Editor)
          • Edit menu (Shell and Editor)
          • Format menu (Editor window only)
          • Run menu (Editor window only)
          • Shell menu (Shell window only)
          • Debug menu (Shell window only)
          • Options menu (Shell and Editor)
          • Window menu (Shell and Editor)
          • Help menu (Shell and Editor)
          • Context Menus
        • Editing and navigation
          • Automatic indentation
          • Completions
          • Calltips
          • Python Shell window
          • Text colors
        • Startup and code execution
          • Command line usage
          • IDLE-console differences
          • Running without a subprocess
        • Help and preferences
          • Additional help sources
          • Setting preferences
          • Extensions
      • 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
          • 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
          • Command-line options
        • Test Discovery
        • Organizing test code
        • Re-using old test code
        • Skipping tests and expected failures
        • Classes and functions
          • Test cases
            • Deprecated aliases
          • 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 the command-line interface
      • 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
        • profile and cProfile Module Reference
        • The Stats Class
        • What Is Deterministic Profiling?
        • Limitations
        • Calibration
        • Using a custom timer
      • hotshot --- High performance logging profiler
        • Profile Objects
        • Using hotshot data
        • Example Usage
      • timeit --- Measure execution time of small code snippets
        • Basic Examples
        • Python Interface
        • Command-Line Interface
        • Examples
      • trace --- Trace or track Python statement execution
        • Command-Line Usage
          • Main options
          • Modifiers
          • Filters
        • Programmatic Interface
    • Software Packaging and Distribution
      • distutils --- Building and installing Python modules
      • ensurepip --- Bootstrapping the pip installer
        • Command line interface
        • Module API
    • 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
          • Default Warning Filters
        • 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
    • 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
        • Example: Emulation of compile()
      • ast --- 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
        • Command-line use
        • Public functions
      • 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++
      • Compiling and Linking under Unix-like systems
  • 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
      • Unicode Exception Objects
      • Recursion Control
      • Standard Exceptions
      • 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
      • Codec registry and support functions
        • Codec lookup API
        • Registry API for Unicode encoding error handlers
    • Abstract Objects Layer
      • Object Protocol
      • Number Protocol
      • Sequence Protocol
      • Mapping Protocol
      • Iterator Protocol
      • Old Buffer Protocol
    • Concrete Objects Layer
      • Fundamental Objects
        • Type Objects
        • The None Object
      • Numeric Objects
        • Plain Integer Objects
        • Boolean Objects
        • Long Integer Objects
        • Floating Point Objects
        • Complex Number Objects
          • Complex Numbers as C Structures
          • Complex Numbers as Python Objects
      • Sequence Objects
        • Byte Array Objects
          • Type check macros
          • Direct API functions
          • Macros
        • String/Bytes Objects
        • Unicode Objects and Codecs
          • Unicode Objects
            • Unicode Type
            • Unicode Character Properties
            • Plain Py_UNICODE
            • wchar_t Support
          • Built-in Codecs
            • Generic Codecs
            • UTF-8 Codecs
            • UTF-32 Codecs
            • UTF-16 Codecs
            • UTF-7 Codecs
            • Unicode-Escape Codecs
            • Raw-Unicode-Escape Codecs
            • Latin-1 Codecs
            • ASCII Codecs
            • Character Map Codecs
            • MBCS codecs for Windows
            • Methods & Slots
          • Methods and Slot Functions
        • 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
      • Initializing and finalizing the interpreter
      • Process-wide parameters
      • Thread State and the Global Interpreter Lock
        • Releasing the GIL from extension code
        • Non-Python created threads
        • High-level API
        • Low-level API
      • Sub-interpreter support
        • Bugs and caveats
      • 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
    • Key terms
    • Open source licensing and collaboration
    • Installing the tools
    • Reading the guide
    • How do I...?
      • ... choose a name for my project?
      • ... create and distribute binary extensions?
  • Installing Python Modules
    • Key terms
    • Basic usage
    • How do I ...?
      • ... install pip in versions of Python prior to Python 2.7.9?
      • ... install packages just for the current user?
      • ... install scientific Python packages?
      • ... work with multiple versions of Python installed in parallel?
    • Common installation issues
      • Installing into the system Python on Linux
      • Installing binary extensions
  • Python HOWTOs
    • Porting Python 2 Code to Python 3
      • The Short Explanation
      • Details
        • Drop support for Python 2.5 and older (at least)
        • Make sure you specify the proper version support in your setup.py file
        • Have good test coverage
        • Learn the differences between Python 2 & 3
        • Update your code
          • Division
          • Text versus binary data
        • Prevent compatibility regressions
        • Check which dependencies block your transition
        • Update your setup.py file to denote Python 3 compatibility
        • Use continuous integration to stay compatible
      • Dropping Python 2 support completely
    • Porting Extension Modules to Python 3
      • Conditional compilation
      • Changes to Object APIs
        • str/unicode Unification
        • long/int Unification
      • Module initialization and state
      • CObject replaced with Capsule
      • 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
      • Revision History and Acknowledgements
      • References
        • General
        • Python-specific
        • Python documentation
    • Logging HOWTO
      • Basic Logging Tutorial
        • When to use logging
        • A simple example
        • Logging to a file
        • Logging from multiple modules
        • Logging variable data
        • Changing the format of displayed messages
        • Displaying the date/time in messages
        • Next Steps
      • Advanced Logging Tutorial
        • Logging Flow
        • Loggers
        • Handlers
        • Formatters
        • Configuring Logging
        • What happens if no configuration is provided
        • Configuring Logging for a Library
      • Logging Levels
        • Custom Levels
      • Useful Handlers
      • Exceptions raised during logging
      • Using arbitrary objects as messages
      • Optimization
    • Logging Cookbook
      • Using logging in multiple modules
      • Logging from multiple threads
      • Multiple handlers and formatters
      • Logging to multiple destinations
      • Configuration server example
      • Sending and receiving logging events across a network
      • Adding contextual information to your logging output
        • Using LoggerAdapters to impart contextual information
          • Using objects other than dicts to pass contextual information
        • Using Filters to impart contextual information
      • Logging to a single file from multiple processes
      • Using file rotation
      • An example dictionary-based configuration
      • Inserting a BOM into messages sent to a SysLogHandler
      • Implementing structured logging
      • Customizing handlers with dictConfig()
      • Configuring filters with dictConfig()
      • Customized exception formatting
      • Speaking logging messages
      • Buffering logging messages and outputting them conditionally
      • Formatting times using UTC (GMT) via configuration
      • Using a context manager for selective logging
    • 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
        • 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
    • Argparse Tutorial
      • Concepts
      • The basics
      • Introducing Positional arguments
      • Introducing Optional arguments
        • Short options
      • Combining Positional and Optional arguments
      • Getting a little more advanced
        • Conflicting options
      • Conclusion
  • 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 expressions 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 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?
      • How do I make an executable from a Python script?
      • Is a *.pyd file the same as a DLL?
      • How can I embed Python into a Windows application?
      • 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?
      • How do I extract the downloaded documentation on Windows?
    • 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
    • Getting started contributing to Python yourself
  • Copyright
  • History and License
    • History of the software
    • Terms and conditions for accessing or otherwise using Python
      • PSF LICENSE AGREEMENT FOR PYTHON 2.7.13
      • BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
      • CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
      • CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
    • Licenses and Acknowledgements for Incorporated Software
      • Mersenne Twister
      • Sockets
      • Floating point exception control
      • MD5 message digest algorithm
      • Asynchronous socket services
      • Cookie management
      • Execution tracing
      • UUencode and UUdecode functions
      • XML Remote Procedure Calls
      • test_epoll
      • Select kqueue
      • strtod and dtoa
      • OpenSSL
      • expat
      • libffi
      • zlib

Get in touch

Submit feedback about this site to:

  • [email protected]

© documentation.help. Design: rehmann.co.