Python Documentation contents ***************************** * What's New in Python * What's New In Python 3.10 * Summary -- Release highlights * New Features * Parenthesized context managers * Better error messages * SyntaxErrors * IndentationErrors * AttributeErrors * NameErrors * PEP 626: Precise line numbers for debugging and other tools * PEP 634: Structural Pattern Matching * Syntax and operations * Declarative approach * Simple pattern: match to a literal * Behavior without the wildcard * Patterns with a literal and variable * Patterns and classes * Patterns with positional parameters * Nested patterns * Complex patterns and the wildcard * Guard * Other Key Features * Optional "EncodingWarning" and "encoding="locale"" option * New Features Related to Type Hints * PEP 604: New Type Union Operator * PEP 612: Parameter Specification Variables * PEP 613: TypeAlias * PEP 647: User-Defined Type Guards * Other Language Changes * New Modules * Improved Modules * asyncio * argparse * array * asynchat, asyncore, smtpd * base64 * bdb * bisect * codecs * collections.abc * contextlib * curses * dataclasses * __slots__ * Keyword-only fields * distutils * doctest * encodings * fileinput * faulthandler * gc * glob * hashlib * hmac * IDLE and idlelib * importlib.metadata * inspect * linecache * os * os.path * pathlib * platform * pprint * py_compile * pyclbr * shelve * statistics * site * socket * ssl * sqlite3 * sys * _thread * threading * traceback * types * typing * unittest * urllib.parse * xml * zipimport * Optimizations * Deprecated * Removed * Porting to Python 3.10 * Changes in the Python syntax * Changes in the Python API * Changes in the C API * CPython bytecode changes * Build Changes * C API Changes * PEP 652: Maintaining the Stable ABI * New Features * Porting to Python 3.10 * Deprecated * Removed * What's New In Python 3.9 * Summary -- Release highlights * You should check for DeprecationWarning in your code * New Features * Dictionary Merge & Update Operators * New String Methods to Remove Prefixes and Suffixes * Type Hinting Generics in Standard Collections * New Parser * Other Language Changes * New Modules * zoneinfo * graphlib * Improved Modules * ast * asyncio * compileall * concurrent.futures * curses * datetime * distutils * fcntl * ftplib * gc * hashlib * http * IDLE and idlelib * imaplib * importlib * inspect * ipaddress * math * multiprocessing * nntplib * os * pathlib * pdb * poplib * pprint * pydoc * random * signal * smtplib * socket * time * sys * tracemalloc * typing * unicodedata * venv * xml * Optimizations * Deprecated * Removed * Porting to Python 3.9 * Changes in the Python API * Changes in the C API * CPython bytecode changes * Build Changes * C API Changes * New Features * Porting to Python 3.9 * Removed * Notable changes in Python 3.9.1 * typing * macOS 11.0 (Big Sur) and Apple Silicon Mac support * Notable changes in Python 3.9.2 * collections.abc * urllib.parse * What's New In Python 3.8 * Summary -- Release highlights * New Features * Assignment expressions * Positional-only parameters * Parallel filesystem cache for compiled bytecode files * Debug build uses the same ABI as release build * f-strings support "=" for self-documenting expressions and debugging * PEP 578: Python Runtime Audit Hooks * PEP 587: Python Initialization Configuration * PEP 590: Vectorcall: a fast calling protocol for CPython * Pickle protocol 5 with out-of-band data buffers * Other Language Changes * New Modules * Improved Modules * ast * asyncio * builtins * collections * cProfile * csv * curses * ctypes * datetime * functools * gc * gettext * gzip * IDLE and idlelib * inspect * io * itertools * json.tool * logging * math * mmap * multiprocessing * os * os.path * pathlib * pickle * plistlib * pprint * py_compile * shlex * shutil * socket * ssl * statistics * sys * tarfile * threading * tokenize * tkinter * time * typing * unicodedata * unittest * venv * weakref * xml * xmlrpc * Optimizations * Build and C API Changes * Deprecated * API and Feature Removals * Porting to Python 3.8 * Changes in Python behavior * Changes in the Python API * Changes in the C API * CPython bytecode changes * Demos and Tools * Notable changes in Python 3.8.1 * Notable changes in Python 3.8.8 * Notable changes in Python 3.8.12 * What's New In Python 3.7 * Summary -- Release Highlights * New Features * PEP 563: Postponed Evaluation of Annotations * PEP 538: Legacy C Locale Coercion * PEP 540: Forced UTF-8 Runtime Mode * PEP 553: Built-in "breakpoint()" * PEP 539: New C API for Thread-Local Storage * PEP 562: Customization of Access to Module Attributes * PEP 564: New Time Functions With Nanosecond Resolution * PEP 565: Show DeprecationWarning in "__main__" * PEP 560: Core Support for "typing" module and Generic Types * PEP 552: Hash-based .pyc Files * PEP 545: Python Documentation Translations * Python Development Mode (-X dev) * Other Language Changes * New Modules * contextvars * dataclasses * importlib.resources * Improved Modules * argparse * asyncio * binascii * calendar * collections * compileall * concurrent.futures * contextlib * cProfile * crypt * datetime * dbm * decimal * dis * distutils * enum * functools * gc * hmac * http.client * http.server * idlelib and IDLE * importlib * io * ipaddress * itertools * locale * logging * math * mimetypes * msilib * multiprocessing * os * pathlib * pdb * py_compile * pydoc * queue * re * signal * socket * socketserver * sqlite3 * ssl * string * subprocess * sys * time * tkinter * tracemalloc * types * unicodedata * unittest * unittest.mock * urllib.parse * uu * uuid * warnings * xml.etree * xmlrpc.server * zipapp * zipfile * C API Changes * Build Changes * Optimizations * Other CPython Implementation Changes * Deprecated Python Behavior * Deprecated Python modules, functions and methods * aifc * asyncio * collections * dbm * enum * gettext * importlib * locale * macpath * threading * socket * ssl * sunau * sys * wave * Deprecated functions and types of the C API * Platform Support Removals * API and Feature Removals * Module Removals * Windows-only Changes * Porting to Python 3.7 * Changes in Python Behavior * Changes in the Python API * Changes in the C API * CPython bytecode changes * Windows-only Changes * Other CPython implementation changes * Notable changes in Python 3.7.1 * Notable changes in Python 3.7.2 * Notable changes in Python 3.7.6 * Notable changes in Python 3.7.10 * What's New In Python 3.6 * Summary -- Release highlights * New Features * PEP 498: Formatted string literals * PEP 526: Syntax for variable annotations * PEP 515: Underscores in Numeric Literals * PEP 525: Asynchronous Generators * PEP 530: Asynchronous Comprehensions * PEP 487: Simpler customization of class creation * PEP 487: Descriptor Protocol Enhancements * PEP 519: Adding a file system path protocol * PEP 495: Local Time Disambiguation * PEP 529: Change Windows filesystem encoding to UTF-8 * PEP 528: Change Windows console encoding to UTF-8 * PEP 520: Preserving Class Attribute Definition Order * PEP 468: Preserving Keyword Argument Order * New *dict* implementation * PEP 523: Adding a frame evaluation API to CPython * PYTHONMALLOC environment variable * DTrace and SystemTap probing support * Other Language Changes * New Modules * secrets * Improved Modules * array * ast * asyncio * binascii * cmath * collections * concurrent.futures * contextlib * datetime * decimal * distutils * email * encodings * enum * faulthandler * fileinput * hashlib * http.client * idlelib and IDLE * importlib * inspect * json * logging * math * multiprocessing * os * pathlib * pdb * pickle * pickletools * pydoc * random * re * readline * rlcompleter * shlex * site * sqlite3 * socket * socketserver * ssl * statistics * struct * subprocess * sys * telnetlib * time * timeit * tkinter * traceback * tracemalloc * typing * unicodedata * unittest.mock * urllib.request * urllib.robotparser * venv * warnings * winreg * winsound * xmlrpc.client * zipfile * zlib * Optimizations * Build and C API Changes * Other Improvements * Deprecated * New Keywords * Deprecated Python behavior * Deprecated Python modules, functions and methods * asynchat * asyncore * dbm * distutils * grp * importlib * os * re * ssl * tkinter * venv * Deprecated functions and types of the C API * Deprecated Build Options * Removed * API and Feature Removals * Porting to Python 3.6 * Changes in 'python' Command Behavior * Changes in the Python API * Changes in the C API * CPython bytecode changes * Notable changes in Python 3.6.2 * New "make regen-all" build target * Removal of "make touch" build target * Notable changes in Python 3.6.4 * Notable changes in Python 3.6.5 * Notable changes in Python 3.6.7 * Notable changes in Python 3.6.10 * Notable changes in Python 3.6.13 * What's New In Python 3.5 * Summary -- Release highlights * New Features * PEP 492 - Coroutines with async and await syntax * PEP 465 - A dedicated infix operator for matrix multiplication * PEP 448 - Additional Unpacking Generalizations * PEP 461 - percent formatting support for bytes and bytearray * PEP 484 - Type Hints * PEP 471 - os.scandir() function -- a better and faster directory iterator * PEP 475: Retry system calls failing with EINTR * PEP 479: Change StopIteration handling inside generators * PEP 485: A function for testing approximate equality * PEP 486: Make the Python Launcher aware of virtual environments * PEP 488: Elimination of PYO files * PEP 489: Multi-phase extension module initialization * Other Language Changes * New Modules * typing * zipapp * Improved Modules * argparse * asyncio * bz2 * cgi * cmath * code * collections * collections.abc * compileall * concurrent.futures * configparser * contextlib * csv * curses * dbm * difflib * distutils * doctest * email * enum * faulthandler * functools * glob * gzip * heapq * http * http.client * idlelib and IDLE * imaplib * imghdr * importlib * inspect * io * ipaddress * json * linecache * locale * logging * lzma * math * multiprocessing * operator * os * pathlib * pickle * poplib * re * readline * selectors * shutil * signal * smtpd * smtplib * sndhdr * socket * ssl * Memory BIO Support * Application-Layer Protocol Negotiation Support * Other Changes * sqlite3 * subprocess * sys * sysconfig * tarfile * threading * time * timeit * tkinter * traceback * types * unicodedata * unittest * unittest.mock * urllib * wsgiref * xmlrpc * xml.sax * zipfile * Other module-level changes * Optimizations * Build and C API Changes * Deprecated * New Keywords * Deprecated Python Behavior * Unsupported Operating Systems * Deprecated Python modules, functions and methods * Removed * API and Feature Removals * Porting to Python 3.5 * Changes in Python behavior * Changes in the Python API * Changes in the C API * Notable changes in Python 3.5.4 * New "make regen-all" build target * Removal of "make touch" build target * What's New In Python 3.4 * Summary -- Release Highlights * New Features * PEP 453: Explicit Bootstrapping of PIP in Python Installations * Bootstrapping pip By Default * Documentation Changes * PEP 446: Newly Created File Descriptors Are Non-Inheritable * Improvements to Codec Handling * PEP 451: A ModuleSpec Type for the Import System * Other Language Changes * New Modules * asyncio * ensurepip * enum * pathlib * selectors * statistics * tracemalloc * Improved Modules * abc * aifc * argparse * audioop * base64 * collections * colorsys * contextlib * dbm * dis * doctest * email * filecmp * functools * gc * glob * hashlib * hmac * html * http * idlelib and IDLE * importlib * inspect * ipaddress * logging * marshal * mmap * multiprocessing * operator * os * pdb * pickle * plistlib * poplib * pprint * pty * pydoc * re * resource * select * shelve * shutil * smtpd * smtplib * socket * sqlite3 * ssl * stat * struct * subprocess * sunau * sys * tarfile * textwrap * threading * traceback * types * urllib * unittest * venv * wave * weakref * xml.etree * zipfile * CPython Implementation Changes * PEP 445: Customization of CPython Memory Allocators * PEP 442: Safe Object Finalization * PEP 456: Secure and Interchangeable Hash Algorithm * PEP 436: Argument Clinic * Other Build and C API Changes * Other Improvements * Significant Optimizations * Deprecated * Deprecations in the Python API * Deprecated Features * Removed * Operating Systems No Longer Supported * API and Feature Removals * Code Cleanups * Porting to Python 3.4 * Changes in 'python' Command Behavior * Changes in the Python API * Changes in the C API * Changed in 3.4.3 * PEP 476: Enabling certificate verification by default for stdlib http clients * What's New In Python 3.3 * Summary -- Release highlights * PEP 405: Virtual Environments * PEP 420: Implicit Namespace Packages * PEP 3118: New memoryview implementation and buffer protocol documentation * Features * API changes * PEP 393: Flexible String Representation * Functionality * Performance and resource usage * PEP 397: Python Launcher for Windows * PEP 3151: Reworking the OS and IO exception hierarchy * PEP 380: Syntax for Delegating to a Subgenerator * PEP 409: Suppressing exception context * PEP 414: Explicit Unicode literals * PEP 3155: Qualified name for classes and functions * PEP 412: Key-Sharing Dictionary * PEP 362: Function Signature Object * PEP 421: Adding sys.implementation * SimpleNamespace * Using importlib as the Implementation of Import * New APIs * Visible Changes * Other Language Changes * A Finer-Grained Import Lock * Builtin functions and types * New Modules * faulthandler * ipaddress * lzma * Improved Modules * abc * array * base64 * binascii * bz2 * codecs * collections * contextlib * crypt * curses * datetime * decimal * Features * API changes * email * Policy Framework * Provisional Policy with New Header API * Other API Changes * ftplib * functools * gc * hmac * http * html * imaplib * inspect * io * itertools * logging * math * mmap * multiprocessing * nntplib * os * pdb * pickle * pydoc * re * sched * select * shlex * shutil * signal * smtpd * smtplib * socket * socketserver * sqlite3 * ssl * stat * struct * subprocess * sys * tarfile * tempfile * textwrap * threading * time * types * unittest * urllib * webbrowser * xml.etree.ElementTree * zlib * Optimizations * Build and C API Changes * Deprecated * Unsupported Operating Systems * Deprecated Python modules, functions and methods * Deprecated functions and types of the C API * Deprecated features * Porting to Python 3.3 * Porting Python code * Porting C code * Building C extensions * Command Line Switch Changes * What's New In Python 3.2 * PEP 384: Defining a Stable ABI * PEP 389: Argparse Command Line Parsing Module * PEP 391: Dictionary Based Configuration for Logging * PEP 3148: The "concurrent.futures" module * PEP 3147: PYC Repository Directories * PEP 3149: ABI Version Tagged .so Files * PEP 3333: Python Web Server Gateway Interface v1.0.1 * Other Language Changes * New, Improved, and Deprecated Modules * email * elementtree * functools * itertools * collections * threading * datetime and time * math * abc * io * reprlib * logging * csv * contextlib * decimal and fractions * ftp * popen * select * gzip and zipfile * tarfile * hashlib * ast * os * shutil * sqlite3 * html * socket * ssl * nntp * certificates * imaplib * http.client * unittest * random * poplib * asyncore * tempfile * inspect * pydoc * dis * dbm * ctypes * site * sysconfig * pdb * configparser * urllib.parse * mailbox * turtledemo * Multi-threading * Optimizations * Unicode * Codecs * Documentation * IDLE * Code Repository * Build and C API Changes * Porting to Python 3.2 * What's New In Python 3.1 * PEP 372: Ordered Dictionaries * PEP 378: Format Specifier for Thousands Separator * Other Language Changes * New, Improved, and Deprecated Modules * Optimizations * IDLE * Build and C API Changes * Porting to Python 3.1 * What's New In Python 3.0 * Common Stumbling Blocks * Print Is A Function * Views And Iterators Instead Of Lists * Ordering Comparisons * Integers * Text Vs. Data Instead Of Unicode Vs. 8-bit * Overview Of Syntax Changes * New Syntax * Changed Syntax * Removed Syntax * Changes Already Present In Python 2.6 * Library Changes * **PEP 3101**: A New Approach To String Formatting * Changes To Exceptions * Miscellaneous Other Changes * Operators And Special Methods * Builtins * Build and C API Changes * Performance * Porting To Python 3.0 * 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 * Changelog * Python next * Core and Builtins * Library * Documentation * Tests * Python 3.10.1 final * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.10.0 final * Core and Builtins * Library * Documentation * Tests * Build * IDLE * C API * Python 3.10.0 release candidate 2 * Security * Core and Builtins * Library * Documentation * Tests * Windows * macOS * Python 3.10.0 release candidate 1 * Security * Core and Builtins * Library * Documentation * Tests * Windows * macOS * Tools/Demos * C API * Python 3.10.0 beta 4 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * C API * Python 3.10.0 beta 3 * Core and Builtins * Library * Documentation * Tests * Build * IDLE * C API * Python 3.10.0 beta 2 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.10.0 beta 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.10.0 alpha 7 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * IDLE * C API * Python 3.10.0 alpha 6 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.10.0 alpha 5 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.10.0 alpha 4 * Core and Builtins * Library * Documentation * Tests * Build * macOS * Tools/Demos * C API * Python 3.10.0 alpha 3 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.10.0 alpha 2 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.10.0 alpha 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.9.0 beta 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * Tools/Demos * C API * Python 3.9.0 alpha 6 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.9.0 alpha 5 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.9.0 alpha 4 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * IDLE * C API * Python 3.9.0 alpha 3 * Core and Builtins * Library * Documentation * Build * IDLE * C API * Python 3.9.0 alpha 2 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * C API * Python 3.9.0 alpha 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.8.0 beta 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.8.0 alpha 4 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.8.0 alpha 3 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * IDLE * Tools/Demos * C API * Python 3.8.0 alpha 2 * Core and Builtins * Library * Documentation * Tests * Windows * IDLE * Python 3.8.0 alpha 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.7.0 final * Library * C API * Python 3.7.0 release candidate 1 * Core and Builtins * Library * Documentation * Build * Windows * IDLE * Python 3.7.0 beta 5 * Core and Builtins * Library * Documentation * Tests * Build * macOS * IDLE * Python 3.7.0 beta 4 * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * Python 3.7.0 beta 3 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.7.0 beta 2 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * Python 3.7.0 beta 1 * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * C API * Python 3.7.0 alpha 4 * Core and Builtins * Library * Documentation * Tests * Windows * Tools/Demos * C API * Python 3.7.0 alpha 3 * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.7.0 alpha 2 * Core and Builtins * Library * Documentation * Build * IDLE * C API * Python 3.7.0 alpha 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * IDLE * Tools/Demos * C API * Python 3.6.6 final * Python 3.6.6 release candidate 1 * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.6.5 final * Tests * Build * Python 3.6.5 release candidate 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.6.4 final * Python 3.6.4 release candidate 1 * Core and Builtins * Library * Documentation * Tests * Build * Windows * macOS * IDLE * Tools/Demos * C API * Python 3.6.3 final * Library * Build * Python 3.6.3 release candidate 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * IDLE * Tools/Demos * Python 3.6.2 final * Python 3.6.2 release candidate 2 * Security * Python 3.6.2 release candidate 1 * Core and Builtins * Library * Security * Library * IDLE * C API * Build * Documentation * Tools/Demos * Tests * Windows * Python 3.6.1 final * Core and Builtins * Build * Python 3.6.1 release candidate 1 * Core and Builtins * Library * IDLE * Windows * C API * Documentation * Tests * Build * Python 3.6.0 final * Python 3.6.0 release candidate 2 * Core and Builtins * Tools/Demos * Windows * Build * Python 3.6.0 release candidate 1 * Core and Builtins * Library * C API * Documentation * Tools/Demos * Python 3.6.0 beta 4 * Core and Builtins * Library * Documentation * Tests * Build * Python 3.6.0 beta 3 * Core and Builtins * Library * Windows * Build * Tests * Python 3.6.0 beta 2 * Core and Builtins * Library * Windows * C API * Build * Tests * Python 3.6.0 beta 1 * Core and Builtins * Library * IDLE * C API * Tests * Build * Tools/Demos * Windows * Python 3.6.0 alpha 4 * Core and Builtins * Library * IDLE * Tests * Windows * Build * Python 3.6.0 alpha 3 * Core and Builtins * Library * Security * Library * Security * Library * IDLE * C API * Build * Tools/Demos * Documentation * Tests * Python 3.6.0 alpha 2 * Core and Builtins * Library * Security * Library * Security * Library * IDLE * Documentation * Tests * Windows * Build * Windows * C API * Tools/Demos * Python 3.6.0 alpha 1 * Core and Builtins * Library * Security * Library * Security * Library * Security * Library * IDLE * Documentation * Tests * Build * Windows * Tools/Demos * C API * Python 3.5.5 final * Python 3.5.5 release candidate 1 * Security * Core and Builtins * Library * Python 3.5.4 final * Library * Python 3.5.4 release candidate 1 * Security * Core and Builtins * Library * Documentation * Tests * Build * Windows * C API * Python 3.5.3 final * Python 3.5.3 release candidate 1 * Core and Builtins * Library * Security * Library * Security * Library * IDLE * C API * Documentation * Tests * Tools/Demos * Windows * Build * Python 3.5.2 final * Core and Builtins * Tests * IDLE * Python 3.5.2 release candidate 1 * Core and Builtins * Security * Library * Security * Library * Security * Library * Security * Library * Security * Library * IDLE * Documentation * Tests * Build * Windows * Tools/Demos * Windows * Python 3.5.1 final * Core and Builtins * Windows * Python 3.5.1 release candidate 1 * Core and Builtins * Library * IDLE * Documentation * Tests * Build * Windows * Tools/Demos * Python 3.5.0 final * Build * Python 3.5.0 release candidate 4 * Library * Build * Python 3.5.0 release candidate 3 * Core and Builtins * Library * Python 3.5.0 release candidate 2 * Core and Builtins * Library * Python 3.5.0 release candidate 1 * Core and Builtins * Library * IDLE * Documentation * Tests * Python 3.5.0 beta 4 * Core and Builtins * Library * Build * Python 3.5.0 beta 3 * Core and Builtins * Library * Tests * Documentation * Build * Python 3.5.0 beta 2 * Core and Builtins * Library * Python 3.5.0 beta 1 * Core and Builtins * Library * IDLE * Tests * Documentation * Tools/Demos * Python 3.5.0 alpha 4 * Core and Builtins * Library * Build * Tests * Tools/Demos * C API * Python 3.5.0 alpha 3 * Core and Builtins * Library * Build * Tests * Tools/Demos * Python 3.5.0 alpha 2 * Core and Builtins * Library * Build * C API * Windows * Python 3.5.0 alpha 1 * Core and Builtins * Library * IDLE * Build * C API * Documentation * Tests * Tools/Demos * Windows * 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. 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. "match" Statements * 4.7. Defining Functions * 4.8. More on Defining Functions * 4.8.1. Default Argument Values * 4.8.2. Keyword Arguments * 4.8.3. Special parameters * 4.8.3.1. Positional-or-Keyword Arguments * 4.8.3.2. Positional-Only Parameters * 4.8.3.3. Keyword-Only Arguments * 4.8.3.4. Function Examples * 4.8.3.5. Recap * 4.8.4. Arbitrary Argument Lists * 4.8.5. Unpacking Argument Lists * 4.8.6. Lambda Expressions * 4.8.7. Documentation Strings * 4.8.8. Function Annotations * 4.9. 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. List Comprehensions * 5.1.4. 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. Formatted String Literals * 7.1.2. The String format() Method * 7.1.3. Manual String Formatting * 7.1.4. 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. Exception Chaining * 8.6. User-defined Exceptions * 8.7. Defining Clean-up Actions * 8.8. Predefined Clean-up Actions * 9. Classes * 9.1. A Word About Names and Objects * 9.2. Python Scopes and Namespaces * 9.2.1. Scopes and Namespaces Example * 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 * 9.7. Odds and Ends * 9.8. Iterators * 9.9. Generators * 9.10. 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. Virtual Environments and Packages * 12.1. Introduction * 12.2. Creating Virtual Environments * 12.3. Managing Packages with pip * 13. What Now? * 14. Interactive Input Editing and History Substitution * 14.1. Tab Completion and History Editing * 14.2. Alternatives to the Interactive Interpreter * 15. Floating Point Arithmetic: Issues and Limitations * 15.1. Representation Error * 16. Appendix * 16.1. Interactive Mode * 16.1.1. Error Handling * 16.1.2. Executable Python Scripts * 16.1.3. The Interactive Startup File * 16.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. Custom OpenSSL * 3. Configure Python * 3.1. Configure Options * 3.1.1. General Options * 3.1.2. Install Options * 3.1.3. Performance options * 3.1.4. Python Debug Build * 3.1.5. Debug options * 3.1.6. Linker options * 3.1.7. Libraries options * 3.1.8. Security Options * 3.1.9. macOS Options * 3.2. Python Build System * 3.2.1. Main files of the build system * 3.2.2. Main build steps * 3.2.3. Main Makefile targets * 3.2.4. C extensions * 3.3. Compiler and linker flags * 3.3.1. Preprocessor flags * 3.3.2. Compiler flags * 3.3.3. Linker flags * 4. Using Python on Windows * 4.1. The full installer * 4.1.1. Installation steps * 4.1.2. Removing the MAX_PATH Limitation * 4.1.3. Installing Without UI * 4.1.4. Installing Without Downloading * 4.1.5. Modifying an install * 4.2. The Microsoft Store package * 4.2.1. Known Issues * 4.3. The nuget.org packages * 4.4. The embeddable package * 4.4.1. Python Application * 4.4.2. Embedding Python * 4.5. Alternative bundles * 4.6. Configuring Python * 4.6.1. Excursus: Setting environment variables * 4.6.2. Finding the Python executable * 4.7. UTF-8 mode * 4.8. Python Launcher for Windows * 4.8.1. Getting started * 4.8.1.1. From the command-line * 4.8.1.2. Virtual environments * 4.8.1.3. From a script * 4.8.1.4. From file associations * 4.8.2. Shebang Lines * 4.8.3. Arguments in shebang lines * 4.8.4. Customization * 4.8.4.1. Customization via INI files * 4.8.4.2. Customizing default Python versions * 4.8.5. Diagnostics * 4.9. Finding modules * 4.10. Additional modules * 4.10.1. PyWin32 * 4.10.2. cx_Freeze * 4.10.3. WConio * 4.11. Compiling Python on Windows * 4.12. Other Platforms * 5. Using Python on a Mac * 5.1. Getting and Installing MacPython * 5.1.1. How to run a Python script * 5.1.2. Running scripts with a GUI * 5.1.3. Configuration * 5.2. The IDE * 5.3. Installing Additional Python Packages * 5.4. GUI Programming on the Mac * 5.5. Distributing Python Applications on the Mac * 5.6. Other Resources * 6. Editors and IDEs * 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. Soft Keywords * 2.3.3. Reserved classes of identifiers * 2.4. Literals * 2.4.1. String and Bytes literals * 2.4.2. String literal concatenation * 2.4.3. Formatted string literals * 2.4.4. Numeric literals * 2.4.5. Integer literals * 2.4.6. Floating point literals * 2.4.7. 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. Special method names * 3.3.1. Basic customization * 3.3.2. Customizing attribute access * 3.3.2.1. Customizing module attribute access * 3.3.2.2. Implementing Descriptors * 3.3.2.3. Invoking Descriptors * 3.3.2.4. __slots__ * 3.3.2.4.1. Notes on using *__slots__* * 3.3.3. Customizing class creation * 3.3.3.1. Metaclasses * 3.3.3.2. Resolving MRO entries * 3.3.3.3. Determining the appropriate metaclass * 3.3.3.4. Preparing the class namespace * 3.3.3.5. Executing the class body * 3.3.3.6. Creating the class object * 3.3.3.7. Uses for metaclasses * 3.3.4. Customizing instance and subclass checks * 3.3.5. Emulating generic types * 3.3.5.1. The purpose of *__class_getitem__* * 3.3.5.2. *__class_getitem__* versus *__getitem__* * 3.3.6. Emulating callable objects * 3.3.7. Emulating container types * 3.3.8. Emulating numeric types * 3.3.9. With Statement Context Managers * 3.3.10. Customizing positional arguments in class pattern matching * 3.3.11. Special method lookup * 3.4. Coroutines * 3.4.1. Awaitable Objects * 3.4.2. Coroutine Objects * 3.4.3. Asynchronous Iterators * 3.4.4. Asynchronous Context Managers * 4. Execution model * 4.1. Structure of a program * 4.2. Naming and binding * 4.2.1. Binding of names * 4.2.2. Resolution of names * 4.2.3. Builtins and restricted execution * 4.2.4. Interaction with dynamic features * 4.3. Exceptions * 5. The import system * 5.1. "importlib" * 5.2. Packages * 5.2.1. Regular packages * 5.2.2. Namespace packages * 5.3. Searching * 5.3.1. The module cache * 5.3.2. Finders and loaders * 5.3.3. Import hooks * 5.3.4. The meta path * 5.4. Loading * 5.4.1. Loaders * 5.4.2. Submodules * 5.4.3. Module spec * 5.4.4. Import-related module attributes * 5.4.5. module.__path__ * 5.4.6. Module reprs * 5.4.7. Cached bytecode invalidation * 5.5. The Path Based Finder * 5.5.1. Path entry finders * 5.5.2. Path entry finder protocol * 5.6. Replacing the standard import system * 5.7. Package Relative Imports * 5.8. Special considerations for __main__ * 5.8.1. __main__.__spec__ * 5.9. Open issues * 5.10. References * 6. Expressions * 6.1. Arithmetic conversions * 6.2. Atoms * 6.2.1. Identifiers (Names) * 6.2.2. Literals * 6.2.3. Parenthesized forms * 6.2.4. Displays for lists, sets and dictionaries * 6.2.5. List displays * 6.2.6. Set displays * 6.2.7. Dictionary displays * 6.2.8. Generator expressions * 6.2.9. Yield expressions * 6.2.9.1. Generator-iterator methods * 6.2.9.2. Examples * 6.2.9.3. Asynchronous generator functions * 6.2.9.4. Asynchronous generator-iterator methods * 6.3. Primaries * 6.3.1. Attribute references * 6.3.2. Subscriptions * 6.3.3. Slicings * 6.3.4. Calls * 6.4. Await expression * 6.5. The power operator * 6.6. Unary arithmetic and bitwise operations * 6.7. Binary arithmetic operations * 6.8. Shifting operations * 6.9. Binary bitwise operations * 6.10. Comparisons * 6.10.1. Value comparisons * 6.10.2. Membership test operations * 6.10.3. Identity comparisons * 6.11. Boolean operations * 6.12. Assignment expressions * 6.13. Conditional expressions * 6.14. Lambdas * 6.15. Expression lists * 6.16. Evaluation order * 6.17. Operator precedence * 7. Simple statements * 7.1. Expression statements * 7.2. Assignment statements * 7.2.1. Augmented assignment statements * 7.2.2. Annotated assignment statements * 7.3. The "assert" statement * 7.4. The "pass" statement * 7.5. The "del" statement * 7.6. The "return" statement * 7.7. The "yield" statement * 7.8. The "raise" statement * 7.9. The "break" statement * 7.10. The "continue" statement * 7.11. The "import" statement * 7.11.1. Future statements * 7.12. The "global" statement * 7.13. The "nonlocal" statement * 8. Compound statements * 8.1. The "if" statement * 8.2. The "while" statement * 8.3. The "for" statement * 8.4. The "try" statement * 8.5. The "with" statement * 8.6. The "match" statement * 8.6.1. Overview * 8.6.2. Guards * 8.6.3. Irrefutable Case Blocks * 8.6.4. Patterns * 8.6.4.1. OR Patterns * 8.6.4.2. AS Patterns * 8.6.4.3. Literal Patterns * 8.6.4.4. Capture Patterns * 8.6.4.5. Wildcard Patterns * 8.6.4.6. Value Patterns * 8.6.4.7. Group Patterns * 8.6.4.8. Sequence Patterns * 8.6.4.9. Mapping Patterns * 8.6.4.10. Class Patterns * 8.7. Function definitions * 8.8. Class definitions * 8.9. Coroutines * 8.9.1. Coroutine function definition * 8.9.2. The "async for" statement * 8.9.3. The "async with" statement * 9. Top-level components * 9.1. Complete Python programs * 9.2. File input * 9.3. Interactive input * 9.4. Expression input * 10. Full Grammar specification * The Python Standard Library * Introduction * Notes on availability * 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", "complex" * Bitwise Operations on Integer Types * Additional Methods on Integer Types * Additional Methods on Float * Hashing of numeric types * Iterator Types * Generator Types * Sequence Types --- "list", "tuple", "range" * Common Sequence Operations * Immutable Sequence Types * Mutable Sequence Types * Lists * Tuples * Ranges * Text Sequence Type --- "str" * String Methods * "printf"-style String Formatting * Binary Sequence Types --- "bytes", "bytearray", "memoryview" * Bytes Objects * Bytearray Objects * Bytes and Bytearray Operations * "printf"-style Bytes Formatting * Memory Views * Set Types --- "set", "frozenset" * Mapping Types --- "dict" * Dictionary view objects * Context Manager Types * Type Annotation Types --- *Generic Alias*, *Union* * Generic Alias Type * Standard Generic Collections * Special Attributes of Generic Alias * Union Type * 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 context * Inheriting from built-in exceptions * Base classes * Concrete exceptions * OS exceptions * Warnings * Exception hierarchy * Text Processing Services * "string" --- Common string operations * String constants * Custom String Formatting * Format String Syntax * Format Specification Mini-Language * Format examples * Template strings * Helper functions * "re" --- Regular expression operations * Regular Expression Syntax * Module Contents * Regular Expression Objects * Match Objects * Regular Expression 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 * Writing a Tokenizer * "difflib" --- Helpers for computing deltas * SequenceMatcher Objects * SequenceMatcher Examples * Differ Objects * Differ Example * A command-line interface to difflib * "textwrap" --- Text wrapping and filling * "unicodedata" --- Unicode Database * "stringprep" --- Internet String Preparation * "readline" --- GNU readline interface * Init file * Line buffer * History file * History list * Startup hooks * Completion * Example * "rlcompleter" --- Completion function for GNU readline * Completer Objects * Binary Data Services * "struct" --- Interpret bytes as packed binary data * Functions and Exceptions * Format Strings * Byte Order, Size, and Alignment * Format Characters * Examples * Classes * "codecs" --- Codec registry and base classes * Codec Base Classes * Error Handlers * Stateless Encoding and Decoding * Incremental Encoding and Decoding * IncrementalEncoder Objects * IncrementalDecoder Objects * Stream Encoding and Decoding * StreamWriter Objects * StreamReader Objects * StreamReaderWriter Objects * StreamRecoder Objects * Encodings and Unicode * Standard Encodings * Python Specific Encodings * Text Encodings * Binary Transforms * Text Transforms * "encodings.idna" --- Internationalized Domain Names in Applications * "encodings.mbcs" --- Windows ANSI codepage * "encodings.utf_8_sig" --- UTF-8 codec with BOM signature * Data Types * "datetime" --- Basic date and time types * Aware and Naive Objects * Constants * Available Types * Common Properties * Determining if an Object is Aware or Naive * "timedelta" Objects * Examples of usage: "timedelta" * "date" Objects * Examples of Usage: "date" * "datetime" Objects * Examples of Usage: "datetime" * "time" Objects * Examples of Usage: "time" * "tzinfo" Objects * "timezone" Objects * "strftime()" and "strptime()" Behavior * "strftime()" and "strptime()" Format Codes * Technical Detail * "zoneinfo" --- IANA time zone support * Using "ZoneInfo" * Data sources * Configuring the data sources * Compile-time configuration * Environment configuration * Runtime configuration * The "ZoneInfo" class * String representations * Pickle serialization * Functions * Globals * Exceptions and warnings * "calendar" --- General calendar-related functions * "collections" --- Container datatypes * "ChainMap" objects * "ChainMap" Examples and Recipes * "Counter" objects * "deque" objects * "deque" Recipes * "defaultdict" objects * "defaultdict" Examples * "namedtuple()" Factory Function for Tuples with Named Fields * "OrderedDict" objects * "OrderedDict" Examples and Recipes * "UserDict" objects * "UserList" objects * "UserString" objects * "collections.abc" --- Abstract Base Classes for Containers * Collections Abstract Base Classes * Collections Abstract Base Classes -- Detailed Descriptions * Examples and Recipes * "heapq" --- Heap queue algorithm * Basic Examples * Priority Queue Implementation Notes * Theory * "bisect" --- Array bisection algorithm * Performance Notes * Searching Sorted Lists * Examples * "array" --- Efficient arrays of numeric values * "weakref" --- Weak references * Weak Reference Objects * Example * Finalizer Objects * Comparing finalizers with "__del__()" methods * "types" --- Dynamic type creation and names for built-in types * Dynamic Type Creation * Standard Interpreter Types * Additional Utility Classes and Functions * Coroutine Utility Functions * "copy" --- Shallow and deep copy operations * "pprint" --- Data pretty printer * PrettyPrinter Objects * Example * "reprlib" --- Alternate "repr()" implementation * Repr Objects * Subclassing Repr Objects * "enum" --- Support for enumerations * Module Contents * Creating an Enum * Programmatic access to enumeration members and their attributes * Duplicating enum members and values * Ensuring unique enumeration values * Using automatic values * Iteration * Comparisons * Allowed members and attributes of enumerations * Restricted Enum subclassing * Pickling * Functional API * Derived Enumerations * IntEnum * IntFlag * Flag * Others * When to use "__new__()" vs. "__init__()" * Interesting examples * Omitting values * Using "auto" * Using "object" * Using a descriptive string * Using a custom "__new__()" * OrderedEnum * DuplicateFreeEnum * Planet * TimePeriod * How are Enums different? * Enum Classes * Enum Members (aka instances) * Finer Points * Supported "__dunder__" names * Supported "_sunder_" names * _Private__names * "Enum" member type * Boolean value of "Enum" classes and members * "Enum" classes with methods * Combining members of "Flag" * "graphlib" --- Functionality to operate with graph-like structures * Exceptions * 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 * Constants * Rounding modes * 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 * Bookkeeping functions * Functions for bytes * Functions for integers * Functions for sequences * Real-valued distributions * Alternative Generator * Notes on Reproducibility * Examples * Recipes * "statistics" --- Mathematical statistics functions * Averages and measures of central location * Measures of spread * Statistics for relations between two inputs * Function details * Exceptions * "NormalDist" objects * "NormalDist" Examples and Recipes * Functional Programming Modules * "itertools" --- Functions creating iterators for efficient looping * Itertool functions * Itertools Recipes * "functools" --- Higher-order functions and operations on callable objects * "partial" Objects * "operator" --- Standard operators as functions * Mapping Operators to Functions * In-place Operators * File and Directory Access * "pathlib" --- Object-oriented filesystem paths * Basic use * Pure paths * General properties * Operators * Accessing individual parts * Methods and properties * Concrete paths * Methods * Correspondence to tools in the "os" module * "os.path" --- Common pathname manipulations * "fileinput" --- Iterate over lines from multiple input streams * "stat" --- Interpreting "stat()" results * "filecmp" --- File and Directory Comparisons * The "dircmp" class * "tempfile" --- Generate temporary files and directories * Examples * Deprecated functions and variables * "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 * Platform-dependent efficient copy operations * copytree example * rmtree example * Archiving operations * Archiving example * Archiving example with *base_dir* * Querying the size of the output terminal * Data Persistence * "pickle" --- Python object serialization * Relationship to other Python modules * Comparison with "marshal" * Comparison with "json" * Data stream format * Module Interface * What can be pickled and unpickled? * Pickling Class Instances * Persistence of External Objects * Dispatch Tables * Handling Stateful Objects * Custom Reduction for Types, Functions, and Other Objects * Out-of-band Buffers * Provider API * Consumer API * Example * Restricting Globals * Performance * Examples * "copyreg" --- Register "pickle" support functions * Example * "shelve" --- Python object persistence * Restrictions * Example * "marshal" --- Internal Python object serialization * "dbm" --- Interfaces to Unix "databases" * "dbm.gnu" --- GNU's reinterpretation of dbm * "dbm.ndbm" --- Interface based on ndbm * "dbm.dumb" --- Portable DBM implementation * "sqlite3" --- DB-API 2.0 interface for SQLite databases * Module functions and constants * Connection Objects * Cursor Objects * Row Objects * Exceptions * SQLite and Python types * Introduction * Using adapters to store additional Python types in SQLite databases * Letting your object adapt itself * Registering an adapter callable * Converting SQLite values to custom Python types * Default adapters and converters * Controlling Transactions * Using "sqlite3" efficiently * Using shortcut methods * Accessing columns by name instead of by index * Using the connection as a context manager * Data Compression and Archiving * "zlib" --- Compression compatible with **gzip** * "gzip" --- Support for **gzip** files * Examples of usage * Command Line Interface * Command line options * "bz2" --- Support for **bzip2** compression * (De)compression of files * Incremental (de)compression * One-shot (de)compression * Examples of usage * "lzma" --- Compression using the LZMA algorithm * Reading and writing compressed files * Compressing and decompressing data in memory * Miscellaneous * Specifying custom filter chains * Examples * "zipfile" --- Work with ZIP archives * ZipFile Objects * Path Objects * PyZipFile Objects * ZipInfo Objects * Command-Line Interface * Command-line options * Decompression pitfalls * From file itself * File System limitations * Resources limitations * Interruption * Default behaviors of extraction * "tarfile" --- Read and write tar archive files * TarFile Objects * TarInfo Objects * Command-Line Interface * Command-line options * 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 * Quick Start * Supported Datatypes * Fallback Values * Supported INI File Structure * Interpolation of values * Mapping Protocol Access * Customizing Parser Behaviour * Legacy API Examples * ConfigParser Objects * RawConfigParser Objects * Exceptions * "netrc" --- netrc file processing * netrc Objects * "xdrlib" --- Encode and decode XDR data * Packer Objects * Unpacker Objects * Exceptions * "plistlib" --- Generate and parse Apple ".plist" files * Examples * Cryptographic Services * "hashlib" --- Secure hashes and message digests * Hash algorithms * SHAKE variable length digests * Key derivation * BLAKE2 * Creating hash objects * Constants * Examples * Simple hashing * Using different digest sizes * Keyed hashing * Randomized hashing * Personalization * Tree mode * Credits * "hmac" --- Keyed-Hashing for Message Authentication * "secrets" --- Generate secure random numbers for managing secrets * Random numbers * Generating tokens * How many bytes should tokens use? * Other functions * Recipes and best practices * Generic Operating System Services * "os" --- Miscellaneous operating system interfaces * File Names, Command Line Arguments, and Environment Variables * Python UTF-8 Mode * Process Parameters * File Object Creation * File Descriptor Operations * Querying the size of a terminal * Inheritance of File Descriptors * Files and Directories * Linux extended attributes * Process Management * Interface to the scheduler * Miscellaneous System Information * Random numbers * "io" --- Core tools for working with streams * Overview * Text I/O * Binary I/O * Raw I/O * Text Encoding * Opt-in EncodingWarning * High-level Module Interface * Class hierarchy * I/O Base Classes * Raw File I/O * Buffered Streams * Text I/O * Performance * Binary I/O * Text I/O * Multi-threading * Reentrancy * "time" --- Time access and conversions * Functions * Clock ID Constants * Timezone Constants * "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 * allow_abbrev * conflict_handler * add_help * exit_on_error * 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 * Intermixed parsing * Upgrading optparse code * "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 * Module-Level Attributes * 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 * BaseRotatingHandler * RotatingFileHandler * TimedRotatingFileHandler * SocketHandler * DatagramHandler * SysLogHandler * NTEventLogHandler * SMTPHandler * MemoryHandler * HTTPHandler * QueueHandler * QueueListener * "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 * macOS Platform * Unix Platforms * Linux 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 * Concurrent Execution * "threading" --- Thread-based parallelism * Thread-Local Data * Thread Objects * Lock Objects * RLock Objects * Condition Objects * Semaphore Objects * "Semaphore" Example * Event Objects * Timer Objects * Barrier Objects * Using locks, conditions, and semaphores in the "with" statement * "multiprocessing" --- Process-based parallelism * Introduction * The "Process" class * Contexts and start methods * Exchanging objects between processes * Synchronization between processes * Sharing state between processes * Using a pool of workers * Reference * "Process" and exceptions * Pipes and Queues * Miscellaneous * Connection Objects * Synchronization primitives * Shared "ctypes" Objects * The "multiprocessing.sharedctypes" module * Managers * Customized managers * Using a remote manager * Proxy Objects * Cleanup * Process Pools * Listeners and Clients * Address Formats * Authentication keys * Logging * The "multiprocessing.dummy" module * Programming guidelines * All start methods * The *spawn* and *forkserver* start methods * Examples * "multiprocessing.shared_memory" --- Provides shared memory for direct access across processes * The "concurrent" package * "concurrent.futures" --- Launching parallel tasks * Executor Objects * ThreadPoolExecutor * ThreadPoolExecutor Example * ProcessPoolExecutor * ProcessPoolExecutor Example * Future Objects * Module Functions * Exception classes * "subprocess" --- Subprocess management * Using the "subprocess" Module * Frequently Used Arguments * Popen Constructor * Exceptions * Security Considerations * Popen Objects * Windows Popen Helpers * Windows Constants * Older high-level API * Replacing Older Functions with the "subprocess" Module * Replacing **/bin/sh** shell command substitution * Replacing shell pipeline * Replacing "os.system()" * Replacing the "os.spawn" family * Replacing "os.popen()", "os.popen2()", "os.popen3()" * Replacing functions from the "popen2" module * Legacy Shell Invocation Functions * Notes * Converting an argument sequence to a string on Windows * "sched" --- Event scheduler * Scheduler Objects * "queue" --- A synchronized queue class * Queue Objects * SimpleQueue Objects * "contextvars" --- Context Variables * Context Variables * Manual Context Management * asyncio support * "_thread" --- Low-level threading API * Networking and Interprocess Communication * "asyncio" --- Asynchronous I/O * Coroutines and Tasks * Coroutines * Awaitables * Running an asyncio Program * Creating Tasks * Sleeping * Running Tasks Concurrently * Shielding From Cancellation * Timeouts * Waiting Primitives * Running in Threads * Scheduling From Other Threads * Introspection * Task Object * Generator-based Coroutines * Streams * StreamReader * StreamWriter * Examples * TCP echo client using streams * TCP echo server using streams * Get HTTP headers * Register an open socket to wait for data using streams * Synchronization Primitives * Lock * Event * Condition * Semaphore * BoundedSemaphore * Subprocesses * Creating Subprocesses * Constants * Interacting with Subprocesses * Subprocess and Threads * Examples * Queues * Queue * Priority Queue * LIFO Queue * Exceptions * Examples * Exceptions * Event Loop * Event Loop Methods * Running and stopping the loop * Scheduling callbacks * Scheduling delayed callbacks * Creating Futures and Tasks * Opening network connections * Creating network servers * Transferring files * TLS Upgrade * Watching file descriptors * Working with socket objects directly * DNS * Working with pipes * Unix signals * Executing code in thread or process pools * Error Handling API * Enabling debug mode * Running Subprocesses * Callback Handles * Server Objects * Event Loop Implementations * Examples * Hello World with call_soon() * Display the current date with call_later() * Watch a file descriptor for read events * Set signal handlers for SIGINT and SIGTERM * Futures * Future Functions * Future Object * Transports and Protocols * Transports * Transports Hierarchy * Base Transport * Read-only Transports * Write-only Transports * Datagram Transports * Subprocess Transports * Protocols * Base Protocols * Base Protocol * Streaming Protocols * Buffered Streaming Protocols * Datagram Protocols * Subprocess Protocols * Examples * TCP Echo Server * TCP Echo Client * UDP Echo Server * UDP Echo Client * Connecting Existing Sockets * loop.subprocess_exec() and SubprocessProtocol * Policies * Getting and Setting the Policy * Policy Objects * Process Watchers * Custom Policies * Platform Support * All Platforms * Windows * Subprocess Support on Windows * macOS * High-level API Index * Tasks * Queues * Subprocesses * Streams * Synchronization * Exceptions * Low-level API Index * Obtaining the Event Loop * Event Loop Methods * Transports * Protocols * Event Loop Policies * Developing with asyncio * Debug Mode * Concurrency and Multithreading * Running Blocking Code * Logging * Detect never-awaited coroutines * Detect never-retrieved exceptions * "socket" --- Low-level networking interface * Socket families * Module contents * Exceptions * Constants * Functions * Creating sockets * Other functions * Socket Objects * Notes on socket timeouts * Timeouts and the "connect" method * Timeouts and the "accept" method * Example * "ssl" --- TLS/SSL wrapper for socket objects * Functions, Constants, and Exceptions * Socket creation * Context creation * Exceptions * 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 * Memory BIO Support * SSL session * Security considerations * Best defaults * Manual settings * Verifying certificates * Protocol versions * Cipher selection * Multi-processing * TLS 1.3 * "select" --- Waiting for I/O completion * "/dev/poll" Polling Objects * Edge and Level Trigger Polling (epoll) Objects * Polling Objects * Kqueue Objects * Kevent Objects * "selectors" --- High-level I/O multiplexing * Introduction * Classes * Examples * "asyncore" --- Asynchronous socket handler * asyncore Example basic HTTP client * asyncore Example basic echo server * "asynchat" --- Asynchronous socket command/response handler * asynchat Example * "signal" --- Set handlers for asynchronous events * General rules * Execution of Python signal handlers * Signals and threads * Module contents * Example * Note on SIGPIPE * "mmap" --- Memory-mapped file support * MADV_* Constants * MAP_* Constants * Internet Data Handling * "email" --- An email and MIME handling package * "email.message": Representing an email message * "email.parser": Parsing email messages * FeedParser API * Parser API * Additional notes * "email.generator": Generating MIME documents * "email.policy": Policy Objects * "email.errors": Exception and Defect classes * "email.headerregistry": Custom Header Objects * "email.contentmanager": Managing MIME Content * Content Manager Instances * "email": Examples * "email.message.Message": Representing an email message using the "compat32" API * "email.mime": Creating email and MIME objects from scratch * "email.header": Internationalized headers * "email.charset": Representing character sets * "email.encoders": Encoders * "email.utils": Miscellaneous utilities * "email.iterators": Iterators * "json" --- JSON encoder and decoder * Basic Usage * Encoders and Decoders * Exceptions * 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 * Command Line Interface * Command line options * "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 * Examples * "mimetypes" --- Map filenames to MIME types * MimeTypes Objects * "base64" --- Base16, Base32, Base64, Base85 Data Encodings * Security Considerations * "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 * "html" --- HyperText Markup Language support * "html.parser" --- Simple HTML and XHTML parser * Example HTML Parser Application * "HTMLParser" Methods * Examples * "html.entities" --- Definitions of HTML general entities * XML Processing Modules * XML vulnerabilities * The "defusedxml" Package * "xml.etree.ElementTree" --- The ElementTree XML API * Tutorial * XML tree and elements * Parsing XML * Pull API for non-blocking parsing * Finding interesting elements * Modifying an XML File * Building XML documents * Parsing XML with Namespaces * Additional resources * XPath support * Example * Supported XPath syntax * Reference * Functions * XInclude support * Example * Reference * Functions * Element Objects * ElementTree Objects * QName Objects * TreeBuilder Objects * XMLParser Objects * XMLPullParser Objects * Exceptions * "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 * LexicalHandler 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 * 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" --- URL handling modules * "urllib.request" --- Extensible library for opening URLs * Request Objects * OpenerDirector Objects * BaseHandler Objects * HTTPRedirectHandler Objects * HTTPCookieProcessor Objects * ProxyHandler Objects * HTTPPasswordMgr Objects * HTTPPasswordMgrWithPriorAuth Objects * AbstractBasicAuthHandler Objects * HTTPBasicAuthHandler Objects * ProxyBasicAuthHandler Objects * AbstractDigestAuthHandler Objects * HTTPDigestAuthHandler Objects * ProxyDigestAuthHandler Objects * HTTPHandler Objects * HTTPSHandler Objects * FileHandler Objects * DataHandler Objects * FTPHandler Objects * CacheFTPHandler Objects * UnknownHandler Objects * HTTPErrorProcessor Objects * Examples * Legacy interface * "urllib.request" Restrictions * "urllib.response" --- Response classes used by urllib * "urllib.parse" --- Parse URLs into components * URL Parsing * Parsing ASCII Encoded Bytes * Structured Parse Results * URL Quoting * "urllib.error" --- Exception classes raised by urllib.request * "urllib.robotparser" --- Parser for robots.txt * "http" --- HTTP modules * HTTP status codes * "http.client" --- HTTP protocol client * HTTPConnection Objects * HTTPResponse Objects * Examples * HTTPMessage Objects * "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 * Attributes * Methods * Utility functions * "smtplib" --- SMTP protocol client * SMTP Objects * SMTP Example * "smtpd" --- SMTP Server * SMTPServer Objects * DebuggingServer Objects * PureProxy Objects * MailmanProxy Objects * SMTPChannel Objects * "telnetlib" --- Telnet client * Telnet Objects * Telnet Example * "uuid" --- UUID objects according to **RFC 4122** * Example * "socketserver" --- A framework for network servers * Server Creation Notes * Server Objects * Request Handler Objects * Examples * "socketserver.TCPServer" Example * "socketserver.UDPServer" Example * Asynchronous Mixins * "http.server" --- HTTP servers * "http.cookies" --- HTTP state management * Cookie Objects * Morsel Objects * Example * "http.cookiejar" --- Cookie handling for HTTP clients * CookieJar and FileCookieJar Objects * FileCookieJar subclasses and co-operation with web browsers * CookiePolicy Objects * DefaultCookiePolicy Objects * Cookie Objects * Examples * "xmlrpc" --- XMLRPC server and client modules * "xmlrpc.client" --- XML-RPC client access * ServerProxy Objects * DateTime Objects * Binary Objects * Fault Objects * ProtocolError Objects * MultiCall Objects * Convenience Functions * Example of Client Usage * Example of Client and Server Usage * "xmlrpc.server" --- Basic XML-RPC servers * SimpleXMLRPCServer Objects * SimpleXMLRPCServer Example * CGIXMLRPCRequestHandler * Documenting XMLRPC server * DocXMLRPCServer Objects * DocCGIXMLRPCRequestHandler * "ipaddress" --- IPv4/IPv6 manipulation library * Convenience factory functions * IP Addresses * Address objects * Conversion to Strings and Integers * Operators * Comparison operators * Arithmetic operators * IP Network definitions * Prefix, net mask and host mask * Network objects * Operators * Logical operators * Iteration * Networks as containers of addresses * Interface objects * Operators * Logical operators * Other Module Level Functions * Custom Exceptions * Multimedia Services * "audioop" --- Manipulate raw audio 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 * Acknowledgements * "locale" --- Internationalization services * Background, details, hints, tips and caveats * For extension writers and programs that embed Python * Access to message catalogs * Program Frameworks * "turtle" --- Turtle graphics * Introduction * Overview of 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 * Compound shapes * Methods of TurtleScreen/Screen and corresponding functions * Window control * Animation control * Using screen events * Input methods * Settings and special methods * Methods specific to Screen, not inherited from TurtleScreen * Public classes * Help and configuration * How to use help * Translation of docstrings into different languages * How to configure Screen and Turtles * "turtledemo" --- Demo scripts * Changes since Python 2.6 * Changes since Python 3.0 * "cmd" --- Support for line-oriented command interpreters * Cmd Objects * Cmd Example * "shlex" --- Simple lexical analysis * shlex Objects * Parsing Rules * Improved Compatibility with Shells * Graphical User Interfaces with Tk * "tkinter" --- Python interface to Tcl/Tk * Architecture * Tkinter Modules * Tkinter Life Preserver * A Hello World Program * Important Tk Concepts * Understanding How Tkinter Wraps Tcl/Tk * How do I...? What option does...? * Navigating the Tcl/Tk Reference Manual * Threading model * 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 * "tkinter.colorchooser" --- Color choosing dialog * "tkinter.font" --- Tkinter font wrapper * Tkinter Dialogs * "tkinter.simpledialog" --- Standard Tkinter input dialogs * "tkinter.filedialog" --- File selection dialogs * Native Load/Save Dialogs * "tkinter.commondialog" --- Dialog window templates * "tkinter.messagebox" --- Tkinter message prompts * "tkinter.scrolledtext" --- Scrolled Text Widget * "tkinter.dnd" --- Drag and drop support * "tkinter.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 * Spinbox * Options * Virtual events * ttk.Spinbox * 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 * "tkinter.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 * 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 * Editor windows * Key bindings * Automatic indentation * Completions * Calltips * Code Context * Python Shell window * Text colors * Startup and code execution * Command line usage * Startup failure * Running user code * User output in Shell * Developing tkinter applications * Running without a subprocess * Help and preferences * Help sources * Setting preferences * IDLE on macOS * Extensions * Development Tools * "typing" --- Support for type hints * Relevant PEPs * Type aliases * NewType * Callable * Generics * User-defined generic types * The "Any" type * Nominal vs structural subtyping * Module contents * Special typing primitives * Special types * Special forms * Building generic types * Other special directives * Generic concrete collections * Corresponding to built-in types * Corresponding to types in "collections" * Other concrete types * Abstract Base Classes * Corresponding to collections in "collections.abc" * Corresponding to other types in "collections.abc" * Asynchronous programming * Context manager types * Protocols * Functions and decorators * Introspection helpers * Constant * "pydoc" --- Documentation generator and online help system * Python Development Mode * Effects of the Python Development Mode * ResourceWarning Example * Bad file descriptor error example * "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 * Distinguishing test iterations using subtests * 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 * "unittest.mock" --- mock object library * Quick Guide * The Mock Class * Calling * Deleting Attributes * Mock names and the name attribute * Attaching Mocks as Attributes * The patchers * patch * patch.object * patch.dict * patch.multiple * patch methods: start and stop * patch builtins * TEST_PREFIX * Nesting Patch Decorators * Where to patch * Patching Descriptors and Proxy Objects * MagicMock and magic method support * Mocking Magic Methods * Magic Mock * Helpers * sentinel * DEFAULT * call * create_autospec * ANY * FILTER_DIR * mock_open * Autospeccing * Sealing mocks * "unittest.mock" --- getting started * Using Mock * Mock Patching Methods * Mock for Method Calls on an Object * Mocking Classes * Naming your mocks * Tracking all Calls * Setting Return Values and Attributes * Raising exceptions with mocks * Side effect functions and iterables * Mocking asynchronous iterators * Mocking asynchronous context manager * Creating a Mock from an Existing Object * Patch Decorators * Further Examples * Mocking chained calls * Partial mocking * Mocking a Generator Method * Applying the same patch to every test method * Mocking Unbound Methods * Checking multiple calls with mock * Coping with mutable arguments * Nesting Patches * Mocking a dictionary with MagicMock * Mock subclasses and their attributes * Mocking imports with patch.dict * Tracking order of calls and less verbose call assertions * More complex argument matching * 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.support" --- Utilities for the Python test suite * "test.support.socket_helper" --- Utilities for socket tests * "test.support.script_helper" --- Utilities for the Python execution tests * "test.support.bytecode_helper" --- Support tools for testing correct bytecode generation * "test.support.threading_helper" --- Utilities for threading tests * "test.support.os_helper" --- Utilities for os tests * "test.support.import_helper" --- Utilities for import tests * "test.support.warnings_helper" --- Utilities for warnings tests * Debugging and Profiling * Audit events table * "bdb" --- Debugger framework * "faulthandler" --- Dump the Python traceback * Dumping the traceback * Fault handler state * Dumping the tracebacks after a timeout * Dumping the traceback on a user signal * Issue with file descriptors * Example * "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 * "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 * "tracemalloc" --- Trace memory allocations * Examples * Display the top 10 * Compute differences * Get the traceback of a memory block * Pretty top * Record the current and peak size of all traced memory blocks * API * Functions * DomainFilter * Filter * Frame * Snapshot * Statistic * StatisticDiff * Trace * Traceback * Software Packaging and Distribution * "distutils" --- Building and installing Python modules * "ensurepip" --- Bootstrapping the "pip" installer * Command line interface * Module API * "venv" --- Creation of virtual environments * Creating virtual environments * API * An example of extending "EnvBuilder" * "zipapp" --- Manage executable Python zip archives * Basic Example * Command-Line Interface * Python API * Examples * Specifying the Interpreter * Creating Standalone Applications with zipapp * Making a Windows executable * Caveats * The Python Zip Application Archive Format * Python Runtime Services * "sys" --- System-specific parameters and functions * "sysconfig" --- Provide access to Python's configuration information * Configuration variables * Installation paths * Other functions * Using "sysconfig" as a script * "builtins" --- Built-in objects * "__main__" --- Top-level code environment * "__name__ == '__main__'" * What is the "top-level code environment"? * Idiomatic Usage * Packaging Considerations * "__main__.py" in Python Packages * Idiomatic Usage * "import __main__" * "warnings" --- Warning control * Warning Categories * The Warnings Filter * Describing Warning Filters * Default Warning Filter * Overriding the default filter * Temporarily Suppressing Warnings * Testing Warnings * Updating Code For New Versions of Dependencies * Available Functions * Available Context Managers * "dataclasses" --- Data Classes * Module contents * Post-init processing * Class variables * Init-only variables * Frozen instances * Inheritance * Re-ordering of keyword-only parameters in "__init__()" * Default factory functions * Mutable default values * "contextlib" --- Utilities for "with"-statement contexts * Utilities * Examples and Recipes * Supporting a variable number of context managers * Catching exceptions from "__enter__" methods * Cleaning up in an "__enter__" implementation * Replacing any use of "try-finally" and flag variables * Using a context manager as a function decorator * Single use, reusable and reentrant context managers * Reentrant context managers * Reusable context managers * "abc" --- Abstract Base Classes * "atexit" --- Exit handlers * "atexit" Example * "traceback" --- Print or retrieve a stack traceback * "TracebackException" Objects * "StackSummary" Objects * "FrameSummary" Objects * Traceback Examples * "__future__" --- Future statement definitions * "gc" --- Garbage Collector interface * "inspect" --- Inspect live objects * Types and members * Retrieving source code * Introspecting callables with the Signature object * Classes and functions * The interpreter stack * Fetching attributes statically * Current State of Generators and Coroutines * Code Objects Bit Flags * Command Line Interface * "site" --- Site-specific configuration hook * Readline configuration * Module contents * Command Line Interface * Custom Python Interpreters * "code" --- Interpreter base classes * Interactive Interpreter Objects * Interactive Console Objects * "codeop" --- Compile Python code * Importing Modules * "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 * "importlib" --- The implementation of "import" * Introduction * Functions * "importlib.abc" -- Abstract base classes related to import * "importlib.resources" -- Resources * "importlib.machinery" -- Importers and path hooks * "importlib.util" -- Utility code for importers * Examples * Importing programmatically * Checking if a module can be imported * Importing a source file directly * Implementing lazy imports * Setting up an importer * Approximating "importlib.import_module()" * Using "importlib.metadata" * Overview * Functional API * Entry points * Distribution metadata * Distribution versions * Distribution files * Distribution requirements * Package distributions * Distributions * Extending the search algorithm * Python Language Services * "ast" --- Abstract Syntax Trees * Abstract Grammar * Node classes * Literals * Variables * Expressions * Subscripting * Comprehensions * Statements * Imports * Control flow * Pattern matching * Function and class definitions * Async and await * "ast" Helpers * Compiler Flags * Command-Line Usage * "symtable" --- Access to the compiler's symbol tables * Generating Symbol Tables * Examining Symbol Tables * "token" --- Constants used with Python parse trees * "keyword" --- Testing for Python keywords * "tokenize" --- Tokenizer for Python source * Tokenizing Input * Command-Line Usage * Examples * "tabnanny" --- Detection of ambiguous indentation * "pyclbr" --- Python module browser support * Function Objects * Class Objects * "py_compile" --- Compile Python source files * Command-Line Interface * "compileall" --- Byte-compile Python libraries * Command-line use * Public functions * "dis" --- Disassembler for Python bytecode * Bytecode analysis * Analysis functions * Python Bytecode Instructions * Opcode collections * "pickletools" --- Tools for pickle developers * Command line usage * Command line options * Programmatic Interface * 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 * Functions * 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 * Hashing Methods * Module Attributes * Module Functions * Examples * "termios" --- POSIX style tty control * Example * "tty" --- Terminal control functions * "pty" --- Pseudo-terminal utilities * Example * "fcntl" --- The "fcntl" and "ioctl" system calls * "pipes" --- Interface to shell pipelines * Template Objects * "resource" --- Resource usage information * Resource Limits * Resource Usage * "nis" --- Interface to Sun's NIS (Yellow Pages) * "syslog" --- Unix syslog library routines * Examples * Simple example * Superseded Modules * "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 * "imp" --- Access the *import* internals * Examples * Undocumented Modules * Platform specific modules * Security Considerations * Extending and Embedding the Python Interpreter * Recommended third party tools * Creating extensions without third party tools * 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 Extension Types: Tutorial * 2.1. The Basics * 2.2. Adding data and methods to the Basic example * 2.3. Providing finer control over data attributes * 2.4. Supporting cyclic garbage collection * 2.5. Subclassing other types * 3. Defining Extension Types: Assorted Topics * 3.1. Finalization and De-allocation * 3.2. Object Presentation * 3.3. Attribute Management * 3.3.1. Generic Attribute Management * 3.3.2. Type-specific Attribute Management * 3.4. Object Comparison * 3.5. Abstract Protocol Support * 3.6. Weak Reference Support * 3.7. More Suggestions * 4. Building C and C++ Extensions * 4.1. Building C and C++ Extensions with distutils * 4.2. Distributing your extension modules * 5. Building C and C++ Extensions on Windows * 5.1. A Cookbook Approach * 5.2. Differences Between Unix and Windows * 5.3. Using DLLs in Practice * Embedding the CPython runtime in a larger application * 1. Embedding Python in Another Application * 1.1. Very High Level Embedding * 1.2. Beyond Very High Level Embedding: An overview * 1.3. Pure Embedding * 1.4. Extending Embedded Python * 1.5. Embedding Python in C++ * 1.6. Compiling and Linking under Unix-like systems * Python/C API Reference Manual * Introduction * Coding standards * Include Files * Useful macros * Objects, Types and Reference Counts * Reference Counts * Reference Count Details * Types * Exceptions * Embedding Python * Debugging Builds * C API Stability * Stable Application Binary Interface * Limited API Scope and Performance * Limited API Caveats * Platform Considerations * Contents of Limited API * The Very High Level Layer * Reference Counting * Exception Handling * Printing and clearing * Raising exceptions * Issuing warnings * Querying the error indicator * Signal Handling * Exception Classes * Exception Objects * Unicode Exception Objects * Recursion Control * Standard Exceptions * Standard Warning Categories * Utilities * Operating System Utilities * System Functions * Process Control * Importing Modules * Data marshalling support * Parsing arguments and building values * Parsing arguments * Strings and buffers * Numbers * Other objects * API Functions * 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 * Call Protocol * The *tp_call* Protocol * The Vectorcall Protocol * Recursion Control * Vectorcall Support API * Object Calling API * Call Support API * Number Protocol * Sequence Protocol * Mapping Protocol * Iterator Protocol * Buffer Protocol * Buffer structure * Buffer request types * request-independent fields * readonly, format * shape, strides, suboffsets * contiguity requests * compound requests * Complex arrays * NumPy-style: shape and strides * PIL-style: shape, strides and suboffsets * Buffer-related functions * Old Buffer Protocol * Concrete Objects Layer * Fundamental Objects * Type Objects * Creating Heap-Allocated Types * The "None" Object * Numeric Objects * Integer Objects * Boolean Objects * Floating Point Objects * Complex Number Objects * Complex Numbers as C Structures * Complex Numbers as Python Objects * Sequence Objects * Bytes Objects * Byte Array Objects * Type check macros * Direct API functions * Macros * Unicode Objects and Codecs * Unicode Objects * Unicode Type * Unicode Character Properties * Creating and accessing Unicode strings * Deprecated Py_UNICODE APIs * Locale Encoding * File System Encoding * 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 * Tuple Objects * Struct Sequence Objects * List Objects * Container Objects * Dictionary Objects * Set Objects * Function Objects * Function Objects * Instance Method Objects * Method Objects * Cell Objects * Code Objects * Other Objects * File Objects * Module Objects * Initializing C modules * Single-phase initialization * Multi-phase initialization * Low-level module creation functions * Support functions * Module lookup * Iterator Objects * Descriptor Objects * Slice Objects * Ellipsis Object * MemoryView objects * Weak Reference Objects * Capsules * Generator Objects * Coroutine Objects * Context Variables Objects * DateTime Objects * Objects for Type Hinting * Initialization, Finalization, and Threads * Before Python Initialization * Global configuration variables * 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 * Cautions about fork() * High-level API * Low-level API * Sub-interpreter support * Bugs and caveats * Asynchronous Notifications * Profiling and Tracing * Advanced Debugger Support * Thread Local Storage Support * Thread Specific Storage (TSS) API * Dynamic Allocation * Methods * Thread Local Storage (TLS) API * Python Initialization Configuration * Example * PyWideStringList * PyStatus * PyPreConfig * Preinitialize Python with PyPreConfig * PyConfig * Initialization with PyConfig * Isolated Configuration * Python Configuration * Python Path Configuration * Py_RunMain() * Py_GetArgcArgv() * Multi-Phase Initialization Private Provisional API * Memory Management * Overview * Allocator Domains * Raw Memory Interface * Memory Interface * Object allocators * Default Memory Allocators * Customize Memory Allocators * Debug hooks on the Python memory allocators * The pymalloc allocator * Customize pymalloc Arena Allocator * tracemalloc C API * Examples * Object Implementation Support * Allocating Objects on the Heap * Common Object Structures * Base object types and macros * Implementing functions and methods * Accessing attributes of extension types * Type Objects * Quick Reference * "tp slots" * sub-slots * slot typedefs * PyTypeObject Definition * PyObject Slots * PyVarObject Slots * PyTypeObject Slots * Static Types * Heap Types * Number Object Structures * Mapping Object Structures * Sequence Object Structures * Buffer Object Structures * Async Object Structures * Slot Type typedefs * Examples * Supporting Cyclic Garbage Collection * Controlling the Garbage Collector State * API and ABI Versioning * Distributing Python Modules * Key terms * Open source licensing and collaboration * Installing the tools * Reading the Python Packaging User 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 3.4? * ... 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 * 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 * Primer * Simple example: A descriptor that returns a constant * Dynamic lookups * Managed attributes * Customized names * Closing thoughts * Complete Practical Example * Validator class * Custom validators * Practical application * Technical Tutorial * Abstract * Definition and introduction * Descriptor protocol * Overview of descriptor invocation * Invocation from an instance * Invocation from a class * Invocation from super * Summary of invocation logic * Automatic name notification * ORM example * Pure Python Equivalents * Properties * Functions and methods * Kinds of methods * Static methods * Class methods * Member objects and __slots__ * 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 * The itertools module * Creating new iterators * Calling functions on elements * Selecting elements * Combinatoric functions * Grouping elements * The functools module * The operator module * Small functions and the lambda expression * 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 * Dealing with handlers that block * Sending and receiving logging events across a network * Running a logging socket listener in production * 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 concurrent.futures.ProcessPoolExecutor * Deploying Web applications using Gunicorn and uWSGI * Using file rotation * Use of alternative formatting styles * Customizing "LogRecord" * Subclassing QueueHandler - a ZeroMQ example * Subclassing QueueListener - a ZeroMQ example * An example dictionary-based configuration * Using a rotator and namer to customize log rotation processing * A more elaborate multiprocessing example * Inserting a BOM into messages sent to a SysLogHandler * Implementing structured logging * Customizing handlers with "dictConfig()" * Using particular formatting styles throughout your application * Using LogRecord factories * Using custom message objects * 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 * A CLI application starter template * A Qt GUI for logging * Patterns to avoid * Opening the same log file multiple times * Using loggers as attributes in a class or passing them as parameters * Adding handlers other than "NullHandler" to a logger in a library * Creating a lot of loggers * 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 * 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 * Definitions * Encodings * References * Python's Unicode Support * The String Type * Converting to Bytes * Unicode Literals in Python Source Code * Unicode Properties * Comparing Strings * Unicode Regular Expressions * References * Reading and Writing Unicode Data * Unicode filenames * Tips for Writing Unicode-aware Programs * Converting Between File Encodings * Files in an Unknown Encoding * References * Acknowledgements * HOWTO Fetch Internet Resources Using The urllib Package * 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 * 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 * An introduction to the ipaddress module * Creating Address/Network/Interface objects * A Note on IP Versions * IP Host Addresses * Defining Networks * Host Interfaces * Inspecting Address/Network/Interface Objects * Networks as lists of Addresses * Comparisons * Using IP Addresses with other modules * Getting more detail when instance creation fails * Argument Clinic How-To * The Goals Of Argument Clinic * Basic Concepts And Usage * Converting Your First Function * Advanced Topics * Symbolic default values * Renaming the C functions and variables generated by Argument Clinic * Converting functions using PyArg_UnpackTuple * Optional Groups * Using real Argument Clinic converters, instead of "legacy converters" * Py_buffer * Advanced converters * Parameter default values * The "NULL" default value * Expressions specified as default values * Using a return converter * Cloning existing functions * Calling Python code * Using a "self converter" * Using a "defining class" converter * Writing a custom converter * Writing a custom return converter * METH_O and METH_NOARGS * tp_new and tp_init functions * Changing and redirecting Clinic's output * The #ifdef trick * Using Argument Clinic in Python files * Instrumenting CPython with DTrace and SystemTap * Enabling the static markers * Static DTrace probes * Static SystemTap markers * Available static markers * SystemTap Tapsets * Examples * Annotations Best Practices * Accessing The Annotations Dict Of An Object In Python 3.10 And Newer * Accessing The Annotations Dict Of An Object In Python 3.9 And Older * Manually Un-Stringizing Stringized Annotations * Best Practices For "__annotations__" In Any Python Version * "__annotations__" Quirks * Python Frequently Asked Questions * General Python FAQ * General Information * Python in the real world * Programming FAQ * General Questions * Core Language * Numbers and strings * Performance * Sequences (Tuples/Lists) * 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 doesn't CPython use a more traditional garbage collection scheme? * Why isn't all memory freed when CPython 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 don't generators support the with statement? * 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? * 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)? * 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? * Graphic User Interface FAQ * General GUI Questions * What 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 * Dealing with 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 3.10.1 * 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 * ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON 3.10.1 DOCUMENTATION * Licenses and Acknowledgements for Incorporated Software * Mersenne Twister * Sockets * Asynchronous socket services * Cookie management * Execution tracing * UUencode and UUdecode functions * XML Remote Procedure Calls * test_epoll * Select kqueue * SipHash24 * strtod and dtoa * OpenSSL * expat * libffi * zlib * cfuhash * libmpdec * W3C C14N test suite