Your IP : 216.73.216.48
Python Documentation contents
*****************************
* 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
* 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
* 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
* "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
* 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
* 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
* 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
* 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
* 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
* 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
* 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