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
* Two new environment variables for debug mode
* 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
* New "make regen-all" build target
* Removal of "make touch" build target
* 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
* 1. Whetting Your Appetite
* 2. Using the Python Interpreter
* 2.1. Invoking the Interpreter
* 2.1.1. Argument Passing
* 2.1.2. Interactive Mode
* 2.2. The Interpreter and Its Environment
* 2.2.1. Source Code Encoding
* 3. An Informal Introduction to Python
* 3.1. Using Python as a Calculator
* 3.1.1. Numbers
* 3.1.2. Strings
* 3.1.3. Unicode Strings
* 3.1.4. Lists
* 3.2. First Steps Towards Programming
* 4. More Control Flow Tools
* 4.1. "if" Statements
* 4.2. "for" Statements
* 4.3. The "range()" Function
* 4.4. "break" and "continue" Statements, and "else" Clauses on
Loops
* 4.5. "pass" Statements
* 4.6. Defining Functions
* 4.7. More on Defining Functions
* 4.7.1. Default Argument Values
* 4.7.2. Keyword Arguments
* 4.7.3. Arbitrary Argument Lists
* 4.7.4. Unpacking Argument Lists
* 4.7.5. Lambda Expressions
* 4.7.6. Documentation Strings
* 4.8. Intermezzo: Coding Style
* 5. Data Structures
* 5.1. More on Lists
* 5.1.1. Using Lists as Stacks
* 5.1.2. Using Lists as Queues
* 5.1.3. Functional Programming Tools
* 5.1.4. List Comprehensions
* 5.1.4.1. Nested List Comprehensions
* 5.2. The "del" statement
* 5.3. Tuples and Sequences
* 5.4. Sets
* 5.5. Dictionaries
* 5.6. Looping Techniques
* 5.7. More on Conditions
* 5.8. Comparing Sequences and Other Types
* 6. Modules
* 6.1. More on Modules
* 6.1.1. Executing modules as scripts
* 6.1.2. The Module Search Path
* 6.1.3. “Compiled” Python files
* 6.2. Standard Modules
* 6.3. The "dir()" Function
* 6.4. Packages
* 6.4.1. Importing * From a Package
* 6.4.2. Intra-package References
* 6.4.3. Packages in Multiple Directories
* 7. Input and Output
* 7.1. Fancier Output Formatting
* 7.1.1. Old string formatting
* 7.2. Reading and Writing Files
* 7.2.1. Methods of File Objects
* 7.2.2. Saving structured data with "json"
* 8. Errors and Exceptions
* 8.1. Syntax Errors
* 8.2. Exceptions
* 8.3. Handling Exceptions
* 8.4. Raising Exceptions
* 8.5. User-defined Exceptions
* 8.6. Defining Clean-up Actions
* 8.7. Predefined Clean-up Actions
* 9. Classes
* 9.1. A Word About Names and Objects
* 9.2. Python Scopes and Namespaces
* 9.3. A First Look at Classes
* 9.3.1. Class Definition Syntax
* 9.3.2. Class Objects
* 9.3.3. Instance Objects
* 9.3.4. Method Objects
* 9.3.5. Class and Instance Variables
* 9.4. Random Remarks
* 9.5. Inheritance
* 9.5.1. Multiple Inheritance
* 9.6. Private Variables and Class-local References
* 9.7. Odds and Ends
* 9.8. Exceptions Are Classes Too
* 9.9. Iterators
* 9.10. Generators
* 9.11. Generator Expressions
* 10. Brief Tour of the Standard Library
* 10.1. Operating System Interface
* 10.2. File Wildcards
* 10.3. Command Line Arguments
* 10.4. Error Output Redirection and Program Termination
* 10.5. String Pattern Matching
* 10.6. Mathematics
* 10.7. Internet Access
* 10.8. Dates and Times
* 10.9. Data Compression
* 10.10. Performance Measurement
* 10.11. Quality Control
* 10.12. Batteries Included
* 11. Brief Tour of the Standard Library — Part II
* 11.1. Output Formatting
* 11.2. Templating
* 11.3. Working with Binary Data Record Layouts
* 11.4. Multi-threading
* 11.5. Logging
* 11.6. Weak References
* 11.7. Tools for Working with Lists
* 11.8. Decimal Floating Point Arithmetic
* 12. What Now?
* 13. Interactive Input Editing and History Substitution
* 13.1. Line Editing
* 13.2. History Substitution
* 13.3. Key Bindings
* 13.4. Alternatives to the Interactive Interpreter
* 14. Floating Point Arithmetic: Issues and Limitations
* 14.1. Representation Error
* 15. Appendix
* 15.1. Interactive Mode
* 15.1.1. Error Handling
* 15.1.2. Executable Python Scripts
* 15.1.3. The Interactive Startup File
* 15.1.4. The Customization Modules
* Python Setup and Usage
* 1. Command line and environment
* 1.1. Command line
* 1.1.1. Interface options
* 1.1.2. Generic options
* 1.1.3. Miscellaneous options
* 1.1.4. Options you shouldn’t use
* 1.2. Environment variables
* 1.2.1. Debug-mode variables
* 2. Using Python on Unix platforms
* 2.1. Getting and installing the latest version of Python
* 2.1.1. On Linux
* 2.1.2. On FreeBSD and OpenBSD
* 2.1.3. On OpenSolaris
* 2.2. Building Python
* 2.3. Python-related paths and files
* 2.4. Miscellaneous
* 2.5. Editors and IDEs
* 3. Using Python on Windows
* 3.1. Installing Python
* 3.2. Alternative bundles
* 3.3. Configuring Python
* 3.3.1. Excursus: Setting environment variables
* 3.3.2. Finding the Python executable
* 3.3.3. Finding modules
* 3.3.4. Executing scripts
* 3.4. Additional modules
* 3.4.1. PyWin32
* 3.4.2. Py2exe
* 3.4.3. WConio
* 3.5. Compiling Python on Windows
* 3.6. Other resources
* 4. Using Python on a Macintosh
* 4.1. Getting and Installing MacPython
* 4.1.1. How to run a Python script
* 4.1.2. Running scripts with a GUI
* 4.1.3. Configuration
* 4.2. The IDE
* 4.3. Installing Additional Python Packages
* 4.4. GUI Programming on the Mac
* 4.5. Distributing Python Applications on the Mac
* 4.6. Other Resources
* The Python Language Reference
* 1. Introduction
* 1.1. Alternate Implementations
* 1.2. Notation
* 2. Lexical analysis
* 2.1. Line structure
* 2.1.1. Logical lines
* 2.1.2. Physical lines
* 2.1.3. Comments
* 2.1.4. Encoding declarations
* 2.1.5. Explicit line joining
* 2.1.6. Implicit line joining
* 2.1.7. Blank lines
* 2.1.8. Indentation
* 2.1.9. Whitespace between tokens
* 2.2. Other tokens
* 2.3. Identifiers and keywords
* 2.3.1. Keywords
* 2.3.2. Reserved classes of identifiers
* 2.4. Literals
* 2.4.1. String literals
* 2.4.2. String literal concatenation
* 2.4.3. Numeric literals
* 2.4.4. Integer and long integer literals
* 2.4.5. Floating point literals
* 2.4.6. Imaginary literals
* 2.5. Operators
* 2.6. Delimiters
* 3. Data model
* 3.1. Objects, values and types
* 3.2. The standard type hierarchy
* 3.3. New-style and classic classes
* 3.4. Special method names
* 3.4.1. Basic customization
* 3.4.2. Customizing attribute access
* 3.4.2.1. More attribute access for new-style classes
* 3.4.2.2. Implementing Descriptors
* 3.4.2.3. Invoking Descriptors
* 3.4.2.4. __slots__
* 3.4.3. Customizing class creation
* 3.4.4. Customizing instance and subclass checks
* 3.4.5. Emulating callable objects
* 3.4.6. Emulating container types
* 3.4.7. Additional methods for emulation of sequence types
* 3.4.8. Emulating numeric types
* 3.4.9. Coercion rules
* 3.4.10. With Statement Context Managers
* 3.4.11. Special method lookup for old-style classes
* 3.4.12. Special method lookup for new-style classes
* 4. Execution model
* 4.1. Naming and binding
* 4.1.1. Interaction with dynamic features
* 4.2. Exceptions
* 5. Expressions
* 5.1. Arithmetic conversions
* 5.2. Atoms
* 5.2.1. Identifiers (Names)
* 5.2.2. Literals
* 5.2.3. Parenthesized forms
* 5.2.4. List displays
* 5.2.5. Displays for sets and dictionaries
* 5.2.6. Generator expressions
* 5.2.7. Dictionary displays
* 5.2.8. Set displays
* 5.2.9. String conversions
* 5.2.10. Yield expressions
* 5.2.10.1. Generator-iterator methods
* 5.3. Primaries
* 5.3.1. Attribute references
* 5.3.2. Subscriptions
* 5.3.3. Slicings
* 5.3.4. Calls
* 5.4. The power operator
* 5.5. Unary arithmetic and bitwise operations
* 5.6. Binary arithmetic operations
* 5.7. Shifting operations
* 5.8. Binary bitwise operations
* 5.9. Comparisons
* 5.9.1. Value comparisons
* 5.9.2. Membership test operations
* 5.9.3. Identity comparisons
* 5.10. Boolean operations
* 5.11. Conditional Expressions
* 5.12. Lambdas
* 5.13. Expression lists
* 5.14. Evaluation order
* 5.15. Operator precedence
* 6. Simple statements
* 6.1. Expression statements
* 6.2. Assignment statements
* 6.2.1. Augmented assignment statements
* 6.3. The "assert" statement
* 6.4. The "pass" statement
* 6.5. The "del" statement
* 6.6. The "print" statement
* 6.7. The "return" statement
* 6.8. The "yield" statement
* 6.9. The "raise" statement
* 6.10. The "break" statement
* 6.11. The "continue" statement
* 6.12. The "import" statement
* 6.12.1. Future statements
* 6.13. The "global" statement
* 6.14. The "exec" statement
* 7. Compound statements
* 7.1. The "if" statement
* 7.2. The "while" statement
* 7.3. The "for" statement
* 7.4. The "try" statement
* 7.5. The "with" statement
* 7.6. Function definitions
* 7.7. Class definitions
* 8. Top-level components
* 8.1. Complete Python programs
* 8.2. File input
* 8.3. Interactive input
* 8.4. Expression input
* 9. Full Grammar specification
* The Python Standard Library
* 1. Introduction
* 2. Built-in Functions
* 3. Non-essential Built-in Functions
* 4. Built-in Constants
* 4.1. Constants added by the "site" module
* 5. Built-in Types
* 5.1. Truth Value Testing
* 5.2. Boolean Operations — "and", "or", "not"
* 5.3. Comparisons
* 5.4. Numeric Types — "int", "float", "long", "complex"
* 5.4.1. Bitwise Operations on Integer Types
* 5.4.2. Additional Methods on Integer Types
* 5.4.3. Additional Methods on Float
* 5.5. Iterator Types
* 5.5.1. Generator Types
* 5.6. Sequence Types — "str", "unicode", "list", "tuple",
"bytearray", "buffer", "xrange"
* 5.6.1. String Methods
* 5.6.2. String Formatting Operations
* 5.6.3. XRange Type
* 5.6.4. Mutable Sequence Types
* 5.7. Set Types — "set", "frozenset"
* 5.8. Mapping Types — "dict"
* 5.8.1. Dictionary view objects
* 5.9. File Objects
* 5.10. memoryview type
* 5.11. Context Manager Types
* 5.12. Other Built-in Types
* 5.12.1. Modules
* 5.12.2. Classes and Class Instances
* 5.12.3. Functions
* 5.12.4. Methods
* 5.12.5. Code Objects
* 5.12.6. Type Objects
* 5.12.7. The Null Object
* 5.12.8. The Ellipsis Object
* 5.12.9. The NotImplemented Object
* 5.12.10. Boolean Values
* 5.12.11. Internal Objects
* 5.13. Special Attributes
* 6. Built-in Exceptions
* 6.1. Exception hierarchy
* 7. String Services
* 7.1. "string" — Common string operations
* 7.1.1. String constants
* 7.1.2. Custom String Formatting
* 7.1.3. Format String Syntax
* 7.1.3.1. Format Specification Mini-Language
* 7.1.3.2. Format examples
* 7.1.4. Template strings
* 7.1.5. String functions
* 7.1.6. Deprecated string functions
* 7.2. "re" — Regular expression operations
* 7.2.1. Regular Expression Syntax
* 7.2.2. Module Contents
* 7.2.3. Regular Expression Objects
* 7.2.4. Match Objects
* 7.2.5. Examples
* 7.2.5.1. Checking For a Pair
* 7.2.5.2. Simulating scanf()
* 7.2.5.3. search() vs. match()
* 7.2.5.4. Making a Phonebook
* 7.2.5.5. Text Munging
* 7.2.5.6. Finding all Adverbs
* 7.2.5.7. Finding all Adverbs and their Positions
* 7.2.5.8. Raw String Notation
* 7.3. "struct" — Interpret strings as packed binary data
* 7.3.1. Functions and Exceptions
* 7.3.2. Format Strings
* 7.3.2.1. Byte Order, Size, and Alignment
* 7.3.2.2. Format Characters
* 7.3.2.3. Examples
* 7.3.3. Classes
* 7.4. "difflib" — Helpers for computing deltas
* 7.4.1. SequenceMatcher Objects
* 7.4.2. SequenceMatcher Examples
* 7.4.3. Differ Objects
* 7.4.4. Differ Example
* 7.4.5. A command-line interface to difflib
* 7.5. "StringIO" — Read and write strings as files
* 7.6. "cStringIO" — Faster version of "StringIO"
* 7.7. "textwrap" — Text wrapping and filling
* 7.8. "codecs" — Codec registry and base classes
* 7.8.1. Codec Base Classes
* 7.8.1.1. Codec Objects
* 7.8.1.2. IncrementalEncoder Objects
* 7.8.1.3. IncrementalDecoder Objects
* 7.8.1.4. StreamWriter Objects
* 7.8.1.5. StreamReader Objects
* 7.8.1.6. StreamReaderWriter Objects
* 7.8.1.7. StreamRecoder Objects
* 7.8.2. Encodings and Unicode
* 7.8.3. Standard Encodings
* 7.8.4. Python Specific Encodings
* 7.8.5. "encodings.idna" — Internationalized Domain Names in
Applications
* 7.8.6. "encodings.utf_8_sig" — UTF-8 codec with BOM
signature
* 7.9. "unicodedata" — Unicode Database
* 7.10. "stringprep" — Internet String Preparation
* 7.11. "fpformat" — Floating point conversions
* 8. Data Types
* 8.1. "datetime" — Basic date and time types
* 8.1.1. Available Types
* 8.1.2. "timedelta" Objects
* 8.1.3. "date" Objects
* 8.1.4. "datetime" Objects
* 8.1.5. "time" Objects
* 8.1.6. "tzinfo" Objects
* 8.1.7. "strftime()" and "strptime()" Behavior
* 8.2. "calendar" — General calendar-related functions
* 8.3. "collections" — High-performance container datatypes
* 8.3.1. "Counter" objects
* 8.3.2. "deque" objects
* 8.3.2.1. "deque" Recipes
* 8.3.3. "defaultdict" objects
* 8.3.3.1. "defaultdict" Examples
* 8.3.4. "namedtuple()" Factory Function for Tuples with Named
Fields
* 8.3.5. "OrderedDict" objects
* 8.3.5.1. "OrderedDict" Examples and Recipes
* 8.3.6. Collections Abstract Base Classes
* 8.4. "heapq" — Heap queue algorithm
* 8.4.1. Basic Examples
* 8.4.2. Priority Queue Implementation Notes
* 8.4.3. Theory
* 8.5. "bisect" — Array bisection algorithm
* 8.5.1. Searching Sorted Lists
* 8.5.2. Other Examples
* 8.6. "array" — Efficient arrays of numeric values
* 8.7. "sets" — Unordered collections of unique elements
* 8.7.1. Set Objects
* 8.7.2. Example
* 8.7.3. Protocol for automatic conversion to immutable
* 8.7.4. Comparison to the built-in "set" types
* 8.8. "sched" — Event scheduler
* 8.8.1. Scheduler Objects
* 8.9. "mutex" — Mutual exclusion support
* 8.9.1. Mutex Objects
* 8.10. "Queue" — A synchronized queue class
* 8.10.1. Queue Objects
* 8.11. "weakref" — Weak references
* 8.11.1. Weak Reference Objects
* 8.11.2. Example
* 8.12. "UserDict" — Class wrapper for dictionary objects
* 8.13. "UserList" — Class wrapper for list objects
* 8.14. "UserString" — Class wrapper for string objects
* 8.15. "types" — Names for built-in types
* 8.16. "new" — Creation of runtime internal objects
* 8.17. "copy" — Shallow and deep copy operations
* 8.18. "pprint" — Data pretty printer
* 8.18.1. PrettyPrinter Objects
* 8.18.2. pprint Example
* 8.19. "repr" — Alternate "repr()" implementation
* 8.19.1. Repr Objects
* 8.19.2. Subclassing Repr Objects
* 9. Numeric and Mathematical Modules
* 9.1. "numbers" — Numeric abstract base classes
* 9.1.1. The numeric tower
* 9.1.2. Notes for type implementors
* 9.1.2.1. Adding More Numeric ABCs
* 9.1.2.2. Implementing the arithmetic operations
* 9.2. "math" — Mathematical functions
* 9.2.1. Number-theoretic and representation functions
* 9.2.2. Power and logarithmic functions
* 9.2.3. Trigonometric functions
* 9.2.4. Angular conversion
* 9.2.5. Hyperbolic functions
* 9.2.6. Special functions
* 9.2.7. Constants
* 9.3. "cmath" — Mathematical functions for complex numbers
* 9.3.1. Conversions to and from polar coordinates
* 9.3.2. Power and logarithmic functions
* 9.3.3. Trigonometric functions
* 9.3.4. Hyperbolic functions
* 9.3.5. Classification functions
* 9.3.6. Constants
* 9.4. "decimal" — Decimal fixed point and floating point
arithmetic
* 9.4.1. Quick-start Tutorial
* 9.4.2. Decimal objects
* 9.4.2.1. Logical operands
* 9.4.3. Context objects
* 9.4.4. Signals
* 9.4.5. Floating Point Notes
* 9.4.5.1. Mitigating round-off error with increased
precision
* 9.4.5.2. Special values
* 9.4.6. Working with threads
* 9.4.7. Recipes
* 9.4.8. Decimal FAQ
* 9.5. "fractions" — Rational numbers
* 9.6. "random" — Generate pseudo-random numbers
* 9.7. "itertools" — Functions creating iterators for efficient
looping
* 9.7.1. Itertool functions
* 9.7.2. Recipes
* 9.8. "functools" — Higher-order functions and operations on
callable objects
* 9.8.1. "partial" Objects
* 9.9. "operator" — Standard operators as functions
* 9.9.1. Mapping Operators to Functions
* 10. File and Directory Access
* 10.1. "os.path" — Common pathname manipulations
* 10.2. "fileinput" — Iterate over lines from multiple input
streams
* 10.3. "stat" — Interpreting "stat()" results
* 10.4. "statvfs" — Constants used with "os.statvfs()"
* 10.5. "filecmp" — File and Directory Comparisons
* 10.5.1. The "dircmp" class
* 10.6. "tempfile" — Generate temporary files and directories
* 10.7. "glob" — Unix style pathname pattern expansion
* 10.8. "fnmatch" — Unix filename pattern matching
* 10.9. "linecache" — Random access to text lines
* 10.10. "shutil" — High-level file operations
* 10.10.1. Directory and files operations
* 10.10.1.1. copytree example
* 10.10.2. Archiving operations
* 10.10.2.1. Archiving example
* 10.11. "dircache" — Cached directory listings
* 10.12. "macpath" — Mac OS 9 path manipulation functions
* 11. Data Persistence
* 11.1. "pickle" — Python object serialization
* 11.1.1. Relationship to other Python modules
* 11.1.2. Data stream format
* 11.1.3. Usage
* 11.1.4. What can be pickled and unpickled?
* 11.1.5. The pickle protocol
* 11.1.5.1. Pickling and unpickling normal class instances
* 11.1.5.2. Pickling and unpickling extension types
* 11.1.5.3. Pickling and unpickling external objects
* 11.1.6. Subclassing Unpicklers
* 11.1.7. Example
* 11.2. "cPickle" — A faster "pickle"
* 11.3. "copy_reg" — Register "pickle" support functions
* 11.3.1. Example
* 11.4. "shelve" — Python object persistence
* 11.4.1. Restrictions
* 11.4.2. Example
* 11.5. "marshal" — Internal Python object serialization
* 11.6. "anydbm" — Generic access to DBM-style databases
* 11.7. "whichdb" — Guess which DBM module created a database
* 11.8. "dbm" — Simple “database” interface
* 11.9. "gdbm" — GNU’s reinterpretation of dbm
* 11.10. "dbhash" — DBM-style interface to the BSD database
library
* 11.10.1. Database Objects
* 11.11. "bsddb" — Interface to Berkeley DB library
* 11.11.1. Hash, BTree and Record Objects
* 11.12. "dumbdbm" — Portable DBM implementation
* 11.12.1. Dumbdbm Objects
* 11.13. "sqlite3" — DB-API 2.0 interface for SQLite databases
* 11.13.1. Module functions and constants
* 11.13.2. Connection Objects
* 11.13.3. Cursor Objects
* 11.13.4. Row Objects
* 11.13.5. SQLite and Python types
* 11.13.5.1. Introduction
* 11.13.5.2. Using adapters to store additional Python types
in SQLite databases
* 11.13.5.2.1. Letting your object adapt itself
* 11.13.5.2.2. Registering an adapter callable
* 11.13.5.3. Converting SQLite values to custom Python types
* 11.13.5.4. Default adapters and converters
* 11.13.6. Controlling Transactions
* 11.13.7. Using "sqlite3" efficiently
* 11.13.7.1. Using shortcut methods
* 11.13.7.2. Accessing columns by name instead of by index
* 11.13.7.3. Using the connection as a context manager
* 11.13.8. Common issues
* 11.13.8.1. Multithreading
* 12. Data Compression and Archiving
* 12.1. "zlib" — Compression compatible with **gzip**
* 12.2. "gzip" — Support for **gzip** files
* 12.2.1. Examples of usage
* 12.3. "bz2" — Compression compatible with **bzip2**
* 12.3.1. (De)compression of files
* 12.3.2. Sequential (de)compression
* 12.3.3. One-shot (de)compression
* 12.4. "zipfile" — Work with ZIP archives
* 12.4.1. ZipFile Objects
* 12.4.2. PyZipFile Objects
* 12.4.3. ZipInfo Objects
* 12.4.4. Command-Line Interface
* 12.4.4.1. Command-line options
* 12.5. "tarfile" — Read and write tar archive files
* 12.5.1. TarFile Objects
* 12.5.2. TarInfo Objects
* 12.5.3. Examples
* 12.5.4. Supported tar formats
* 12.5.5. Unicode issues
* 13. File Formats
* 13.1. "csv" — CSV File Reading and Writing
* 13.1.1. Module Contents
* 13.1.2. Dialects and Formatting Parameters
* 13.1.3. Reader Objects
* 13.1.4. Writer Objects
* 13.1.5. Examples
* 13.2. "ConfigParser" — Configuration file parser
* 13.2.1. RawConfigParser Objects
* 13.2.2. ConfigParser Objects
* 13.2.3. SafeConfigParser Objects
* 13.2.4. Examples
* 13.3. "robotparser" — Parser for robots.txt
* 13.4. "netrc" — netrc file processing
* 13.4.1. netrc Objects
* 13.5. "xdrlib" — Encode and decode XDR data
* 13.5.1. Packer Objects
* 13.5.2. Unpacker Objects
* 13.5.3. Exceptions
* 13.6. "plistlib" — Generate and parse Mac OS X ".plist" files
* 13.6.1. Examples
* 14. Cryptographic Services
* 14.1. "hashlib" — Secure hashes and message digests
* 14.1.1. Key derivation
* 14.2. "hmac" — Keyed-Hashing for Message Authentication
* 14.3. "md5" — MD5 message digest algorithm
* 14.4. "sha" — SHA-1 message digest algorithm
* 15. Generic Operating System Services
* 15.1. "os" — Miscellaneous operating system interfaces
* 15.1.1. Process Parameters
* 15.1.2. File Object Creation
* 15.1.3. File Descriptor Operations
* 15.1.3.1. "open()" flag constants
* 15.1.4. Files and Directories
* 15.1.5. Process Management
* 15.1.6. Miscellaneous System Information
* 15.1.7. Miscellaneous Functions
* 15.2. "io" — Core tools for working with streams
* 15.2.1. Module Interface
* 15.2.2. I/O Base Classes
* 15.2.3. Raw File I/O
* 15.2.4. Buffered Streams
* 15.2.5. Text I/O
* 15.2.6. Advanced topics
* 15.2.6.1. Performance
* 15.2.6.1.1. Binary I/O
* 15.2.6.1.2. Text I/O
* 15.2.6.2. Multi-threading
* 15.2.6.3. Reentrancy
* 15.3. "time" — Time access and conversions
* 15.4. "argparse" — Parser for command-line options, arguments
and sub-commands
* 15.4.1. Example
* 15.4.1.1. Creating a parser
* 15.4.1.2. Adding arguments
* 15.4.1.3. Parsing arguments
* 15.4.2. ArgumentParser objects
* 15.4.2.1. prog
* 15.4.2.2. usage
* 15.4.2.3. description
* 15.4.2.4. epilog
* 15.4.2.5. parents
* 15.4.2.6. formatter_class
* 15.4.2.7. prefix_chars
* 15.4.2.8. fromfile_prefix_chars
* 15.4.2.9. argument_default
* 15.4.2.10. conflict_handler
* 15.4.2.11. add_help
* 15.4.3. The add_argument() method
* 15.4.3.1. name or flags
* 15.4.3.2. action
* 15.4.3.3. nargs
* 15.4.3.4. const
* 15.4.3.5. default
* 15.4.3.6. type
* 15.4.3.7. choices
* 15.4.3.8. required
* 15.4.3.9. help
* 15.4.3.10. metavar
* 15.4.3.11. dest
* 15.4.3.12. Action classes
* 15.4.4. The parse_args() method
* 15.4.4.1. Option value syntax
* 15.4.4.2. Invalid arguments
* 15.4.4.3. Arguments containing "-"
* 15.4.4.4. Argument abbreviations (prefix matching)
* 15.4.4.5. Beyond "sys.argv"
* 15.4.4.6. The Namespace object
* 15.4.5. Other utilities
* 15.4.5.1. Sub-commands
* 15.4.5.2. FileType objects
* 15.4.5.3. Argument groups
* 15.4.5.4. Mutual exclusion
* 15.4.5.5. Parser defaults
* 15.4.5.6. Printing help
* 15.4.5.7. Partial parsing
* 15.4.5.8. Customizing file parsing
* 15.4.5.9. Exiting methods
* 15.4.6. Upgrading optparse code
* 15.5. "optparse" — Parser for command line options
* 15.5.1. Background
* 15.5.1.1. Terminology
* 15.5.1.2. What are options for?
* 15.5.1.3. What are positional arguments for?
* 15.5.2. Tutorial
* 15.5.2.1. Understanding option actions
* 15.5.2.2. The store action
* 15.5.2.3. Handling boolean (flag) options
* 15.5.2.4. Other actions
* 15.5.2.5. Default values
* 15.5.2.6. Generating help
* 15.5.2.6.1. Grouping Options
* 15.5.2.7. Printing a version string
* 15.5.2.8. How "optparse" handles errors
* 15.5.2.9. Putting it all together
* 15.5.3. Reference Guide
* 15.5.3.1. Creating the parser
* 15.5.3.2. Populating the parser
* 15.5.3.3. Defining options
* 15.5.3.4. Option attributes
* 15.5.3.5. Standard option actions
* 15.5.3.6. Standard option types
* 15.5.3.7. Parsing arguments
* 15.5.3.8. Querying and manipulating your option parser
* 15.5.3.9. Conflicts between options
* 15.5.3.10. Cleanup
* 15.5.3.11. Other methods
* 15.5.4. Option Callbacks
* 15.5.4.1. Defining a callback option
* 15.5.4.2. How callbacks are called
* 15.5.4.3. Raising errors in a callback
* 15.5.4.4. Callback example 1: trivial callback
* 15.5.4.5. Callback example 2: check option order
* 15.5.4.6. Callback example 3: check option order
(generalized)
* 15.5.4.7. Callback example 4: check arbitrary condition
* 15.5.4.8. Callback example 5: fixed arguments
* 15.5.4.9. Callback example 6: variable arguments
* 15.5.5. Extending "optparse"
* 15.5.5.1. Adding new types
* 15.5.5.2. Adding new actions
* 15.6. "getopt" — C-style parser for command line options
* 15.7. "logging" — Logging facility for Python
* 15.7.1. Logger Objects
* 15.7.2. Logging Levels
* 15.7.3. Handler Objects
* 15.7.4. Formatter Objects
* 15.7.5. Filter Objects
* 15.7.6. LogRecord Objects
* 15.7.7. LogRecord attributes
* 15.7.8. LoggerAdapter Objects
* 15.7.9. Thread Safety
* 15.7.10. Module-Level Functions
* 15.7.11. Integration with the warnings module
* 15.8. "logging.config" — Logging configuration
* 15.8.1. Configuration functions
* 15.8.2. Configuration dictionary schema
* 15.8.2.1. Dictionary Schema Details
* 15.8.2.2. Incremental Configuration
* 15.8.2.3. Object connections
* 15.8.2.4. User-defined objects
* 15.8.2.5. Access to external objects
* 15.8.2.6. Access to internal objects
* 15.8.2.7. Import resolution and custom importers
* 15.8.3. Configuration file format
* 15.9. "logging.handlers" — Logging handlers
* 15.9.1. StreamHandler
* 15.9.2. FileHandler
* 15.9.3. NullHandler
* 15.9.4. WatchedFileHandler
* 15.9.5. RotatingFileHandler
* 15.9.6. TimedRotatingFileHandler
* 15.9.7. SocketHandler
* 15.9.8. DatagramHandler
* 15.9.9. SysLogHandler
* 15.9.10. NTEventLogHandler
* 15.9.11. SMTPHandler
* 15.9.12. MemoryHandler
* 15.9.13. HTTPHandler
* 15.10. "getpass" — Portable password input
* 15.11. "curses" — Terminal handling for character-cell
displays
* 15.11.1. Functions
* 15.11.2. Window Objects
* 15.11.3. Constants
* 15.12. "curses.textpad" — Text input widget for curses
programs
* 15.12.1. Textbox objects
* 15.13. "curses.ascii" — Utilities for ASCII characters
* 15.14. "curses.panel" — A panel stack extension for curses
* 15.14.1. Functions
* 15.14.2. Panel Objects
* 15.15. "platform" — Access to underlying platform’s
identifying data
* 15.15.1. Cross Platform
* 15.15.2. Java Platform
* 15.15.3. Windows Platform
* 15.15.3.1. Win95/98 specific
* 15.15.4. Mac OS Platform
* 15.15.5. Unix Platforms
* 15.16. "errno" — Standard errno system symbols
* 15.17. "ctypes" — A foreign function library for Python
* 15.17.1. ctypes tutorial
* 15.17.1.1. Loading dynamic link libraries
* 15.17.1.2. Accessing functions from loaded dlls
* 15.17.1.3. Calling functions
* 15.17.1.4. Fundamental data types
* 15.17.1.5. Calling functions, continued
* 15.17.1.6. Calling functions with your own custom data
types
* 15.17.1.7. Specifying the required argument types
(function prototypes)
* 15.17.1.8. Return types
* 15.17.1.9. Passing pointers (or: passing parameters by
reference)
* 15.17.1.10. Structures and unions
* 15.17.1.11. Structure/union alignment and byte order
* 15.17.1.12. Bit fields in structures and unions
* 15.17.1.13. Arrays
* 15.17.1.14. Pointers
* 15.17.1.15. Type conversions
* 15.17.1.16. Incomplete Types
* 15.17.1.17. Callback functions
* 15.17.1.18. Accessing values exported from dlls
* 15.17.1.19. Surprises
* 15.17.1.20. Variable-sized data types
* 15.17.2. ctypes reference
* 15.17.2.1. Finding shared libraries
* 15.17.2.2. Loading shared libraries
* 15.17.2.3. Foreign functions
* 15.17.2.4. Function prototypes
* 15.17.2.5. Utility functions
* 15.17.2.6. Data types
* 15.17.2.7. Fundamental data types
* 15.17.2.8. Structured data types
* 15.17.2.9. Arrays and pointers
* 16. Optional Operating System Services
* 16.1. "select" — Waiting for I/O completion
* 16.1.1. Edge and Level Trigger Polling (epoll) Objects
* 16.1.2. Polling Objects
* 16.1.3. Kqueue Objects
* 16.1.4. Kevent Objects
* 16.2. "threading" — Higher-level threading interface
* 16.2.1. Thread Objects
* 16.2.2. Lock Objects
* 16.2.3. RLock Objects
* 16.2.4. Condition Objects
* 16.2.5. Semaphore Objects
* 16.2.5.1. "Semaphore" Example
* 16.2.6. Event Objects
* 16.2.7. Timer Objects
* 16.2.8. Using locks, conditions, and semaphores in the
"with" statement
* 16.2.9. Importing in threaded code
* 16.3. "thread" — Multiple threads of control
* 16.4. "dummy_threading" — Drop-in replacement for the
"threading" module
* 16.5. "dummy_thread" — Drop-in replacement for the "thread"
module
* 16.6. "multiprocessing" — Process-based “threading” interface
* 16.6.1. Introduction
* 16.6.1.1. The "Process" class
* 16.6.1.2. Exchanging objects between processes
* 16.6.1.3. Synchronization between processes
* 16.6.1.4. Sharing state between processes
* 16.6.1.5. Using a pool of workers
* 16.6.2. Reference
* 16.6.2.1. "Process" and exceptions
* 16.6.2.2. Pipes and Queues
* 16.6.2.3. Miscellaneous
* 16.6.2.4. Connection Objects
* 16.6.2.5. Synchronization primitives
* 16.6.2.6. Shared "ctypes" Objects
* 16.6.2.6.1. The "multiprocessing.sharedctypes" module
* 16.6.2.7. Managers
* 16.6.2.7.1. Customized managers
* 16.6.2.7.2. Using a remote manager
* 16.6.2.8. Proxy Objects
* 16.6.2.8.1. Cleanup
* 16.6.2.9. Process Pools
* 16.6.2.10. Listeners and Clients
* 16.6.2.10.1. Address Formats
* 16.6.2.11. Authentication keys
* 16.6.2.12. Logging
* 16.6.2.13. The "multiprocessing.dummy" module
* 16.6.3. Programming guidelines
* 16.6.3.1. All platforms
* 16.6.3.2. Windows
* 16.6.4. Examples
* 16.7. "mmap" — Memory-mapped file support
* 16.8. "readline" — GNU readline interface
* 16.8.1. Init file
* 16.8.2. Line buffer
* 16.8.3. History file
* 16.8.4. History list
* 16.8.5. Startup hooks
* 16.8.6. Completion
* 16.8.7. Example
* 16.9. "rlcompleter" — Completion function for GNU readline
* 16.9.1. Completer Objects
* 17. Interprocess Communication and Networking
* 17.1. "subprocess" — Subprocess management
* 17.1.1. Using the "subprocess" Module
* 17.1.1.1. Frequently Used Arguments
* 17.1.1.2. Popen Constructor
* 17.1.1.3. Exceptions
* 17.1.1.4. Security
* 17.1.2. Popen Objects
* 17.1.3. Windows Popen Helpers
* 17.1.3.1. Constants
* 17.1.4. Replacing Older Functions with the "subprocess"
Module
* 17.1.4.1. Replacing /bin/sh shell backquote
* 17.1.4.2. Replacing shell pipeline
* 17.1.4.3. Replacing "os.system()"
* 17.1.4.4. Replacing the "os.spawn" family
* 17.1.4.5. Replacing "os.popen()", "os.popen2()",
"os.popen3()"
* 17.1.4.6. Replacing functions from the "popen2" module
* 17.1.5. Notes
* 17.1.5.1. Converting an argument sequence to a string on
Windows
* 17.2. "socket" — Low-level networking interface
* 17.2.1. Socket Objects
* 17.2.2. Example
* 17.3. "ssl" — TLS/SSL wrapper for socket objects
* 17.3.1. Functions, Constants, and Exceptions
* 17.3.1.1. Socket creation
* 17.3.1.2. Context creation
* 17.3.1.3. Random generation
* 17.3.1.4. Certificate handling
* 17.3.1.5. Constants
* 17.3.2. SSL Sockets
* 17.3.3. SSL Contexts
* 17.3.4. Certificates
* 17.3.4.1. Certificate chains
* 17.3.4.2. CA certificates
* 17.3.4.3. Combined key and certificate
* 17.3.4.4. Self-signed certificates
* 17.3.5. Examples
* 17.3.5.1. Testing for SSL support
* 17.3.5.2. Client-side operation
* 17.3.5.3. Server-side operation
* 17.3.6. Notes on non-blocking sockets
* 17.3.7. Security considerations
* 17.3.7.1. Best defaults
* 17.3.7.2. Manual settings
* 17.3.7.2.1. Verifying certificates
* 17.3.7.2.2. Protocol versions
* 17.3.7.2.3. Cipher selection
* 17.3.7.3. Multi-processing
* 17.3.8. LibreSSL support
* 17.4. "signal" — Set handlers for asynchronous events
* 17.4.1. Example
* 17.5. "popen2" — Subprocesses with accessible I/O streams
* 17.5.1. Popen3 and Popen4 Objects
* 17.5.2. Flow Control Issues
* 17.6. "asyncore" — Asynchronous socket handler
* 17.6.1. asyncore Example basic HTTP client
* 17.6.2. asyncore Example basic echo server
* 17.7. "asynchat" — Asynchronous socket command/response
handler
* 17.7.1. asynchat - Auxiliary Classes
* 17.7.2. asynchat Example
* 18. Internet Data Handling
* 18.1. "email" — An email and MIME handling package
* 18.1.1. "email.message": Representing an email message
* 18.1.2. "email.parser": Parsing email messages
* 18.1.2.1. FeedParser API
* 18.1.2.2. Parser class API
* 18.1.2.3. Additional notes
* 18.1.3. "email.generator": Generating MIME documents
* 18.1.4. "email.mime": Creating email and MIME objects from
scratch
* 18.1.5. "email.header": Internationalized headers
* 18.1.6. "email.charset": Representing character sets
* 18.1.7. "email.encoders": Encoders
* 18.1.8. "email.errors": Exception and Defect classes
* 18.1.9. "email.utils": Miscellaneous utilities
* 18.1.10. "email.iterators": Iterators
* 18.1.11. "email": Examples
* 18.1.12. Package History
* 18.1.13. Differences from "mimelib"
* 18.2. "json" — JSON encoder and decoder
* 18.2.1. Basic Usage
* 18.2.2. Encoders and Decoders
* 18.2.3. Standard Compliance and Interoperability
* 18.2.3.1. Character Encodings
* 18.2.3.2. Infinite and NaN Number Values
* 18.2.3.3. Repeated Names Within an Object
* 18.2.3.4. Top-level Non-Object, Non-Array Values
* 18.2.3.5. Implementation Limitations
* 18.3. "mailcap" — Mailcap file handling
* 18.4. "mailbox" — Manipulate mailboxes in various formats
* 18.4.1. "Mailbox" objects
* 18.4.1.1. "Maildir"
* 18.4.1.2. "mbox"
* 18.4.1.3. "MH"
* 18.4.1.4. "Babyl"
* 18.4.1.5. "MMDF"
* 18.4.2. "Message" objects
* 18.4.2.1. "MaildirMessage"
* 18.4.2.2. "mboxMessage"
* 18.4.2.3. "MHMessage"
* 18.4.2.4. "BabylMessage"
* 18.4.2.5. "MMDFMessage"
* 18.4.3. Exceptions
* 18.4.4. Deprecated classes and methods
* 18.4.5. Examples
* 18.5. "mhlib" — Access to MH mailboxes
* 18.5.1. MH Objects
* 18.5.2. Folder Objects
* 18.5.3. Message Objects
* 18.6. "mimetools" — Tools for parsing MIME messages
* 18.6.1. Additional Methods of Message Objects
* 18.7. "mimetypes" — Map filenames to MIME types
* 18.7.1. MimeTypes Objects
* 18.8. "MimeWriter" — Generic MIME file writer
* 18.8.1. MimeWriter Objects
* 18.9. "mimify" — MIME processing of mail messages
* 18.10. "multifile" — Support for files containing distinct
parts
* 18.10.1. MultiFile Objects
* 18.10.2. "MultiFile" Example
* 18.11. "rfc822" — Parse RFC 2822 mail headers
* 18.11.1. Message Objects
* 18.11.2. AddressList Objects
* 18.12. "base64" — RFC 3548: Base16, Base32, Base64 Data
Encodings
* 18.13. "binhex" — Encode and decode binhex4 files
* 18.13.1. Notes
* 18.14. "binascii" — Convert between binary and ASCII
* 18.15. "quopri" — Encode and decode MIME quoted-printable data
* 18.16. "uu" — Encode and decode uuencode files
* 19. Structured Markup Processing Tools
* 19.1. "HTMLParser" — Simple HTML and XHTML parser
* 19.1.1. Example HTML Parser Application
* 19.1.2. "HTMLParser" Methods
* 19.1.3. Examples
* 19.2. "sgmllib" — Simple SGML parser
* 19.3. "htmllib" — A parser for HTML documents
* 19.3.1. HTMLParser Objects
* 19.4. "htmlentitydefs" — Definitions of HTML general entities
* 19.5. XML Processing Modules
* 19.6. XML vulnerabilities
* 19.6.1. defused packages
* 19.7. "xml.etree.ElementTree" — The ElementTree XML API
* 19.7.1. Tutorial
* 19.7.1.1. XML tree and elements
* 19.7.1.2. Parsing XML
* 19.7.1.3. Finding interesting elements
* 19.7.1.4. Modifying an XML File
* 19.7.1.5. Building XML documents
* 19.7.1.6. Parsing XML with Namespaces
* 19.7.1.7. Additional resources
* 19.7.2. XPath support
* 19.7.2.1. Example
* 19.7.2.2. Supported XPath syntax
* 19.7.3. Reference
* 19.7.3.1. Functions
* 19.7.3.2. Element Objects
* 19.7.3.3. ElementTree Objects
* 19.7.3.4. QName Objects
* 19.7.3.5. TreeBuilder Objects
* 19.7.3.6. XMLParser Objects
* 19.8. "xml.dom" — The Document Object Model API
* 19.8.1. Module Contents
* 19.8.2. Objects in the DOM
* 19.8.2.1. DOMImplementation Objects
* 19.8.2.2. Node Objects
* 19.8.2.3. NodeList Objects
* 19.8.2.4. DocumentType Objects
* 19.8.2.5. Document Objects
* 19.8.2.6. Element Objects
* 19.8.2.7. Attr Objects
* 19.8.2.8. NamedNodeMap Objects
* 19.8.2.9. Comment Objects
* 19.8.2.10. Text and CDATASection Objects
* 19.8.2.11. ProcessingInstruction Objects
* 19.8.2.12. Exceptions
* 19.8.3. Conformance
* 19.8.3.1. Type Mapping
* 19.8.3.2. Accessor Methods
* 19.9. "xml.dom.minidom" — Minimal DOM implementation
* 19.9.1. DOM Objects
* 19.9.2. DOM Example
* 19.9.3. minidom and the DOM standard
* 19.10. "xml.dom.pulldom" — Support for building partial DOM
trees
* 19.10.1. DOMEventStream Objects
* 19.11. "xml.sax" — Support for SAX2 parsers
* 19.11.1. SAXException Objects
* 19.12. "xml.sax.handler" — Base classes for SAX handlers
* 19.12.1. ContentHandler Objects
* 19.12.2. DTDHandler Objects
* 19.12.3. EntityResolver Objects
* 19.12.4. ErrorHandler Objects
* 19.13. "xml.sax.saxutils" — SAX Utilities
* 19.14. "xml.sax.xmlreader" — Interface for XML parsers
* 19.14.1. XMLReader Objects
* 19.14.2. IncrementalParser Objects
* 19.14.3. Locator Objects
* 19.14.4. InputSource Objects
* 19.14.5. The "Attributes" Interface
* 19.14.6. The "AttributesNS" Interface
* 19.15. "xml.parsers.expat" — Fast XML parsing using Expat
* 19.15.1. XMLParser Objects
* 19.15.2. ExpatError Exceptions
* 19.15.3. Example
* 19.15.4. Content Model Descriptions
* 19.15.5. Expat error constants
* 20. Internet Protocols and Support
* 20.1. "webbrowser" — Convenient Web-browser controller
* 20.1.1. Browser Controller Objects
* 20.2. "cgi" — Common Gateway Interface support
* 20.2.1. Introduction
* 20.2.2. Using the cgi module
* 20.2.3. Higher Level Interface
* 20.2.4. Old classes
* 20.2.5. Functions
* 20.2.6. Caring about security
* 20.2.7. Installing your CGI script on a Unix system
* 20.2.8. Testing your CGI script
* 20.2.9. Debugging CGI scripts
* 20.2.10. Common problems and solutions
* 20.3. "cgitb" — Traceback manager for CGI scripts
* 20.4. "wsgiref" — WSGI Utilities and Reference Implementation
* 20.4.1. "wsgiref.util" – WSGI environment utilities
* 20.4.2. "wsgiref.headers" – WSGI response header tools
* 20.4.3. "wsgiref.simple_server" – a simple WSGI HTTP server
* 20.4.4. "wsgiref.validate" — WSGI conformance checker
* 20.4.5. "wsgiref.handlers" – server/gateway base classes
* 20.4.6. Examples
* 20.5. "urllib" — Open arbitrary resources by URL
* 20.5.1. High-level interface
* 20.5.2. Utility functions
* 20.5.3. URL Opener objects
* 20.5.4. "urllib" Restrictions
* 20.5.5. Examples
* 20.6. "urllib2" — extensible library for opening URLs
* 20.6.1. Request Objects
* 20.6.2. OpenerDirector Objects
* 20.6.3. BaseHandler Objects
* 20.6.4. HTTPRedirectHandler Objects
* 20.6.5. HTTPCookieProcessor Objects
* 20.6.6. ProxyHandler Objects
* 20.6.7. HTTPPasswordMgr Objects
* 20.6.8. AbstractBasicAuthHandler Objects
* 20.6.9. HTTPBasicAuthHandler Objects
* 20.6.10. ProxyBasicAuthHandler Objects
* 20.6.11. AbstractDigestAuthHandler Objects
* 20.6.12. HTTPDigestAuthHandler Objects
* 20.6.13. ProxyDigestAuthHandler Objects
* 20.6.14. HTTPHandler Objects
* 20.6.15. HTTPSHandler Objects
* 20.6.16. FileHandler Objects
* 20.6.17. FTPHandler Objects
* 20.6.18. CacheFTPHandler Objects
* 20.6.19. UnknownHandler Objects
* 20.6.20. HTTPErrorProcessor Objects
* 20.6.21. Examples
* 20.7. "httplib" — HTTP protocol client
* 20.7.1. HTTPConnection Objects
* 20.7.2. HTTPResponse Objects
* 20.7.3. Examples
* 20.8. "ftplib" — FTP protocol client
* 20.8.1. FTP Objects
* 20.8.2. FTP_TLS Objects
* 20.9. "poplib" — POP3 protocol client
* 20.9.1. POP3 Objects
* 20.9.2. POP3 Example
* 20.10. "imaplib" — IMAP4 protocol client
* 20.10.1. IMAP4 Objects
* 20.10.2. IMAP4 Example
* 20.11. "nntplib" — NNTP protocol client
* 20.11.1. NNTP Objects
* 20.12. "smtplib" — SMTP protocol client
* 20.12.1. SMTP Objects
* 20.12.2. SMTP Example
* 20.13. "smtpd" — SMTP Server
* 20.13.1. SMTPServer Objects
* 20.13.2. DebuggingServer Objects
* 20.13.3. PureProxy Objects
* 20.13.4. MailmanProxy Objects
* 20.14. "telnetlib" — Telnet client
* 20.14.1. Telnet Objects
* 20.14.2. Telnet Example
* 20.15. "uuid" — UUID objects according to RFC 4122
* 20.15.1. Example
* 20.16. "urlparse" — Parse URLs into components
* 20.16.1. Results of "urlparse()" and "urlsplit()"
* 20.17. "SocketServer" — A framework for network servers
* 20.17.1. Server Creation Notes
* 20.17.2. Server Objects
* 20.17.3. Request Handler Objects
* 20.17.4. Examples
* 20.17.4.1. "SocketServer.TCPServer" Example
* 20.17.4.2. "SocketServer.UDPServer" Example
* 20.17.4.3. Asynchronous Mixins
* 20.18. "BaseHTTPServer" — Basic HTTP server
* 20.18.1. More examples
* 20.19. "SimpleHTTPServer" — Simple HTTP request handler
* 20.20. "CGIHTTPServer" — CGI-capable HTTP request handler
* 20.21. "cookielib" — Cookie handling for HTTP clients
* 20.21.1. CookieJar and FileCookieJar Objects
* 20.21.2. FileCookieJar subclasses and co-operation with web
browsers
* 20.21.3. CookiePolicy Objects
* 20.21.4. DefaultCookiePolicy Objects
* 20.21.5. Cookie Objects
* 20.21.6. Examples
* 20.22. "Cookie" — HTTP state management
* 20.22.1. Cookie Objects
* 20.22.2. Morsel Objects
* 20.22.3. Example
* 20.23. "xmlrpclib" — XML-RPC client access
* 20.23.1. ServerProxy Objects
* 20.23.2. Boolean Objects
* 20.23.3. DateTime Objects
* 20.23.4. Binary Objects
* 20.23.5. Fault Objects
* 20.23.6. ProtocolError Objects
* 20.23.7. MultiCall Objects
* 20.23.8. Convenience Functions
* 20.23.9. Example of Client Usage
* 20.23.10. Example of Client and Server Usage
* 20.24. "SimpleXMLRPCServer" — Basic XML-RPC server
* 20.24.1. SimpleXMLRPCServer Objects
* 20.24.1.1. SimpleXMLRPCServer Example
* 20.24.2. CGIXMLRPCRequestHandler
* 20.25. "DocXMLRPCServer" — Self-documenting XML-RPC server
* 20.25.1. DocXMLRPCServer Objects
* 20.25.2. DocCGIXMLRPCRequestHandler
* 21. Multimedia Services
* 21.1. "audioop" — Manipulate raw audio data
* 21.2. "imageop" — Manipulate raw image data
* 21.3. "aifc" — Read and write AIFF and AIFC files
* 21.4. "sunau" — Read and write Sun AU files
* 21.4.1. AU_read Objects
* 21.4.2. AU_write Objects
* 21.5. "wave" — Read and write WAV files
* 21.5.1. Wave_read Objects
* 21.5.2. Wave_write Objects
* 21.6. "chunk" — Read IFF chunked data
* 21.7. "colorsys" — Conversions between color systems
* 21.8. "imghdr" — Determine the type of an image
* 21.9. "sndhdr" — Determine type of sound file
* 21.10. "ossaudiodev" — Access to OSS-compatible audio devices
* 21.10.1. Audio Device Objects
* 21.10.2. Mixer Device Objects
* 22. Internationalization
* 22.1. "gettext" — Multilingual internationalization services
* 22.1.1. GNU **gettext** API
* 22.1.2. Class-based API
* 22.1.2.1. The "NullTranslations" class
* 22.1.2.2. The "GNUTranslations" class
* 22.1.2.3. Solaris message catalog support
* 22.1.2.4. The Catalog constructor
* 22.1.3. Internationalizing your programs and modules
* 22.1.3.1. Localizing your module
* 22.1.3.2. Localizing your application
* 22.1.3.3. Changing languages on the fly
* 22.1.3.4. Deferred translations
* 22.1.3.5. "gettext()" vs. "lgettext()"
* 22.1.4. Acknowledgements
* 22.2. "locale" — Internationalization services
* 22.2.1. Background, details, hints, tips and caveats
* 22.2.2. For extension writers and programs that embed Python
* 22.2.3. Access to message catalogs
* 23. Program Frameworks
* 23.1. "cmd" — Support for line-oriented command interpreters
* 23.1.1. Cmd Objects
* 23.2. "shlex" — Simple lexical analysis
* 23.2.1. shlex Objects
* 23.2.2. Parsing Rules
* 24. Graphical User Interfaces with Tk
* 24.1. "Tkinter" — Python interface to Tcl/Tk
* 24.1.1. Tkinter Modules
* 24.1.2. Tkinter Life Preserver
* 24.1.2.1. How To Use This Section
* 24.1.2.2. A Simple Hello World Program
* 24.1.3. A (Very) Quick Look at Tcl/Tk
* 24.1.4. Mapping Basic Tk into Tkinter
* 24.1.5. How Tk and Tkinter are Related
* 24.1.6. Handy Reference
* 24.1.6.1. Setting Options
* 24.1.6.2. The Packer
* 24.1.6.3. Packer Options
* 24.1.6.4. Coupling Widget Variables
* 24.1.6.5. The Window Manager
* 24.1.6.6. Tk Option Data Types
* 24.1.6.7. Bindings and Events
* 24.1.6.8. The index Parameter
* 24.1.6.9. Images
* 24.1.7. File Handlers
* 24.2. "ttk" — Tk themed widgets
* 24.2.1. Using Ttk
* 24.2.2. Ttk Widgets
* 24.2.3. Widget
* 24.2.3.1. Standard Options
* 24.2.3.2. Scrollable Widget Options
* 24.2.3.3. Label Options
* 24.2.3.4. Compatibility Options
* 24.2.3.5. Widget States
* 24.2.3.6. ttk.Widget
* 24.2.4. Combobox
* 24.2.4.1. Options
* 24.2.4.2. Virtual events
* 24.2.4.3. ttk.Combobox
* 24.2.5. Notebook
* 24.2.5.1. Options
* 24.2.5.2. Tab Options
* 24.2.5.3. Tab Identifiers
* 24.2.5.4. Virtual Events
* 24.2.5.5. ttk.Notebook
* 24.2.6. Progressbar
* 24.2.6.1. Options
* 24.2.6.2. ttk.Progressbar
* 24.2.7. Separator
* 24.2.7.1. Options
* 24.2.8. Sizegrip
* 24.2.8.1. Platform-specific notes
* 24.2.8.2. Bugs
* 24.2.9. Treeview
* 24.2.9.1. Options
* 24.2.9.2. Item Options
* 24.2.9.3. Tag Options
* 24.2.9.4. Column Identifiers
* 24.2.9.5. Virtual Events
* 24.2.9.6. ttk.Treeview
* 24.2.10. Ttk Styling
* 24.2.10.1. Layouts
* 24.3. "Tix" — Extension widgets for Tk
* 24.3.1. Using Tix
* 24.3.2. Tix Widgets
* 24.3.2.1. Basic Widgets
* 24.3.2.2. File Selectors
* 24.3.2.3. Hierarchical ListBox
* 24.3.2.4. Tabular ListBox
* 24.3.2.5. Manager Widgets
* 24.3.2.6. Image Types
* 24.3.2.7. Miscellaneous Widgets
* 24.3.2.8. Form Geometry Manager
* 24.3.3. Tix Commands
* 24.4. "ScrolledText" — Scrolled Text Widget
* 24.5. "turtle" — Turtle graphics for Tk
* 24.5.1. Introduction
* 24.5.2. Overview over available Turtle and Screen methods
* 24.5.2.1. Turtle methods
* 24.5.2.2. Methods of TurtleScreen/Screen
* 24.5.3. Methods of RawTurtle/Turtle and corresponding
functions
* 24.5.3.1. Turtle motion
* 24.5.3.2. Tell Turtle’s state
* 24.5.3.3. Settings for measurement
* 24.5.3.4. Pen control
* 24.5.3.4.1. Drawing state
* 24.5.3.4.2. Color control
* 24.5.3.4.3. Filling
* 24.5.3.4.4. More drawing control
* 24.5.3.5. Turtle state
* 24.5.3.5.1. Visibility
* 24.5.3.5.2. Appearance
* 24.5.3.6. Using events
* 24.5.3.7. Special Turtle methods
* 24.5.3.8. Excursus about the use of compound shapes
* 24.5.4. Methods of TurtleScreen/Screen and corresponding
functions
* 24.5.4.1. Window control
* 24.5.4.2. Animation control
* 24.5.4.3. Using screen events
* 24.5.4.4. Settings and special methods
* 24.5.4.5. Methods specific to Screen, not inherited from
TurtleScreen
* 24.5.5. The public classes of the module "turtle"
* 24.5.6. Help and configuration
* 24.5.6.1. How to use help
* 24.5.6.2. Translation of docstrings into different
languages
* 24.5.6.3. How to configure Screen and Turtles
* 24.5.7. Demo scripts
* 24.6. IDLE
* 24.6.1. Menus
* 24.6.1.1. File menu (Shell and Editor)
* 24.6.1.2. Edit menu (Shell and Editor)
* 24.6.1.3. Format menu (Editor window only)
* 24.6.1.4. Run menu (Editor window only)
* 24.6.1.5. Shell menu (Shell window only)
* 24.6.1.6. Debug menu (Shell window only)
* 24.6.1.7. Options menu (Shell and Editor)
* 24.6.1.8. Window menu (Shell and Editor)
* 24.6.1.9. Help menu (Shell and Editor)
* 24.6.1.10. Context Menus
* 24.6.2. Editing and navigation
* 24.6.2.1. Automatic indentation
* 24.6.2.2. Completions
* 24.6.2.3. Calltips
* 24.6.2.4. Python Shell window
* 24.6.2.5. Text colors
* 24.6.3. Startup and code execution
* 24.6.3.1. Command line usage
* 24.6.3.2. IDLE-console differences
* 24.6.3.3. Running without a subprocess
* 24.6.4. Help and preferences
* 24.6.4.1. Additional help sources
* 24.6.4.2. Setting preferences
* 24.6.4.3. Extensions
* 24.7. Other Graphical User Interface Packages
* 25. Development Tools
* 25.1. "pydoc" — Documentation generator and online help system
* 25.2. "doctest" — Test interactive Python examples
* 25.2.1. Simple Usage: Checking Examples in Docstrings
* 25.2.2. Simple Usage: Checking Examples in a Text File
* 25.2.3. How It Works
* 25.2.3.1. Which Docstrings Are Examined?
* 25.2.3.2. How are Docstring Examples Recognized?
* 25.2.3.3. What’s the Execution Context?
* 25.2.3.4. What About Exceptions?
* 25.2.3.5. Option Flags
* 25.2.3.6. Directives
* 25.2.3.7. Warnings
* 25.2.4. Basic API
* 25.2.5. Unittest API
* 25.2.6. Advanced API
* 25.2.6.1. DocTest Objects
* 25.2.6.2. Example Objects
* 25.2.6.3. DocTestFinder objects
* 25.2.6.4. DocTestParser objects
* 25.2.6.5. DocTestRunner objects
* 25.2.6.6. OutputChecker objects
* 25.2.7. Debugging
* 25.2.8. Soapbox
* 25.3. "unittest" — Unit testing framework
* 25.3.1. Basic example
* 25.3.2. Command-Line Interface
* 25.3.2.1. Command-line options
* 25.3.3. Test Discovery
* 25.3.4. Organizing test code
* 25.3.5. Re-using old test code
* 25.3.6. Skipping tests and expected failures
* 25.3.7. Classes and functions
* 25.3.7.1. Test cases
* 25.3.7.1.1. Deprecated aliases
* 25.3.7.2. Grouping tests
* 25.3.7.3. Loading and running tests
* 25.3.7.3.1. load_tests Protocol
* 25.3.8. Class and Module Fixtures
* 25.3.8.1. setUpClass and tearDownClass
* 25.3.8.2. setUpModule and tearDownModule
* 25.3.9. Signal Handling
* 25.4. 2to3 - Automated Python 2 to 3 code translation
* 25.4.1. Using 2to3
* 25.4.2. Fixers
* 25.4.3. "lib2to3" - 2to3’s library
* 25.5. "test" — Regression tests package for Python
* 25.5.1. Writing Unit Tests for the "test" package
* 25.5.2. Running tests using the command-line interface
* 25.6. "test.support" — Utility functions for tests
* 26. Debugging and Profiling
* 26.1. "bdb" — Debugger framework
* 26.2. "pdb" — The Python Debugger
* 26.3. Debugger Commands
* 26.4. The Python Profilers
* 26.4.1. Introduction to the profilers
* 26.4.2. Instant User’s Manual
* 26.4.3. "profile" and "cProfile" Module Reference
* 26.4.4. The "Stats" Class
* 26.4.5. What Is Deterministic Profiling?
* 26.4.6. Limitations
* 26.4.7. Calibration
* 26.4.8. Using a custom timer
* 26.5. "hotshot" — High performance logging profiler
* 26.5.1. Profile Objects
* 26.5.2. Using hotshot data
* 26.5.3. Example Usage
* 26.6. "timeit" — Measure execution time of small code snippets
* 26.6.1. Basic Examples
* 26.6.2. Python Interface
* 26.6.3. Command-Line Interface
* 26.6.4. Examples
* 26.7. "trace" — Trace or track Python statement execution
* 26.7.1. Command-Line Usage
* 26.7.1.1. Main options
* 26.7.1.2. Modifiers
* 26.7.1.3. Filters
* 26.7.2. Programmatic Interface
* 27. Software Packaging and Distribution
* 27.1. "distutils" — Building and installing Python modules
* 27.2. "ensurepip" — Bootstrapping the "pip" installer
* 27.2.1. Command line interface
* 27.2.2. Module API
* 28. Python Runtime Services
* 28.1. "sys" — System-specific parameters and functions
* 28.2. "sysconfig" — Provide access to Python’s configuration
information
* 28.2.1. Configuration variables
* 28.2.2. Installation paths
* 28.2.3. Other functions
* 28.3. "__builtin__" — Built-in objects
* 28.4. "future_builtins" — Python 3 builtins
* 28.5. "__main__" — Top-level script environment
* 28.6. "warnings" — Warning control
* 28.6.1. Warning Categories
* 28.6.2. The Warnings Filter
* 28.6.2.1. Default Warning Filters
* 28.6.3. Temporarily Suppressing Warnings
* 28.6.4. Testing Warnings
* 28.6.5. Updating Code For New Versions of Python
* 28.6.6. Available Functions
* 28.6.7. Available Context Managers
* 28.7. "contextlib" — Utilities for "with"-statement contexts
* 28.8. "abc" — Abstract Base Classes
* 28.9. "atexit" — Exit handlers
* 28.9.1. "atexit" Example
* 28.10. "traceback" — Print or retrieve a stack traceback
* 28.10.1. Traceback Examples
* 28.11. "__future__" — Future statement definitions
* 28.12. "gc" — Garbage Collector interface
* 28.13. "inspect" — Inspect live objects
* 28.13.1. Types and members
* 28.13.2. Retrieving source code
* 28.13.3. Classes and functions
* 28.13.4. The interpreter stack
* 28.14. "site" — Site-specific configuration hook
* 28.15. "user" — User-specific configuration hook
* 28.16. "fpectl" — Floating point exception control
* 28.16.1. Example
* 28.16.2. Limitations and other considerations
* 29. Custom Python Interpreters
* 29.1. "code" — Interpreter base classes
* 29.1.1. Interactive Interpreter Objects
* 29.1.2. Interactive Console Objects
* 29.2. "codeop" — Compile Python code
* 30. Restricted Execution
* 30.1. "rexec" — Restricted execution framework
* 30.1.1. RExec Objects
* 30.1.2. Defining restricted environments
* 30.1.3. An example
* 30.2. "Bastion" — Restricting access to objects
* 31. Importing Modules
* 31.1. "imp" — Access the "import" internals
* 31.1.1. Examples
* 31.2. "importlib" — Convenience wrappers for "__import__()"
* 31.3. "imputil" — Import utilities
* 31.3.1. Examples
* 31.4. "zipimport" — Import modules from Zip archives
* 31.4.1. zipimporter Objects
* 31.4.2. Examples
* 31.5. "pkgutil" — Package extension utility
* 31.6. "modulefinder" — Find modules used by a script
* 31.6.1. Example usage of "ModuleFinder"
* 31.7. "runpy" — Locating and executing Python modules
* 32. Python Language Services
* 32.1. "parser" — Access Python parse trees
* 32.1.1. Creating ST Objects
* 32.1.2. Converting ST Objects
* 32.1.3. Queries on ST Objects
* 32.1.4. Exceptions and Error Handling
* 32.1.5. ST Objects
* 32.1.6. Example: Emulation of "compile()"
* 32.2. "ast" — Abstract Syntax Trees
* 32.2.1. Node classes
* 32.2.2. Abstract Grammar
* 32.2.3. "ast" Helpers
* 32.3. "symtable" — Access to the compiler’s symbol tables
* 32.3.1. Generating Symbol Tables
* 32.3.2. Examining Symbol Tables
* 32.4. "symbol" — Constants used with Python parse trees
* 32.5. "token" — Constants used with Python parse trees
* 32.6. "keyword" — Testing for Python keywords
* 32.7. "tokenize" — Tokenizer for Python source
* 32.8. "tabnanny" — Detection of ambiguous indentation
* 32.9. "pyclbr" — Python class browser support
* 32.9.1. Class Objects
* 32.9.2. Function Objects
* 32.10. "py_compile" — Compile Python source files
* 32.11. "compileall" — Byte-compile Python libraries
* 32.11.1. Command-line use
* 32.11.2. Public functions
* 32.12. "dis" — Disassembler for Python bytecode
* 32.12.1. Python Bytecode Instructions
* 32.13. "pickletools" — Tools for pickle developers
* 33. Python compiler package
* 33.1. The basic interface
* 33.2. Limitations
* 33.3. Python Abstract Syntax
* 33.3.1. AST Nodes
* 33.3.2. Assignment nodes
* 33.3.3. Examples
* 33.4. Using Visitors to Walk ASTs
* 33.5. Bytecode Generation
* 34. Miscellaneous Services
* 34.1. "formatter" — Generic output formatting
* 34.1.1. The Formatter Interface
* 34.1.2. Formatter Implementations
* 34.1.3. The Writer Interface
* 34.1.4. Writer Implementations
* 35. MS Windows Specific Services
* 35.1. "msilib" — Read and write Microsoft Installer files
* 35.1.1. Database Objects
* 35.1.2. View Objects
* 35.1.3. Summary Information Objects
* 35.1.4. Record Objects
* 35.1.5. Errors
* 35.1.6. CAB Objects
* 35.1.7. Directory Objects
* 35.1.8. Features
* 35.1.9. GUI classes
* 35.1.10. Precomputed tables
* 35.2. "msvcrt" — Useful routines from the MS VC++ runtime
* 35.2.1. File Operations
* 35.2.2. Console I/O
* 35.2.3. Other Functions
* 35.3. "_winreg" — Windows registry access
* 35.3.1. Constants
* 35.3.1.1. HKEY_* Constants
* 35.3.1.2. Access Rights
* 35.3.1.2.1. 64-bit Specific
* 35.3.1.3. Value Types
* 35.3.2. Registry Handle Objects
* 35.4. "winsound" — Sound-playing interface for Windows
* 36. Unix Specific Services
* 36.1. "posix" — The most common POSIX system calls
* 36.1.1. Large File Support
* 36.1.2. Notable Module Contents
* 36.2. "pwd" — The password database
* 36.3. "spwd" — The shadow password database
* 36.4. "grp" — The group database
* 36.5. "crypt" — Function to check Unix passwords
* 36.6. "dl" — Call C functions in shared objects
* 36.6.1. Dl Objects
* 36.7. "termios" — POSIX style tty control
* 36.7.1. Example
* 36.8. "tty" — Terminal control functions
* 36.9. "pty" — Pseudo-terminal utilities
* 36.10. "fcntl" — The "fcntl" and "ioctl" system calls
* 36.11. "pipes" — Interface to shell pipelines
* 36.11.1. Template Objects
* 36.12. "posixfile" — File-like objects with locking support
* 36.13. "resource" — Resource usage information
* 36.13.1. Resource Limits
* 36.13.2. Resource Usage
* 36.14. "nis" — Interface to Sun’s NIS (Yellow Pages)
* 36.15. "syslog" — Unix syslog library routines
* 36.15.1. Examples
* 36.15.1.1. Simple example
* 36.16. "commands" — Utilities for running commands
* 37. Mac OS X specific services
* 37.1. "ic" — Access to the Mac OS X Internet Config
* 37.1.1. IC Objects
* 37.2. "MacOS" — Access to Mac OS interpreter features
* 37.3. "macostools" — Convenience routines for file
manipulation
* 37.4. "findertools" — The **finder**’s Apple Events interface
* 37.5. "EasyDialogs" — Basic Macintosh dialogs
* 37.5.1. ProgressBar Objects
* 37.6. "FrameWork" — Interactive application framework
* 37.6.1. Application Objects
* 37.6.2. Window Objects
* 37.6.3. ControlsWindow Object
* 37.6.4. ScrolledWindow Object
* 37.6.5. DialogWindow Objects
* 37.7. "autoGIL" — Global Interpreter Lock handling in event
loops
* 37.8. Mac OS Toolbox Modules
* 37.8.1. "Carbon.AE" — Apple Events
* 37.8.2. "Carbon.AH" — Apple Help
* 37.8.3. "Carbon.App" — Appearance Manager
* 37.8.4. "Carbon.Appearance" — Appearance Manager constants
* 37.8.5. "Carbon.CF" — Core Foundation
* 37.8.6. "Carbon.CG" — Core Graphics
* 37.8.7. "Carbon.CarbonEvt" — Carbon Event Manager
* 37.8.8. "Carbon.CarbonEvents" — Carbon Event Manager
constants
* 37.8.9. "Carbon.Cm" — Component Manager
* 37.8.10. "Carbon.Components" — Component Manager constants
* 37.8.11. "Carbon.ControlAccessor" — Control Manager accssors
* 37.8.12. "Carbon.Controls" — Control Manager constants
* 37.8.13. "Carbon.CoreFounation" — CoreFounation constants
* 37.8.14. "Carbon.CoreGraphics" — CoreGraphics constants
* 37.8.15. "Carbon.Ctl" — Control Manager
* 37.8.16. "Carbon.Dialogs" — Dialog Manager constants
* 37.8.17. "Carbon.Dlg" — Dialog Manager
* 37.8.18. "Carbon.Drag" — Drag and Drop Manager
* 37.8.19. "Carbon.Dragconst" — Drag and Drop Manager
constants
* 37.8.20. "Carbon.Events" — Event Manager constants
* 37.8.21. "Carbon.Evt" — Event Manager
* 37.8.22. "Carbon.File" — File Manager
* 37.8.23. "Carbon.Files" — File Manager constants
* 37.8.24. "Carbon.Fm" — Font Manager
* 37.8.25. "Carbon.Folder" — Folder Manager
* 37.8.26. "Carbon.Folders" — Folder Manager constants
* 37.8.27. "Carbon.Fonts" — Font Manager constants
* 37.8.28. "Carbon.Help" — Help Manager
* 37.8.29. "Carbon.IBCarbon" — Carbon InterfaceBuilder
* 37.8.30. "Carbon.IBCarbonRuntime" — Carbon InterfaceBuilder
constants
* 37.8.31. "Carbon.Icn" — Carbon Icon Manager
* 37.8.32. "Carbon.Icons" — Carbon Icon Manager constants
* 37.8.33. "Carbon.Launch" — Carbon Launch Services
* 37.8.34. "Carbon.LaunchServices" — Carbon Launch Services
constants
* 37.8.35. "Carbon.List" — List Manager
* 37.8.36. "Carbon.Lists" — List Manager constants
* 37.8.37. "Carbon.MacHelp" — Help Manager constants
* 37.8.38. "Carbon.MediaDescr" — Parsers and generators for
Quicktime Media descriptors
* 37.8.39. "Carbon.Menu" — Menu Manager
* 37.8.40. "Carbon.Menus" — Menu Manager constants
* 37.8.41. "Carbon.Mlte" — MultiLingual Text Editor
* 37.8.42. "Carbon.OSA" — Carbon OSA Interface
* 37.8.43. "Carbon.OSAconst" — Carbon OSA Interface constants
* 37.8.44. "Carbon.QDOffscreen" — QuickDraw Offscreen
constants
* 37.8.45. "Carbon.Qd" — QuickDraw
* 37.8.46. "Carbon.Qdoffs" — QuickDraw Offscreen
* 37.8.47. "Carbon.Qt" — QuickTime
* 37.8.48. "Carbon.QuickDraw" — QuickDraw constants
* 37.8.49. "Carbon.QuickTime" — QuickTime constants
* 37.8.50. "Carbon.Res" — Resource Manager and Handles
* 37.8.51. "Carbon.Resources" — Resource Manager and Handles
constants
* 37.8.52. "Carbon.Scrap" — Scrap Manager
* 37.8.53. "Carbon.Snd" — Sound Manager
* 37.8.54. "Carbon.Sound" — Sound Manager constants
* 37.8.55. "Carbon.TE" — TextEdit
* 37.8.56. "Carbon.TextEdit" — TextEdit constants
* 37.8.57. "Carbon.Win" — Window Manager
* 37.8.58. "Carbon.Windows" — Window Manager constants
* 37.9. "ColorPicker" — Color selection dialog
* 38. MacPython OSA Modules
* 38.1. "gensuitemodule" — Generate OSA stub packages
* 38.2. "aetools" — OSA client support
* 38.3. "aepack" — Conversion between Python variables and
AppleEvent data containers
* 38.4. "aetypes" — AppleEvent objects
* 38.5. "MiniAEFrame" — Open Scripting Architecture server
support
* 38.5.1. AEServer Objects
* 39. SGI IRIX Specific Services
* 39.1. "al" — Audio functions on the SGI
* 39.1.1. Configuration Objects
* 39.1.2. Port Objects
* 39.2. "AL" — Constants used with the "al" module
* 39.3. "cd" — CD-ROM access on SGI systems
* 39.3.1. Player Objects
* 39.3.2. Parser Objects
* 39.4. "fl" — FORMS library for graphical user interfaces
* 39.4.1. Functions Defined in Module "fl"
* 39.4.2. Form Objects
* 39.4.3. FORMS Objects
* 39.5. "FL" — Constants used with the "fl" module
* 39.6. "flp" — Functions for loading stored FORMS designs
* 39.7. "fm" — *Font Manager* interface
* 39.8. "gl" — *Graphics Library* interface
* 39.9. "DEVICE" — Constants used with the "gl" module
* 39.10. "GL" — Constants used with the "gl" module
* 39.11. "imgfile" — Support for SGI imglib files
* 39.12. "jpeg" — Read and write JPEG files
* 40. SunOS Specific Services
* 40.1. "sunaudiodev" — Access to Sun audio hardware
* 40.1.1. Audio Device Objects
* 40.2. "SUNAUDIODEV" — Constants used with "sunaudiodev"
* 41. Undocumented Modules
* 41.1. Miscellaneous useful utilities
* 41.2. Platform specific modules
* 41.3. Multimedia
* 41.4. Undocumented Mac OS modules
* 41.4.1. "applesingle" — AppleSingle decoder
* 41.4.2. "buildtools" — Helper module for BuildApplet and
Friends
* 41.4.3. "cfmfile" — Code Fragment Resource module
* 41.4.4. "icopen" — Internet Config replacement for "open()"
* 41.4.5. "macerrors" — Mac OS Errors
* 41.4.6. "macresource" — Locate script resources
* 41.4.7. "Nav" — NavServices calls
* 41.4.8. "PixMapWrapper" — Wrapper for PixMap objects
* 41.4.9. "videoreader" — Read QuickTime movies
* 41.4.10. "W" — Widgets built on "FrameWork"
* 41.5. Obsolete
* 41.6. SGI-specific Extension modules
* Extending and Embedding the Python Interpreter
* 1. Extending Python with C or C++
* 1.1. A Simple Example
* 1.2. Intermezzo: Errors and Exceptions
* 1.3. Back to the Example
* 1.4. The Module’s Method Table and Initialization Function
* 1.5. Compilation and Linkage
* 1.6. Calling Python Functions from C
* 1.7. Extracting Parameters in Extension Functions
* 1.8. Keyword Parameters for Extension Functions
* 1.9. Building Arbitrary Values
* 1.10. Reference Counts
* 1.10.1. Reference Counting in Python
* 1.10.2. Ownership Rules
* 1.10.3. Thin Ice
* 1.10.4. NULL Pointers
* 1.11. Writing Extensions in C++
* 1.12. Providing a C API for an Extension Module
* 2. Defining New Types
* 2.1. The Basics
* 2.1.1. Adding data and methods to the Basic example
* 2.1.2. Providing finer control over data attributes
* 2.1.3. Supporting cyclic garbage collection
* 2.1.4. Subclassing other types
* 2.2. Type Methods
* 2.2.1. Finalization and De-allocation
* 2.2.2. Object Presentation
* 2.2.3. Attribute Management
* 2.2.3.1. Generic Attribute Management
* 2.2.3.2. Type-specific Attribute Management
* 2.2.4. Object Comparison
* 2.2.5. Abstract Protocol Support
* 2.2.6. Weak Reference Support
* 2.2.7. More Suggestions
* 3. Building C and C++ Extensions with distutils
* 3.1. Distributing your extension modules
* 4. Building C and C++ Extensions on Windows
* 4.1. A Cookbook Approach
* 4.2. Differences Between Unix and Windows
* 4.3. Using DLLs in Practice
* 5. Embedding Python in Another Application
* 5.1. Very High Level Embedding
* 5.2. Beyond Very High Level Embedding: An overview
* 5.3. Pure Embedding
* 5.4. Extending Embedded Python
* 5.5. Embedding Python in C++
* 5.6. 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
* Standard Warning Categories
* 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
* Ellipsis Object
* 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
* Object allocators
* The pymalloc allocator
* 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
* Pip not installed
* Installing binary extensions
* Python HOWTOs
* Porting Python 2 Code to Python 3
* The Short Explanation
* Details
* Drop support for Python 2.6 and older
* 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
* Use feature detection instead of version detection
* 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
* Consider using optional static type checking
* 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 in CPython?
* How are dictionaries implemented in CPython?
* 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.17
* 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