Python Documentation contents
*****************************

* What's New in Python

  * What's New In Python 3.13

    * Summary -- Release highlights

    * New Features

    * Other Language Changes

    * New Modules

    * Improved Modules

      * ast

      * array

      * copy

      * dbm

      * doctest

      * io

      * opcode

      * os

      * pathlib

      * pdb

      * sqlite3

      * tkinter

      * traceback

      * typing

      * venv

    * Optimizations

    * Deprecated

      * Pending Removal in Python 3.14

      * Pending Removal in Python 3.15

      * Pending Removal in Python 3.16

      * Pending Removal in Future Versions

    * Removed

    * Porting to Python 3.13

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.13

      * Deprecated

      * Removed

      * Pending Removal in Python 3.14

      * Pending Removal in Python 3.15

      * Pending Removal in Future Versions

  * What's New In Python 3.12

    * Summary -- Release highlights

    * New Features

      * PEP 695: Type Parameter Syntax

      * PEP 701: Syntactic formalization of f-strings

      * PEP 684: A Per-Interpreter GIL

      * PEP 669: Low impact monitoring for CPython

      * PEP 688: Making the buffer protocol accessible in Python

      * PEP 709: Comprehension inlining

      * Improved Error Messages

    * New Features Related to Type Hints

      * PEP 692: Using "TypedDict" for more precise "**kwargs" typing

      * PEP 698: Override Decorator for Static Typing

    * Other Language Changes

    * New Modules

    * Improved Modules

      * array

      * asyncio

      * calendar

      * csv

      * dis

      * fractions

      * importlib.resources

      * inspect

      * itertools

      * math

      * os

      * os.path

      * pathlib

      * pdb

      * random

      * shutil

      * sqlite3

      * statistics

      * sys

      * tempfile

      * threading

      * tkinter

      * tokenize

      * types

      * typing

      * unicodedata

      * unittest

      * uuid

    * Optimizations

    * CPython bytecode changes

    * Demos and Tools

    * Deprecated

      * Pending Removal in Python 3.13

      * Pending Removal in Python 3.14

      * Pending Removal in Future Versions

    * Removed

      * asynchat and asyncore

      * configparser

      * distutils

      * ensurepip

      * enum

      * ftplib

      * gzip

      * hashlib

      * importlib

      * imp

      * io

      * locale

      * sqlite3

      * ssl

      * unittest

      * webbrowser

      * xml.etree.ElementTree

      * zipimport

      * Others

    * Porting to Python 3.12

      * Changes in the Python API

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.12

      * Deprecated

        * Pending Removal in Python 3.14

        * Pending Removal in Python 3.15

        * Pending Removal in Future Versions

      * Removed

  * What's New In Python 3.11

    * Summary -- Release highlights

    * New Features

      * PEP 657: Fine-grained error locations in tracebacks

      * PEP 654: Exception Groups and "except*"

      * PEP 678: Exceptions can be enriched with notes

      * Windows "py.exe" launcher improvements

    * New Features Related to Type Hints

      * PEP 646: Variadic generics

      * PEP 655: Marking individual "TypedDict" items as required or
        not-required

      * PEP 673: "Self" type

      * PEP 675: Arbitrary literal string type

      * PEP 681: Data class transforms

      * PEP 563 may not be the future

    * Other Language Changes

    * Other CPython Implementation Changes

    * New Modules

    * Improved Modules

      * asyncio

      * contextlib

      * dataclasses

      * datetime

      * enum

      * fcntl

      * fractions

      * functools

      * hashlib

      * IDLE and idlelib

      * inspect

      * locale

      * logging

      * math

      * operator

      * os

      * pathlib

      * re

      * shutil

      * socket

      * sqlite3

      * string

      * sys

      * sysconfig

      * tempfile

      * threading

      * time

      * tkinter

      * traceback

      * typing

      * unicodedata

      * unittest

      * venv

      * warnings

      * zipfile

    * Optimizations

    * Faster CPython

      * Faster Startup

        * Frozen imports / Static code objects

      * Faster Runtime

        * Cheaper, lazy Python frames

        * Inlined Python function calls

        * PEP 659: Specializing Adaptive Interpreter

      * Misc

      * FAQ

        * How should I write my code to utilize these speedups?

        * Will CPython 3.11 use more memory?

        * I don't see any speedups in my workload. Why?

        * Is there a JIT compiler?

      * About

    * CPython bytecode changes

      * New opcodes

      * Replaced opcodes

      * Changed/removed opcodes

    * Deprecated

      * Language/Builtins

      * Modules

      * Standard Library

    * Pending Removal in Python 3.12

    * Removed

    * Porting to Python 3.11

    * Build Changes

    * C API Changes

      * New Features

      * Porting to Python 3.11

      * Deprecated

      * Pending Removal in Python 3.12

      * Removed

  * 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

      * enum

      * fileinput

      * faulthandler

      * gc

      * glob

      * hashlib

      * hmac

      * IDLE and idlelib

      * importlib.metadata

      * inspect

      * itertools

      * 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

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.12.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 7

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 6

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.12.0 alpha 5

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

    * Python 3.12.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 3

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.12.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.12.0 alpha 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * Tools/Demos

      * C API

    * Python 3.11.0 beta 1

      * Security

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 7

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * Tools/Demos

      * C API

    * Python 3.11.0 alpha 6

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * IDLE

      * C API

    * Python 3.11.0 alpha 5

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 4

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 3

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * C API

    * Python 3.11.0 alpha 2

      * Core and Builtins

      * Library

      * Documentation

      * Tests

      * Build

      * Windows

      * macOS

      * IDLE

      * C API

    * Python 3.11.0 alpha 1

      * 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

      * Security

      * Core and Builtins

      * 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

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * C API

      * Build

      * Tools/Demos

      * Documentation

      * Tests

    * Python 3.6.0 alpha 2

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Windows

      * Build

      * C API

      * Tools/Demos

    * Python 3.6.0 alpha 1

      * Security

      * Core and Builtins

      * 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

      * Security

      * Core and Builtins

      * 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

      * Security

      * Core and Builtins

      * Library

      * IDLE

      * Documentation

      * Tests

      * Build

      * Windows

      * Tools/Demos

    * 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. Text

      * 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

    * 8.9. Raising and Handling Multiple Unrelated Exceptions

    * 8.10. Enriching Exceptions with Notes

  * 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.2. Building Python

    * 2.3. Python-related paths and files

    * 2.4. Miscellaneous

    * 2.5. Custom OpenSSL

  * 3. Configure Python

    * 3.1. Build Requirements

    * 3.2. Generated files

    * 3.3. Configure Options

      * 3.3.1. General Options

      * 3.3.2. C compiler options

      * 3.3.3. Linker options

      * 3.3.4. Options for third-party dependencies

      * 3.3.5. WebAssembly Options

      * 3.3.6. Install Options

      * 3.3.7. Performance options

      * 3.3.8. Python Debug Build

      * 3.3.9. Debug options

      * 3.3.10. Linker options

      * 3.3.11. Libraries options

      * 3.3.12. Security Options

      * 3.3.13. macOS Options

      * 3.3.14. Cross Compiling Options

    * 3.4. Python Build System

      * 3.4.1. Main files of the build system

      * 3.4.2. Main build steps

      * 3.4.3. Main Makefile targets

      * 3.4.4. C extensions

    * 3.5. Compiler and linker flags

      * 3.5.1. Preprocessor flags

      * 3.5.2. Compiler flags

      * 3.5.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.2.1.1. Redirection of local data, registry, and temporary
          paths

    * 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.8.6. Dry Run

      * 4.8.7. Install on demand

      * 4.8.8. Return codes

    * 4.9. Finding modules

    * 4.10. Additional modules

      * 4.10.1. PyWin32

      * 4.10.2. cx_Freeze

    * 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.1.1. Escape sequences

      * 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.2.1. None

      * 3.2.2. NotImplemented

      * 3.2.3. Ellipsis

      * 3.2.4. "numbers.Number"

        * 3.2.4.1. "numbers.Integral"

        * 3.2.4.2. "numbers.Real" ("float")

        * 3.2.4.3. "numbers.Complex" ("complex")

      * 3.2.5. Sequences

        * 3.2.5.1. Immutable sequences

        * 3.2.5.2. Mutable sequences

      * 3.2.6. Set types

      * 3.2.7. Mappings

        * 3.2.7.1. Dictionaries

      * 3.2.8. Callable types

        * 3.2.8.1. User-defined functions

        * 3.2.8.2. Instance methods

        * 3.2.8.3. Generator functions

        * 3.2.8.4. Coroutine functions

        * 3.2.8.5. Asynchronous generator functions

        * 3.2.8.6. Built-in functions

        * 3.2.8.7. Built-in methods

        * 3.2.8.8. Classes

        * 3.2.8.9. Class Instances

      * 3.2.9. Modules

      * 3.2.10. Custom classes

      * 3.2.11. Class instances

      * 3.2.12. I/O objects (also known as file objects)

      * 3.2.13. Internal types

        * 3.2.13.1. Code objects

          * "codeobject.co_positions()"

        * 3.2.13.2. Frame objects

          * "frame.clear()"

        * 3.2.13.3. Traceback objects

        * 3.2.13.4. Slice objects

          * "slice.indices()"

        * 3.2.13.5. Static method objects

        * 3.2.13.6. Class method objects

    * 3.3. Special method names

      * 3.3.1. Basic customization

        * "object.__new__()"

        * "object.__init__()"

        * "object.__del__()"

        * "object.__repr__()"

        * "object.__str__()"

        * "object.__bytes__()"

        * "object.__format__()"

        * "object.__lt__()"

        * "object.__le__()"

        * "object.__eq__()"

        * "object.__ne__()"

        * "object.__gt__()"

        * "object.__ge__()"

        * "object.__hash__()"

        * "object.__bool__()"

      * 3.3.2. Customizing attribute access

        * "object.__getattr__()"

        * "object.__getattribute__()"

        * "object.__setattr__()"

        * "object.__delattr__()"

        * "object.__dir__()"

        * 3.3.2.1. Customizing module attribute access

        * 3.3.2.2. Implementing Descriptors

          * "object.__get__()"

          * "object.__set__()"

          * "object.__delete__()"

        * 3.3.2.3. Invoking Descriptors

        * 3.3.2.4. __slots__

          * "object.__slots__"

      * 3.3.3. Customizing class creation

        * "object.__init_subclass__()"

        * "object.__set_name__()"

        * 3.3.3.1. Metaclasses

        * 3.3.3.2. Resolving MRO entries

          * "object.__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

        * "class.__instancecheck__()"

        * "class.__subclasscheck__()"

      * 3.3.5. Emulating generic types

        * "object.__class_getitem__()"

        * 3.3.5.1. The purpose of *__class_getitem__*

        * 3.3.5.2. *__class_getitem__* versus *__getitem__*

      * 3.3.6. Emulating callable objects

        * "object.__call__()"

      * 3.3.7. Emulating container types

        * "object.__len__()"

        * "object.__length_hint__()"

        * "object.__getitem__()"

        * "object.__setitem__()"

        * "object.__delitem__()"

        * "object.__missing__()"

        * "object.__iter__()"

        * "object.__reversed__()"

        * "object.__contains__()"

      * 3.3.8. Emulating numeric types

        * "object.__add__()"

        * "object.__sub__()"

        * "object.__mul__()"

        * "object.__matmul__()"

        * "object.__truediv__()"

        * "object.__floordiv__()"

        * "object.__mod__()"

        * "object.__divmod__()"

        * "object.__pow__()"

        * "object.__lshift__()"

        * "object.__rshift__()"

        * "object.__and__()"

        * "object.__xor__()"

        * "object.__or__()"

        * "object.__radd__()"

        * "object.__rsub__()"

        * "object.__rmul__()"

        * "object.__rmatmul__()"

        * "object.__rtruediv__()"

        * "object.__rfloordiv__()"

        * "object.__rmod__()"

        * "object.__rdivmod__()"

        * "object.__rpow__()"

        * "object.__rlshift__()"

        * "object.__rrshift__()"

        * "object.__rand__()"

        * "object.__rxor__()"

        * "object.__ror__()"

        * "object.__iadd__()"

        * "object.__isub__()"

        * "object.__imul__()"

        * "object.__imatmul__()"

        * "object.__itruediv__()"

        * "object.__ifloordiv__()"

        * "object.__imod__()"

        * "object.__ipow__()"

        * "object.__ilshift__()"

        * "object.__irshift__()"

        * "object.__iand__()"

        * "object.__ixor__()"

        * "object.__ior__()"

        * "object.__neg__()"

        * "object.__pos__()"

        * "object.__abs__()"

        * "object.__invert__()"

        * "object.__complex__()"

        * "object.__int__()"

        * "object.__float__()"

        * "object.__index__()"

        * "object.__round__()"

        * "object.__trunc__()"

        * "object.__floor__()"

        * "object.__ceil__()"

      * 3.3.9. With Statement Context Managers

        * "object.__enter__()"

        * "object.__exit__()"

      * 3.3.10. Customizing positional arguments in class pattern
        matching

        * "object.__match_args__"

      * 3.3.11. Emulating buffer types

        * "object.__buffer__()"

        * "object.__release_buffer__()"

      * 3.3.12. Special method lookup

    * 3.4. Coroutines

      * 3.4.1. Awaitable Objects

        * "object.__await__()"

      * 3.4.2. Coroutine Objects

        * "coroutine.send()"

        * "coroutine.throw()"

        * "coroutine.close()"

      * 3.4.3. Asynchronous Iterators

        * "object.__aiter__()"

        * "object.__anext__()"

      * 3.4.4. Asynchronous Context Managers

        * "object.__aenter__()"

        * "object.__aexit__()"

  * 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. Annotation scopes

      * 4.2.4. Lazy evaluation

      * 4.2.5. Builtins and restricted execution

      * 4.2.6. 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

        * "__name__"

        * "__loader__"

        * "__package__"

        * "__spec__"

        * "__path__"

        * "__file__"

        * "__cached__"

      * 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. 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

          * "generator.__next__()"

          * "generator.send()"

          * "generator.throw()"

          * "generator.close()"

        * 6.2.9.2. Examples

        * 6.2.9.3. Asynchronous generator functions

        * 6.2.9.4. Asynchronous generator-iterator methods

          * "agen.__anext__()"

          * "agen.asend()"

          * "agen.athrow()"

          * "agen.aclose()"

    * 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

    * 7.14. The "type" 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.4.1. "except" clause

      * 8.4.2. "except*" clause

      * 8.4.3. "else" clause

      * 8.4.4. "finally" clause

    * 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

    * 8.10. Type parameter lists

      * 8.10.1. Generic functions

      * 8.10.2. Generic classes

      * 8.10.3. Generic type aliases

  * 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

      * WebAssembly platforms

  * Built-in Functions

    * "abs()"

    * "aiter()"

    * "all()"

    * "anext()"

    * "any()"

    * "ascii()"

    * "bin()"

    * "bool"

    * "breakpoint()"

    * "callable()"

    * "chr()"

    * "classmethod()"

    * "compile()"

    * "complex"

    * "delattr()"

    * "dir()"

    * "divmod()"

    * "enumerate()"

    * "eval()"

    * "exec()"

    * "filter()"

    * "float"

    * "format()"

    * "getattr()"

    * "globals()"

    * "hasattr()"

    * "hash()"

    * "help()"

    * "hex()"

    * "id()"

    * "input()"

    * "int"

    * "isinstance()"

    * "issubclass()"

    * "iter()"

    * "len()"

    * "locals()"

    * "map()"

    * "max()"

    * "min()"

    * "next()"

    * "object"

    * "oct()"

    * "open()"

    * "ord()"

    * "pow()"

    * "print()"

    * "property"

    * "repr()"

    * "reversed()"

    * "round()"

    * "setattr()"

    * "slice"

    * "sorted()"

    * "staticmethod()"

    * "sum()"

    * "super"

    * "type"

    * "vars()"

    * "zip()"

    * "__import__()"

  * Built-in Constants

    * "False"

    * "True"

    * "None"

    * "NotImplemented"

    * "Ellipsis"

    * "__debug__"

    * Constants added by the "site" module

      * "quit"

      * "exit"

      * "copyright"

      * "credits"

      * "license"

  * 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

        * "int.bit_length()"

        * "int.bit_count()"

        * "int.to_bytes()"

        * "int.from_bytes()"

        * "int.as_integer_ratio()"

        * "int.is_integer()"

      * Additional Methods on Float

        * "float.as_integer_ratio()"

        * "float.is_integer()"

        * "float.hex()"

        * "float.fromhex()"

      * Hashing of numeric types

    * Boolean Type - "bool"

    * Iterator Types

      * "container.__iter__()"

      * "iterator.__iter__()"

      * "iterator.__next__()"

      * Generator Types

    * Sequence Types --- "list", "tuple", "range"

      * Common Sequence Operations

      * Immutable Sequence Types

      * Mutable Sequence Types

      * Lists

        * "list"

          * "list.sort()"

      * Tuples

        * "tuple"

      * Ranges

        * "range"

          * "range.start"

          * "range.stop"

          * "range.step"

    * Text Sequence Type --- "str"

      * "str"

      * String Methods

        * "str.capitalize()"

        * "str.casefold()"

        * "str.center()"

        * "str.count()"

        * "str.encode()"

        * "str.endswith()"

        * "str.expandtabs()"

        * "str.find()"

        * "str.format()"

        * "str.format_map()"

        * "str.index()"

        * "str.isalnum()"

        * "str.isalpha()"

        * "str.isascii()"

        * "str.isdecimal()"

        * "str.isdigit()"

        * "str.isidentifier()"

        * "str.islower()"

        * "str.isnumeric()"

        * "str.isprintable()"

        * "str.isspace()"

        * "str.istitle()"

        * "str.isupper()"

        * "str.join()"

        * "str.ljust()"

        * "str.lower()"

        * "str.lstrip()"

        * "str.maketrans()"

        * "str.partition()"

        * "str.removeprefix()"

        * "str.removesuffix()"

        * "str.replace()"

        * "str.rfind()"

        * "str.rindex()"

        * "str.rjust()"

        * "str.rpartition()"

        * "str.rsplit()"

        * "str.rstrip()"

        * "str.split()"

        * "str.splitlines()"

        * "str.startswith()"

        * "str.strip()"

        * "str.swapcase()"

        * "str.title()"

        * "str.translate()"

        * "str.upper()"

        * "str.zfill()"

      * "printf"-style String Formatting

    * Binary Sequence Types --- "bytes", "bytearray", "memoryview"

      * Bytes Objects

        * "bytes"

          * "bytes.fromhex()"

          * "bytes.hex()"

      * Bytearray Objects

        * "bytearray"

          * "bytearray.fromhex()"

          * "bytearray.hex()"

      * Bytes and Bytearray Operations

        * "bytes.count()"

        * "bytearray.count()"

        * "bytes.removeprefix()"

        * "bytearray.removeprefix()"

        * "bytes.removesuffix()"

        * "bytearray.removesuffix()"

        * "bytes.decode()"

        * "bytearray.decode()"

        * "bytes.endswith()"

        * "bytearray.endswith()"

        * "bytes.find()"

        * "bytearray.find()"

        * "bytes.index()"

        * "bytearray.index()"

        * "bytes.join()"

        * "bytearray.join()"

        * "bytes.maketrans()"

        * "bytearray.maketrans()"

        * "bytes.partition()"

        * "bytearray.partition()"

        * "bytes.replace()"

        * "bytearray.replace()"

        * "bytes.rfind()"

        * "bytearray.rfind()"

        * "bytes.rindex()"

        * "bytearray.rindex()"

        * "bytes.rpartition()"

        * "bytearray.rpartition()"

        * "bytes.startswith()"

        * "bytearray.startswith()"

        * "bytes.translate()"

        * "bytearray.translate()"

        * "bytes.center()"

        * "bytearray.center()"

        * "bytes.ljust()"

        * "bytearray.ljust()"

        * "bytes.lstrip()"

        * "bytearray.lstrip()"

        * "bytes.rjust()"

        * "bytearray.rjust()"

        * "bytes.rsplit()"

        * "bytearray.rsplit()"

        * "bytes.rstrip()"

        * "bytearray.rstrip()"

        * "bytes.split()"

        * "bytearray.split()"

        * "bytes.strip()"

        * "bytearray.strip()"

        * "bytes.capitalize()"

        * "bytearray.capitalize()"

        * "bytes.expandtabs()"

        * "bytearray.expandtabs()"

        * "bytes.isalnum()"

        * "bytearray.isalnum()"

        * "bytes.isalpha()"

        * "bytearray.isalpha()"

        * "bytes.isascii()"

        * "bytearray.isascii()"

        * "bytes.isdigit()"

        * "bytearray.isdigit()"

        * "bytes.islower()"

        * "bytearray.islower()"

        * "bytes.isspace()"

        * "bytearray.isspace()"

        * "bytes.istitle()"

        * "bytearray.istitle()"

        * "bytes.isupper()"

        * "bytearray.isupper()"

        * "bytes.lower()"

        * "bytearray.lower()"

        * "bytes.splitlines()"

        * "bytearray.splitlines()"

        * "bytes.swapcase()"

        * "bytearray.swapcase()"

        * "bytes.title()"

        * "bytearray.title()"

        * "bytes.upper()"

        * "bytearray.upper()"

        * "bytes.zfill()"

        * "bytearray.zfill()"

      * "printf"-style Bytes Formatting

      * Memory Views

        * "memoryview"

          * "memoryview.__eq__()"

          * "memoryview.tobytes()"

          * "memoryview.hex()"

          * "memoryview.tolist()"

          * "memoryview.toreadonly()"

          * "memoryview.release()"

          * "memoryview.cast()"

          * "memoryview.obj"

          * "memoryview.nbytes"

          * "memoryview.readonly"

          * "memoryview.format"

          * "memoryview.itemsize"

          * "memoryview.ndim"

          * "memoryview.shape"

          * "memoryview.strides"

          * "memoryview.suboffsets"

          * "memoryview.c_contiguous"

          * "memoryview.f_contiguous"

          * "memoryview.contiguous"

    * Set Types --- "set", "frozenset"

      * "set"

      * "frozenset"

        * "frozenset.isdisjoint()"

        * "frozenset.issubset()"

        * "frozenset.issuperset()"

        * "frozenset.union()"

        * "frozenset.intersection()"

        * "frozenset.difference()"

        * "frozenset.symmetric_difference()"

        * "frozenset.copy()"

        * "frozenset.update()"

        * "frozenset.intersection_update()"

        * "frozenset.difference_update()"

        * "frozenset.symmetric_difference_update()"

        * "frozenset.add()"

        * "frozenset.remove()"

        * "frozenset.discard()"

        * "frozenset.pop()"

        * "frozenset.clear()"

    * Mapping Types --- "dict"

      * "dict"

        * "dict.clear()"

        * "dict.copy()"

        * "dict.fromkeys()"

        * "dict.get()"

        * "dict.items()"

        * "dict.keys()"

        * "dict.pop()"

        * "dict.popitem()"

        * "dict.setdefault()"

        * "dict.update()"

        * "dict.values()"

      * Dictionary view objects

    * Context Manager Types

      * "contextmanager.__enter__()"

      * "contextmanager.__exit__()"

    * Type Annotation Types --- *Generic Alias*, *Union*

      * Generic Alias Type

        * Standard Generic Classes

        * Special Attributes of "GenericAlias" objects

          * "genericalias.__origin__"

          * "genericalias.__args__"

          * "genericalias.__parameters__"

          * "genericalias.__unpacked__"

      * 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

      * Internal Objects

    * Special Attributes

      * "object.__dict__"

      * "instance.__class__"

      * "class.__bases__"

      * "definition.__name__"

      * "definition.__qualname__"

      * "definition.__type_params__"

      * "class.__mro__"

      * "class.mro()"

      * "class.__subclasses__()"

    * Integer string conversion length limitation

      * Affected APIs

      * Configuring the limit

      * Recommended configuration

  * Built-in Exceptions

    * Exception context

    * Inheriting from built-in exceptions

    * Base classes

      * "BaseException"

        * "BaseException.args"

        * "BaseException.with_traceback()"

        * "BaseException.add_note()"

        * "BaseException.__notes__"

      * "Exception"

      * "ArithmeticError"

      * "BufferError"

      * "LookupError"

    * Concrete exceptions

      * "AssertionError"

      * "AttributeError"

      * "EOFError"

      * "FloatingPointError"

      * "GeneratorExit"

      * "ImportError"

        * "ImportError.name"

        * "ImportError.path"

      * "ModuleNotFoundError"

      * "IndexError"

      * "KeyError"

      * "KeyboardInterrupt"

      * "MemoryError"

      * "NameError"

      * "NotImplementedError"

      * "OSError"

        * "OSError.errno"

        * "OSError.winerror"

        * "OSError.strerror"

        * "OSError.filename"

        * "OSError.filename2"

      * "OverflowError"

      * "RecursionError"

      * "ReferenceError"

      * "RuntimeError"

      * "StopIteration"

      * "StopAsyncIteration"

      * "SyntaxError"

        * "SyntaxError.filename"

        * "SyntaxError.lineno"

        * "SyntaxError.offset"

        * "SyntaxError.text"

        * "SyntaxError.end_lineno"

        * "SyntaxError.end_offset"

      * "IndentationError"

      * "TabError"

      * "SystemError"

      * "SystemExit"

        * "SystemExit.code"

      * "TypeError"

      * "UnboundLocalError"

      * "UnicodeError"

        * "UnicodeError.encoding"

        * "UnicodeError.reason"

        * "UnicodeError.object"

        * "UnicodeError.start"

        * "UnicodeError.end"

      * "UnicodeEncodeError"

      * "UnicodeDecodeError"

      * "UnicodeTranslateError"

      * "ValueError"

      * "ZeroDivisionError"

      * "EnvironmentError"

      * "IOError"

      * "WindowsError"

      * OS exceptions

        * "BlockingIOError"

          * "BlockingIOError.characters_written"

        * "ChildProcessError"

        * "ConnectionError"

        * "BrokenPipeError"

        * "ConnectionAbortedError"

        * "ConnectionRefusedError"

        * "ConnectionResetError"

        * "FileExistsError"

        * "FileNotFoundError"

        * "InterruptedError"

        * "IsADirectoryError"

        * "NotADirectoryError"

        * "PermissionError"

        * "ProcessLookupError"

        * "TimeoutError"

    * Warnings

      * "Warning"

      * "UserWarning"

      * "DeprecationWarning"

      * "PendingDeprecationWarning"

      * "SyntaxWarning"

      * "RuntimeWarning"

      * "FutureWarning"

      * "ImportWarning"

      * "UnicodeWarning"

      * "EncodingWarning"

      * "BytesWarning"

      * "ResourceWarning"

    * Exception groups

      * "ExceptionGroup"

      * "BaseExceptionGroup"

        * "BaseExceptionGroup.message"

        * "BaseExceptionGroup.exceptions"

        * "BaseExceptionGroup.subgroup()"

        * "BaseExceptionGroup.split()"

        * "BaseExceptionGroup.derive()"

    * Exception hierarchy

  * Text Processing Services

    * "string" --- Common string operations

      * String constants

        * "ascii_letters"

        * "ascii_lowercase"

        * "ascii_uppercase"

        * "digits"

        * "hexdigits"

        * "octdigits"

        * "punctuation"

        * "printable"

        * "whitespace"

      * Custom String Formatting

        * "Formatter"

          * "Formatter.format()"

          * "Formatter.vformat()"

          * "Formatter.parse()"

          * "Formatter.get_field()"

          * "Formatter.get_value()"

          * "Formatter.check_unused_args()"

          * "Formatter.format_field()"

          * "Formatter.convert_field()"

      * Format String Syntax

        * Format Specification Mini-Language

        * Format examples

      * Template strings

        * "Template"

          * "Template.substitute()"

          * "Template.safe_substitute()"

          * "Template.is_valid()"

          * "Template.get_identifiers()"

          * "Template.template"

      * Helper functions

        * "capwords()"

    * "re" --- Regular expression operations

      * Regular Expression Syntax

      * Module Contents

        * Flags

          * "RegexFlag"

          * "A"

          * "ASCII"

          * "DEBUG"

          * "I"

          * "IGNORECASE"

          * "L"

          * "LOCALE"

          * "M"

          * "MULTILINE"

          * "NOFLAG"

          * "S"

          * "DOTALL"

          * "U"

          * "UNICODE"

          * "X"

          * "VERBOSE"

        * Functions

          * "compile()"

          * "search()"

          * "match()"

          * "fullmatch()"

          * "split()"

          * "findall()"

          * "finditer()"

          * "sub()"

          * "subn()"

          * "escape()"

          * "purge()"

        * Exceptions

          * "error"

            * "error.msg"

            * "error.pattern"

            * "error.pos"

            * "error.lineno"

            * "error.colno"

      * Regular Expression Objects

        * "Pattern"

          * "Pattern.search()"

          * "Pattern.match()"

          * "Pattern.fullmatch()"

          * "Pattern.split()"

          * "Pattern.findall()"

          * "Pattern.finditer()"

          * "Pattern.sub()"

          * "Pattern.subn()"

          * "Pattern.flags"

          * "Pattern.groups"

          * "Pattern.groupindex"

          * "Pattern.pattern"

      * Match Objects

        * "Match"

          * "Match.expand()"

          * "Match.group()"

          * "Match.__getitem__()"

          * "Match.groups()"

          * "Match.groupdict()"

          * "Match.start()"

          * "Match.end()"

          * "Match.span()"

          * "Match.pos"

          * "Match.endpos"

          * "Match.lastindex"

          * "Match.lastgroup"

          * "Match.re"

          * "Match.string"

      * 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

      * "Differ"

      * "HtmlDiff"

        * "HtmlDiff.__init__()"

        * "HtmlDiff.make_file()"

        * "HtmlDiff.make_table()"

      * "context_diff()"

      * "get_close_matches()"

      * "ndiff()"

      * "restore()"

      * "unified_diff()"

      * "diff_bytes()"

      * "IS_LINE_JUNK()"

      * "IS_CHARACTER_JUNK()"

      * SequenceMatcher Objects

        * "SequenceMatcher"

          * "SequenceMatcher.set_seqs()"

          * "SequenceMatcher.set_seq1()"

          * "SequenceMatcher.set_seq2()"

          * "SequenceMatcher.find_longest_match()"

          * "SequenceMatcher.get_matching_blocks()"

          * "SequenceMatcher.get_opcodes()"

          * "SequenceMatcher.get_grouped_opcodes()"

          * "SequenceMatcher.ratio()"

          * "SequenceMatcher.quick_ratio()"

          * "SequenceMatcher.real_quick_ratio()"

      * SequenceMatcher Examples

      * Differ Objects

        * "Differ.compare()"

      * Differ Example

      * A command-line interface to difflib

      * ndiff example

    * "textwrap" --- Text wrapping and filling

      * "wrap()"

      * "fill()"

      * "shorten()"

      * "dedent()"

      * "indent()"

      * "TextWrapper"

        * "TextWrapper.width"

        * "TextWrapper.expand_tabs"

        * "TextWrapper.tabsize"

        * "TextWrapper.replace_whitespace"

        * "TextWrapper.drop_whitespace"

        * "TextWrapper.initial_indent"

        * "TextWrapper.subsequent_indent"

        * "TextWrapper.fix_sentence_endings"

        * "TextWrapper.break_long_words"

        * "TextWrapper.break_on_hyphens"

        * "TextWrapper.max_lines"

        * "TextWrapper.placeholder"

        * "TextWrapper.wrap()"

        * "TextWrapper.fill()"

    * "unicodedata" --- Unicode Database

      * "lookup()"

      * "name()"

      * "decimal()"

      * "digit()"

      * "numeric()"

      * "category()"

      * "bidirectional()"

      * "combining()"

      * "east_asian_width()"

      * "mirrored()"

      * "decomposition()"

      * "normalize()"

      * "is_normalized()"

      * "unidata_version"

      * "ucd_3_2_0"

    * "stringprep" --- Internet String Preparation

      * "in_table_a1()"

      * "in_table_b1()"

      * "map_table_b2()"

      * "map_table_b3()"

      * "in_table_c11()"

      * "in_table_c12()"

      * "in_table_c11_c12()"

      * "in_table_c21()"

      * "in_table_c22()"

      * "in_table_c21_c22()"

      * "in_table_c3()"

      * "in_table_c4()"

      * "in_table_c5()"

      * "in_table_c6()"

      * "in_table_c7()"

      * "in_table_c8()"

      * "in_table_c9()"

      * "in_table_d1()"

      * "in_table_d2()"

    * "readline" --- GNU readline interface

      * Init file

        * "parse_and_bind()"

        * "read_init_file()"

      * Line buffer

        * "get_line_buffer()"

        * "insert_text()"

        * "redisplay()"

      * History file

        * "read_history_file()"

        * "write_history_file()"

        * "append_history_file()"

        * "get_history_length()"

        * "set_history_length()"

      * History list

        * "clear_history()"

        * "get_current_history_length()"

        * "get_history_item()"

        * "remove_history_item()"

        * "replace_history_item()"

        * "add_history()"

        * "set_auto_history()"

      * Startup hooks

        * "set_startup_hook()"

        * "set_pre_input_hook()"

      * Completion

        * "set_completer()"

        * "get_completer()"

        * "get_completion_type()"

        * "get_begidx()"

        * "get_endidx()"

        * "set_completer_delims()"

        * "get_completer_delims()"

        * "set_completion_display_matches_hook()"

      * Example

    * "rlcompleter" --- Completion function for GNU readline

      * Completer Objects

        * "Completer.complete()"

  * Binary Data Services

    * "struct" --- Interpret bytes as packed binary data

      * Functions and Exceptions

        * "error"

        * "pack()"

        * "pack_into()"

        * "unpack()"

        * "unpack_from()"

        * "iter_unpack()"

        * "calcsize()"

      * Format Strings

        * Byte Order, Size, and Alignment

        * Format Characters

        * Examples

      * Applications

        * Native Formats

        * Standard Formats

      * Classes

        * "Struct"

          * "Struct.pack()"

          * "Struct.pack_into()"

          * "Struct.unpack()"

          * "Struct.unpack_from()"

          * "Struct.iter_unpack()"

          * "Struct.format"

          * "Struct.size"

    * "codecs" --- Codec registry and base classes

      * "encode()"

      * "decode()"

      * "lookup()"

      * "CodecInfo"

        * "CodecInfo.name"

        * "CodecInfo.encode"

        * "CodecInfo.decode"

        * "CodecInfo.incrementalencoder"

        * "CodecInfo.incrementaldecoder"

        * "CodecInfo.streamwriter"

        * "CodecInfo.streamreader"

      * "getencoder()"

      * "getdecoder()"

      * "getincrementalencoder()"

      * "getincrementaldecoder()"

      * "getreader()"

      * "getwriter()"

      * "register()"

      * "unregister()"

      * "open()"

      * "EncodedFile()"

      * "iterencode()"

      * "iterdecode()"

      * "BOM"

      * "BOM_BE"

      * "BOM_LE"

      * "BOM_UTF8"

      * "BOM_UTF16"

      * "BOM_UTF16_BE"

      * "BOM_UTF16_LE"

      * "BOM_UTF32"

      * "BOM_UTF32_BE"

      * "BOM_UTF32_LE"

      * Codec Base Classes

        * Error Handlers

          * "register_error()"

          * "lookup_error()"

          * "strict_errors()"

          * "ignore_errors()"

          * "replace_errors()"

          * "backslashreplace_errors()"

          * "xmlcharrefreplace_errors()"

          * "namereplace_errors()"

        * Stateless Encoding and Decoding

          * "Codec.encode()"

          * "Codec.decode()"

        * Incremental Encoding and Decoding

          * IncrementalEncoder Objects

            * "IncrementalEncoder"

              * "IncrementalEncoder.encode()"

              * "IncrementalEncoder.reset()"

              * "IncrementalEncoder.getstate()"

              * "IncrementalEncoder.setstate()"

          * IncrementalDecoder Objects

            * "IncrementalDecoder"

              * "IncrementalDecoder.decode()"

              * "IncrementalDecoder.reset()"

              * "IncrementalDecoder.getstate()"

              * "IncrementalDecoder.setstate()"

        * Stream Encoding and Decoding

          * StreamWriter Objects

            * "StreamWriter"

              * "StreamWriter.write()"

              * "StreamWriter.writelines()"

              * "StreamWriter.reset()"

          * StreamReader Objects

            * "StreamReader"

              * "StreamReader.read()"

              * "StreamReader.readline()"

              * "StreamReader.readlines()"

              * "StreamReader.reset()"

          * StreamReaderWriter Objects

            * "StreamReaderWriter"

          * StreamRecoder Objects

            * "StreamRecoder"

      * Encodings and Unicode

      * Standard Encodings

      * Python Specific Encodings

        * Text Encodings

        * Binary Transforms

        * Text Transforms

      * "encodings.idna" --- Internationalized Domain Names in
        Applications

        * "nameprep()"

        * "ToASCII()"

        * "ToUnicode()"

      * "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

        * "MINYEAR"

        * "MAXYEAR"

        * "UTC"

      * Available Types

        * Common Properties

        * Determining if an Object is Aware or Naive

      * "timedelta" Objects

        * "timedelta"

          * "timedelta.min"

          * "timedelta.max"

          * "timedelta.resolution"

          * "timedelta.total_seconds()"

        * Examples of usage: "timedelta"

      * "date" Objects

        * "date"

          * "date.today()"

          * "date.fromtimestamp()"

          * "date.fromordinal()"

          * "date.fromisoformat()"

          * "date.fromisocalendar()"

          * "date.min"

          * "date.max"

          * "date.resolution"

          * "date.year"

          * "date.month"

          * "date.day"

          * "date.replace()"

          * "date.timetuple()"

          * "date.toordinal()"

          * "date.weekday()"

          * "date.isoweekday()"

          * "date.isocalendar()"

          * "date.isoformat()"

          * "date.__str__()"

          * "date.ctime()"

          * "date.strftime()"

          * "date.__format__()"

        * Examples of Usage: "date"

      * "datetime" Objects

        * "datetime"

          * "datetime.today()"

          * "datetime.now()"

          * "datetime.utcnow()"

          * "datetime.fromtimestamp()"

          * "datetime.utcfromtimestamp()"

          * "datetime.fromordinal()"

          * "datetime.combine()"

          * "datetime.fromisoformat()"

          * "datetime.fromisocalendar()"

          * "datetime.strptime()"

          * "datetime.min"

          * "datetime.max"

          * "datetime.resolution"

          * "datetime.year"

          * "datetime.month"

          * "datetime.day"

          * "datetime.hour"

          * "datetime.minute"

          * "datetime.second"

          * "datetime.microsecond"

          * "datetime.tzinfo"

          * "datetime.fold"

          * "datetime.date()"

          * "datetime.time()"

          * "datetime.timetz()"

          * "datetime.replace()"

          * "datetime.astimezone()"

          * "datetime.utcoffset()"

          * "datetime.dst()"

          * "datetime.tzname()"

          * "datetime.timetuple()"

          * "datetime.utctimetuple()"

          * "datetime.toordinal()"

          * "datetime.timestamp()"

          * "datetime.weekday()"

          * "datetime.isoweekday()"

          * "datetime.isocalendar()"

          * "datetime.isoformat()"

          * "datetime.__str__()"

          * "datetime.ctime()"

          * "datetime.strftime()"

          * "datetime.__format__()"

        * Examples of Usage: "datetime"

      * "time" Objects

        * "time"

          * "time.min"

          * "time.max"

          * "time.resolution"

          * "time.hour"

          * "time.minute"

          * "time.second"

          * "time.microsecond"

          * "time.tzinfo"

          * "time.fold"

          * "time.fromisoformat()"

          * "time.replace()"

          * "time.isoformat()"

          * "time.__str__()"

          * "time.strftime()"

          * "time.__format__()"

          * "time.utcoffset()"

          * "time.dst()"

          * "time.tzname()"

        * Examples of Usage: "time"

      * "tzinfo" Objects

        * "tzinfo"

          * "tzinfo.utcoffset()"

          * "tzinfo.dst()"

          * "tzinfo.tzname()"

          * "tzinfo.fromutc()"

      * "timezone" Objects

        * "timezone"

          * "timezone.utcoffset()"

          * "timezone.tzname()"

          * "timezone.dst()"

          * "timezone.fromutc()"

          * "timezone.utc"

      * "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

        * "ZoneInfo"

          * "ZoneInfo.from_file()"

          * "ZoneInfo.no_cache()"

          * "ZoneInfo.clear_cache()"

          * "ZoneInfo.key"

        * String representations

        * Pickle serialization

      * Functions

        * "available_timezones()"

        * "reset_tzpath()"

      * Globals

        * "TZPATH"

      * Exceptions and warnings

        * "ZoneInfoNotFoundError"

        * "InvalidTZPathWarning"

    * "calendar" --- General calendar-related functions

      * "Calendar"

        * "Calendar.iterweekdays()"

        * "Calendar.itermonthdates()"

        * "Calendar.itermonthdays()"

        * "Calendar.itermonthdays2()"

        * "Calendar.itermonthdays3()"

        * "Calendar.itermonthdays4()"

        * "Calendar.monthdatescalendar()"

        * "Calendar.monthdays2calendar()"

        * "Calendar.monthdayscalendar()"

        * "Calendar.yeardatescalendar()"

        * "Calendar.yeardays2calendar()"

        * "Calendar.yeardayscalendar()"

      * "TextCalendar"

        * "TextCalendar.formatmonth()"

        * "TextCalendar.prmonth()"

        * "TextCalendar.formatyear()"

        * "TextCalendar.pryear()"

      * "HTMLCalendar"

        * "HTMLCalendar.formatmonth()"

        * "HTMLCalendar.formatyear()"

        * "HTMLCalendar.formatyearpage()"

        * "HTMLCalendar.cssclasses"

        * "HTMLCalendar.cssclass_noday"

        * "HTMLCalendar.cssclasses_weekday_head"

        * "HTMLCalendar.cssclass_month_head"

        * "HTMLCalendar.cssclass_month"

        * "HTMLCalendar.cssclass_year"

        * "HTMLCalendar.cssclass_year_head"

      * "LocaleTextCalendar"

      * "LocaleHTMLCalendar"

      * "setfirstweekday()"

      * "firstweekday()"

      * "isleap()"

      * "leapdays()"

      * "weekday()"

      * "weekheader()"

      * "monthrange()"

      * "monthcalendar()"

      * "prmonth()"

      * "month()"

      * "prcal()"

      * "calendar()"

      * "timegm()"

      * "day_name"

      * "day_abbr"

      * "MONDAY"

      * "TUESDAY"

      * "WEDNESDAY"

      * "THURSDAY"

      * "FRIDAY"

      * "SATURDAY"

      * "SUNDAY"

      * "Day"

      * "month_name"

      * "month_abbr"

      * "JANUARY"

      * "FEBRUARY"

      * "MARCH"

      * "APRIL"

      * "MAY"

      * "JUNE"

      * "JULY"

      * "AUGUST"

      * "SEPTEMBER"

      * "OCTOBER"

      * "NOVEMBER"

      * "DECEMBER"

      * "Month"

      * "IllegalMonthError"

        * "IllegalMonthError.month"

      * "IllegalWeekdayError"

        * "IllegalWeekdayError.weekday"

      * Command-Line Usage

    * "collections" --- Container datatypes

      * "ChainMap" objects

        * "ChainMap"

          * "ChainMap.maps"

          * "ChainMap.new_child()"

          * "ChainMap.parents"

        * "ChainMap" Examples and Recipes

      * "Counter" objects

        * "Counter"

          * "Counter.elements()"

          * "Counter.most_common()"

          * "Counter.subtract()"

          * "Counter.total()"

          * "Counter.fromkeys()"

          * "Counter.update()"

      * "deque" objects

        * "deque"

          * "deque.append()"

          * "deque.appendleft()"

          * "deque.clear()"

          * "deque.copy()"

          * "deque.count()"

          * "deque.extend()"

          * "deque.extendleft()"

          * "deque.index()"

          * "deque.insert()"

          * "deque.pop()"

          * "deque.popleft()"

          * "deque.remove()"

          * "deque.reverse()"

          * "deque.rotate()"

          * "deque.maxlen"

        * "deque" Recipes

      * "defaultdict" objects

        * "defaultdict"

          * "defaultdict.__missing__()"

          * "defaultdict.default_factory"

        * "defaultdict" Examples

      * "namedtuple()" Factory Function for Tuples with Named Fields

        * "namedtuple()"

        * "somenamedtuple._make()"

        * "somenamedtuple._asdict()"

        * "somenamedtuple._replace()"

        * "somenamedtuple._fields"

        * "somenamedtuple._field_defaults"

      * "OrderedDict" objects

        * "OrderedDict"

          * "OrderedDict.popitem()"

          * "OrderedDict.move_to_end()"

        * "OrderedDict" Examples and Recipes

      * "UserDict" objects

        * "UserDict"

          * "UserDict.data"

      * "UserList" objects

        * "UserList"

          * "UserList.data"

      * "UserString" objects

        * "UserString"

          * "UserString.data"

    * "collections.abc" --- Abstract Base Classes for Containers

      * Collections Abstract Base Classes

      * Collections Abstract Base Classes -- Detailed Descriptions

        * "Container"

        * "Hashable"

        * "Sized"

        * "Callable"

        * "Iterable"

        * "Collection"

        * "Iterator"

        * "Reversible"

        * "Generator"

        * "Sequence"

        * "MutableSequence"

        * "ByteString"

        * "Set"

        * "MutableSet"

        * "Mapping"

        * "MutableMapping"

        * "MappingView"

        * "ItemsView"

        * "KeysView"

        * "ValuesView"

        * "Awaitable"

        * "Coroutine"

        * "AsyncIterable"

        * "AsyncIterator"

        * "AsyncGenerator"

        * "Buffer"

      * Examples and Recipes

    * "heapq" --- Heap queue algorithm

      * "heappush()"

      * "heappop()"

      * "heappushpop()"

      * "heapify()"

      * "heapreplace()"

      * "merge()"

      * "nlargest()"

      * "nsmallest()"

      * Basic Examples

      * Priority Queue Implementation Notes

      * Theory

    * "bisect" --- Array bisection algorithm

      * "bisect_left()"

      * "bisect_right()"

      * "bisect()"

      * "insort_left()"

      * "insort_right()"

      * "insort()"

      * Performance Notes

      * Searching Sorted Lists

      * Examples

    * "array" --- Efficient arrays of numeric values

      * "typecodes"

      * "array"

        * "array.typecode"

        * "array.itemsize"

        * "array.append()"

        * "array.buffer_info()"

        * "array.byteswap()"

        * "array.count()"

        * "array.extend()"

        * "array.frombytes()"

        * "array.fromfile()"

        * "array.fromlist()"

        * "array.fromunicode()"

        * "array.index()"

        * "array.insert()"

        * "array.pop()"

        * "array.remove()"

        * "array.reverse()"

        * "array.tobytes()"

        * "array.tofile()"

        * "array.tolist()"

        * "array.tounicode()"

    * "weakref" --- Weak references

      * "ref"

        * "ref.__callback__"

      * "proxy()"

      * "getweakrefcount()"

      * "getweakrefs()"

      * "WeakKeyDictionary"

        * "WeakKeyDictionary.keyrefs()"

      * "WeakValueDictionary"

        * "WeakValueDictionary.valuerefs()"

      * "WeakSet"

      * "WeakMethod"

      * "finalize"

        * "finalize.__call__()"

        * "finalize.detach()"

        * "finalize.peek()"

        * "finalize.alive"

        * "finalize.atexit"

      * "ReferenceType"

      * "ProxyType"

      * "CallableProxyType"

      * "ProxyTypes"

      * Weak Reference Objects

      * Example

      * Finalizer Objects

      * Comparing finalizers with "__del__()" methods

    * "types" --- Dynamic type creation and names for built-in types

      * Dynamic Type Creation

        * "new_class()"

        * "prepare_class()"

        * "resolve_bases()"

        * "get_original_bases()"

      * Standard Interpreter Types

        * "NoneType"

        * "FunctionType"

        * "LambdaType"

        * "GeneratorType"

        * "CoroutineType"

        * "AsyncGeneratorType"

        * "CodeType"

          * "CodeType.replace()"

        * "CellType"

        * "MethodType"

        * "BuiltinFunctionType"

        * "BuiltinMethodType"

        * "WrapperDescriptorType"

        * "MethodWrapperType"

        * "NotImplementedType"

        * "MethodDescriptorType"

        * "ClassMethodDescriptorType"

        * "ModuleType"

          * "ModuleType.__doc__"

          * "ModuleType.__loader__"

          * "ModuleType.__name__"

          * "ModuleType.__package__"

          * "ModuleType.__spec__"

        * "EllipsisType"

        * "GenericAlias"

        * "UnionType"

        * "TracebackType"

        * "FrameType"

        * "GetSetDescriptorType"

        * "MemberDescriptorType"

        * "MappingProxyType"

          * "MappingProxyType.copy()"

          * "MappingProxyType.get()"

          * "MappingProxyType.items()"

          * "MappingProxyType.keys()"

          * "MappingProxyType.values()"

        * "CapsuleType"

      * Additional Utility Classes and Functions

        * "SimpleNamespace"

        * "DynamicClassAttribute()"

      * Coroutine Utility Functions

        * "coroutine()"

    * "copy" --- Shallow and deep copy operations

      * "copy()"

      * "deepcopy()"

      * "replace()"

      * "Error"

      * "object.__copy__()"

      * "object.__deepcopy__()"

      * "object.__replace__()"

    * "pprint" --- Data pretty printer

      * "PrettyPrinter"

      * "pformat()"

      * "pp()"

      * "pprint()"

      * "isreadable()"

      * "isrecursive()"

      * "saferepr()"

      * PrettyPrinter Objects

        * "PrettyPrinter.pformat()"

        * "PrettyPrinter.pprint()"

        * "PrettyPrinter.isreadable()"

        * "PrettyPrinter.isrecursive()"

        * "PrettyPrinter.format()"

      * Example

    * "reprlib" --- Alternate "repr()" implementation

      * "Repr"

      * "aRepr"

      * "repr()"

      * "recursive_repr()"

      * Repr Objects

        * "Repr.fillvalue"

        * "Repr.maxlevel"

        * "Repr.maxdict"

        * "Repr.maxlist"

        * "Repr.maxtuple"

        * "Repr.maxset"

        * "Repr.maxfrozenset"

        * "Repr.maxdeque"

        * "Repr.maxarray"

        * "Repr.maxlong"

        * "Repr.maxstring"

        * "Repr.maxother"

        * "Repr.indent"

        * "Repr.repr()"

        * "Repr.repr1()"

      * Subclassing Repr Objects

    * "enum" --- Support for enumerations

      * Module Contents

      * Data Types

        * "EnumType"

          * "EnumType.__call__()"

          * "EnumType.__contains__()"

          * "EnumType.__dir__()"

          * "EnumType.__getitem__()"

          * "EnumType.__iter__()"

          * "EnumType.__len__()"

          * "EnumType.__reversed__()"

        * "Enum"

          * "Enum.name"

          * "Enum.value"

          * "Enum._ignore_"

          * "Enum.__dir__()"

          * "Enum._generate_next_value_()"

          * "Enum.__init_subclass__()"

          * "Enum._missing_()"

          * "Enum.__repr__()"

          * "Enum.__str__()"

          * "Enum.__format__()"

        * "IntEnum"

        * "StrEnum"

        * "Flag"

          * "Flag.__contains__()"

          * "Flag.__or__()"

          * "Flag.__and__()"

          * "Flag.__xor__()"

          * "Flag._numeric_repr_()"

        * "IntFlag"

        * "ReprEnum"

        * "EnumCheck"

          * "EnumCheck.UNIQUE"

          * "EnumCheck.CONTINUOUS"

          * "EnumCheck.NAMED_FLAGS"

        * "FlagBoundary"

          * "FlagBoundary.STRICT"

          * "FlagBoundary.CONFORM"

          * "FlagBoundary.EJECT"

          * "FlagBoundary.KEEP"

        * Supported "__dunder__" names

        * Supported "_sunder_" names

      * Utilities and Decorators

        * "auto"

        * "property()"

        * "unique()"

        * "verify()"

        * "member()"

        * "nonmember()"

        * "global_enum()"

        * "show_flag_values()"

      * Notes

    * "graphlib" --- Functionality to operate with graph-like
      structures

      * "TopologicalSorter"

        * "TopologicalSorter.add()"

        * "TopologicalSorter.prepare()"

        * "TopologicalSorter.is_active()"

        * "TopologicalSorter.done()"

        * "TopologicalSorter.get_ready()"

        * "TopologicalSorter.static_order()"

      * Exceptions

        * "CycleError"

  * Numeric and Mathematical Modules

    * "numbers" --- Numeric abstract base classes

      * "Number"

      * The numeric tower

        * "Complex"

          * "Complex.real"

          * "Complex.imag"

          * "Complex.conjugate()"

        * "Real"

        * "Rational"

          * "Rational.numerator"

          * "Rational.denominator"

        * "Integral"

      * Notes for type implementors

        * Adding More Numeric ABCs

        * Implementing the arithmetic operations

    * "math" --- Mathematical functions

      * Number-theoretic and representation functions

        * "ceil()"

        * "comb()"

        * "copysign()"

        * "fabs()"

        * "factorial()"

        * "floor()"

        * "fmod()"

        * "frexp()"

        * "fsum()"

        * "gcd()"

        * "isclose()"

        * "isfinite()"

        * "isinf()"

        * "isnan()"

        * "isqrt()"

        * "lcm()"

        * "ldexp()"

        * "modf()"

        * "nextafter()"

        * "perm()"

        * "prod()"

        * "remainder()"

        * "sumprod()"

        * "trunc()"

        * "ulp()"

      * Power and logarithmic functions

        * "cbrt()"

        * "exp()"

        * "exp2()"

        * "expm1()"

        * "log()"

        * "log1p()"

        * "log2()"

        * "log10()"

        * "pow()"

        * "sqrt()"

      * Trigonometric functions

        * "acos()"

        * "asin()"

        * "atan()"

        * "atan2()"

        * "cos()"

        * "dist()"

        * "hypot()"

        * "sin()"

        * "tan()"

      * Angular conversion

        * "degrees()"

        * "radians()"

      * Hyperbolic functions

        * "acosh()"

        * "asinh()"

        * "atanh()"

        * "cosh()"

        * "sinh()"

        * "tanh()"

      * Special functions

        * "erf()"

        * "erfc()"

        * "gamma()"

        * "lgamma()"

      * Constants

        * "pi"

        * "e"

        * "tau"

        * "inf"

        * "nan"

    * "cmath" --- Mathematical functions for complex numbers

      * Conversions to and from polar coordinates

        * "phase()"

        * "polar()"

        * "rect()"

      * Power and logarithmic functions

        * "exp()"

        * "log()"

        * "log10()"

        * "sqrt()"

      * Trigonometric functions

        * "acos()"

        * "asin()"

        * "atan()"

        * "cos()"

        * "sin()"

        * "tan()"

      * Hyperbolic functions

        * "acosh()"

        * "asinh()"

        * "atanh()"

        * "cosh()"

        * "sinh()"

        * "tanh()"

      * Classification functions

        * "isfinite()"

        * "isinf()"

        * "isnan()"

        * "isclose()"

      * Constants

        * "pi"

        * "e"

        * "tau"

        * "inf"

        * "infj"

        * "nan"

        * "nanj"

    * "decimal" --- Decimal fixed point and floating point arithmetic

      * Quick-start Tutorial

      * Decimal objects

        * "Decimal"

          * "Decimal.adjusted()"

          * "Decimal.as_integer_ratio()"

          * "Decimal.as_tuple()"

          * "Decimal.canonical()"

          * "Decimal.compare()"

          * "Decimal.compare_signal()"

          * "Decimal.compare_total()"

          * "Decimal.compare_total_mag()"

          * "Decimal.conjugate()"

          * "Decimal.copy_abs()"

          * "Decimal.copy_negate()"

          * "Decimal.copy_sign()"

          * "Decimal.exp()"

          * "Decimal.from_float()"

          * "Decimal.fma()"

          * "Decimal.is_canonical()"

          * "Decimal.is_finite()"

          * "Decimal.is_infinite()"

          * "Decimal.is_nan()"

          * "Decimal.is_normal()"

          * "Decimal.is_qnan()"

          * "Decimal.is_signed()"

          * "Decimal.is_snan()"

          * "Decimal.is_subnormal()"

          * "Decimal.is_zero()"

          * "Decimal.ln()"

          * "Decimal.log10()"

          * "Decimal.logb()"

          * "Decimal.logical_and()"

          * "Decimal.logical_invert()"

          * "Decimal.logical_or()"

          * "Decimal.logical_xor()"

          * "Decimal.max()"

          * "Decimal.max_mag()"

          * "Decimal.min()"

          * "Decimal.min_mag()"

          * "Decimal.next_minus()"

          * "Decimal.next_plus()"

          * "Decimal.next_toward()"

          * "Decimal.normalize()"

          * "Decimal.number_class()"

          * "Decimal.quantize()"

          * "Decimal.radix()"

          * "Decimal.remainder_near()"

          * "Decimal.rotate()"

          * "Decimal.same_quantum()"

          * "Decimal.scaleb()"

          * "Decimal.shift()"

          * "Decimal.sqrt()"

          * "Decimal.to_eng_string()"

          * "Decimal.to_integral()"

          * "Decimal.to_integral_exact()"

          * "Decimal.to_integral_value()"

        * Logical operands

      * Context objects

        * "getcontext()"

        * "setcontext()"

        * "localcontext()"

        * "BasicContext"

        * "ExtendedContext"

        * "DefaultContext"

        * "Context"

          * "Context.clear_flags()"

          * "Context.clear_traps()"

          * "Context.copy()"

          * "Context.copy_decimal()"

          * "Context.create_decimal()"

          * "Context.create_decimal_from_float()"

          * "Context.Etiny()"

          * "Context.Etop()"

          * "Context.abs()"

          * "Context.add()"

          * "Context.canonical()"

          * "Context.compare()"

          * "Context.compare_signal()"

          * "Context.compare_total()"

          * "Context.compare_total_mag()"

          * "Context.copy_abs()"

          * "Context.copy_negate()"

          * "Context.copy_sign()"

          * "Context.divide()"

          * "Context.divide_int()"

          * "Context.divmod()"

          * "Context.exp()"

          * "Context.fma()"

          * "Context.is_canonical()"

          * "Context.is_finite()"

          * "Context.is_infinite()"

          * "Context.is_nan()"

          * "Context.is_normal()"

          * "Context.is_qnan()"

          * "Context.is_signed()"

          * "Context.is_snan()"

          * "Context.is_subnormal()"

          * "Context.is_zero()"

          * "Context.ln()"

          * "Context.log10()"

          * "Context.logb()"

          * "Context.logical_and()"

          * "Context.logical_invert()"

          * "Context.logical_or()"

          * "Context.logical_xor()"

          * "Context.max()"

          * "Context.max_mag()"

          * "Context.min()"

          * "Context.min_mag()"

          * "Context.minus()"

          * "Context.multiply()"

          * "Context.next_minus()"

          * "Context.next_plus()"

          * "Context.next_toward()"

          * "Context.normalize()"

          * "Context.number_class()"

          * "Context.plus()"

          * "Context.power()"

          * "Context.quantize()"

          * "Context.radix()"

          * "Context.remainder()"

          * "Context.remainder_near()"

          * "Context.rotate()"

          * "Context.same_quantum()"

          * "Context.scaleb()"

          * "Context.shift()"

          * "Context.sqrt()"

          * "Context.subtract()"

          * "Context.to_eng_string()"

          * "Context.to_integral_exact()"

          * "Context.to_sci_string()"

      * Constants

        * "MAX_PREC"

        * "MAX_EMAX"

        * "MIN_EMIN"

        * "MIN_ETINY"

        * "HAVE_THREADS"

        * "HAVE_CONTEXTVAR"

      * Rounding modes

        * "ROUND_CEILING"

        * "ROUND_DOWN"

        * "ROUND_FLOOR"

        * "ROUND_HALF_DOWN"

        * "ROUND_HALF_EVEN"

        * "ROUND_HALF_UP"

        * "ROUND_UP"

        * "ROUND_05UP"

      * Signals

        * "Clamped"

        * "DecimalException"

        * "DivisionByZero"

        * "Inexact"

        * "InvalidOperation"

        * "Overflow"

        * "Rounded"

        * "Subnormal"

        * "Underflow"

        * "FloatOperation"

      * Floating Point Notes

        * Mitigating round-off error with increased precision

        * Special values

      * Working with threads

      * Recipes

      * Decimal FAQ

    * "fractions" --- Rational numbers

      * "Fraction"

        * "Fraction.numerator"

        * "Fraction.denominator"

        * "Fraction.as_integer_ratio()"

        * "Fraction.is_integer()"

        * "Fraction.from_float()"

        * "Fraction.from_decimal()"

        * "Fraction.limit_denominator()"

        * "Fraction.__floor__()"

        * "Fraction.__ceil__()"

        * "Fraction.__round__()"

        * "Fraction.__format__()"

    * "random" --- Generate pseudo-random numbers

      * Bookkeeping functions

        * "seed()"

        * "getstate()"

        * "setstate()"

      * Functions for bytes

        * "randbytes()"

      * Functions for integers

        * "randrange()"

        * "randint()"

        * "getrandbits()"

      * Functions for sequences

        * "choice()"

        * "choices()"

        * "shuffle()"

        * "sample()"

      * Discrete distributions

        * "binomialvariate()"

      * Real-valued distributions

        * "random()"

        * "uniform()"

        * "triangular()"

        * "betavariate()"

        * "expovariate()"

        * "gammavariate()"

        * "gauss()"

        * "lognormvariate()"

        * "normalvariate()"

        * "vonmisesvariate()"

        * "paretovariate()"

        * "weibullvariate()"

      * Alternative Generator

        * "Random"

        * "SystemRandom"

      * 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

        * "mean()"

        * "fmean()"

        * "geometric_mean()"

        * "harmonic_mean()"

        * "median()"

        * "median_low()"

        * "median_high()"

        * "median_grouped()"

        * "mode()"

        * "multimode()"

        * "pstdev()"

        * "pvariance()"

        * "stdev()"

        * "variance()"

        * "quantiles()"

        * "covariance()"

        * "correlation()"

        * "linear_regression()"

      * Exceptions

        * "StatisticsError"

      * "NormalDist" objects

        * "NormalDist"

          * "NormalDist.mean"

          * "NormalDist.median"

          * "NormalDist.mode"

          * "NormalDist.stdev"

          * "NormalDist.variance"

          * "NormalDist.from_samples()"

          * "NormalDist.samples()"

          * "NormalDist.pdf()"

          * "NormalDist.cdf()"

          * "NormalDist.inv_cdf()"

          * "NormalDist.overlap()"

          * "NormalDist.quantiles()"

          * "NormalDist.zscore()"

        * "NormalDist" Examples and Recipes

          * Classic probability problems

          * Monte Carlo inputs for simulations

          * Approximating binomial distributions

          * Naive bayesian classifier

          * Kernel density estimation

  * Functional Programming Modules

    * "itertools" --- Functions creating iterators for efficient
      looping

      * Itertool functions

        * "accumulate()"

        * "batched()"

        * "chain()"

          * "chain.from_iterable()"

        * "combinations()"

        * "combinations_with_replacement()"

        * "compress()"

        * "count()"

        * "cycle()"

        * "dropwhile()"

        * "filterfalse()"

        * "groupby()"

        * "islice()"

        * "pairwise()"

        * "permutations()"

        * "product()"

        * "repeat()"

        * "starmap()"

        * "takewhile()"

        * "tee()"

        * "zip_longest()"

      * Itertools Recipes

    * "functools" --- Higher-order functions and operations on
      callable objects

      * "cache()"

      * "cached_property()"

      * "cmp_to_key()"

      * "lru_cache()"

      * "total_ordering()"

      * "partial()"

      * "partialmethod"

      * "reduce()"

      * "singledispatch()"

      * "singledispatchmethod"

      * "update_wrapper()"

      * "wraps()"

      * "partial" Objects

        * "partial.func"

        * "partial.args"

        * "partial.keywords"

    * "operator" --- Standard operators as functions

      * "lt()"

      * "le()"

      * "eq()"

      * "ne()"

      * "ge()"

      * "gt()"

      * "__lt__()"

      * "__le__()"

      * "__eq__()"

      * "__ne__()"

      * "__ge__()"

      * "__gt__()"

      * "not_()"

      * "__not__()"

      * "truth()"

      * "is_()"

      * "is_not()"

      * "abs()"

      * "__abs__()"

      * "add()"

      * "__add__()"

      * "and_()"

      * "__and__()"

      * "floordiv()"

      * "__floordiv__()"

      * "index()"

      * "__index__()"

      * "inv()"

      * "invert()"

      * "__inv__()"

      * "__invert__()"

      * "lshift()"

      * "__lshift__()"

      * "mod()"

      * "__mod__()"

      * "mul()"

      * "__mul__()"

      * "matmul()"

      * "__matmul__()"

      * "neg()"

      * "__neg__()"

      * "or_()"

      * "__or__()"

      * "pos()"

      * "__pos__()"

      * "pow()"

      * "__pow__()"

      * "rshift()"

      * "__rshift__()"

      * "sub()"

      * "__sub__()"

      * "truediv()"

      * "__truediv__()"

      * "xor()"

      * "__xor__()"

      * "concat()"

      * "__concat__()"

      * "contains()"

      * "__contains__()"

      * "countOf()"

      * "delitem()"

      * "__delitem__()"

      * "getitem()"

      * "__getitem__()"

      * "indexOf()"

      * "setitem()"

      * "__setitem__()"

      * "length_hint()"

      * "call()"

      * "__call__()"

      * "attrgetter()"

      * "itemgetter()"

      * "methodcaller()"

      * Mapping Operators to Functions

      * In-place Operators

        * "iadd()"

        * "__iadd__()"

        * "iand()"

        * "__iand__()"

        * "iconcat()"

        * "__iconcat__()"

        * "ifloordiv()"

        * "__ifloordiv__()"

        * "ilshift()"

        * "__ilshift__()"

        * "imod()"

        * "__imod__()"

        * "imul()"

        * "__imul__()"

        * "imatmul()"

        * "__imatmul__()"

        * "ior()"

        * "__ior__()"

        * "ipow()"

        * "__ipow__()"

        * "irshift()"

        * "__irshift__()"

        * "isub()"

        * "__isub__()"

        * "itruediv()"

        * "__itruediv__()"

        * "ixor()"

        * "__ixor__()"

  * File and Directory Access

    * "pathlib" --- Object-oriented filesystem paths

      * Basic use

      * Exceptions

        * "UnsupportedOperation"

      * Pure paths

        * "PurePath"

        * "PurePosixPath"

        * "PureWindowsPath"

        * General properties

        * Operators

        * Accessing individual parts

          * "PurePath.parts"

        * Methods and properties

          * "PurePath.pathmod"

          * "PurePath.drive"

          * "PurePath.root"

          * "PurePath.anchor"

          * "PurePath.parents"

          * "PurePath.parent"

          * "PurePath.name"

          * "PurePath.suffix"

          * "PurePath.suffixes"

          * "PurePath.stem"

          * "PurePath.as_posix()"

          * "PurePath.as_uri()"

          * "PurePath.is_absolute()"

          * "PurePath.is_relative_to()"

          * "PurePath.is_reserved()"

          * "PurePath.joinpath()"

          * "PurePath.match()"

          * "PurePath.relative_to()"

          * "PurePath.with_name()"

          * "PurePath.with_stem()"

          * "PurePath.with_suffix()"

          * "PurePath.with_segments()"

      * Concrete paths

        * "Path"

        * "PosixPath"

        * "WindowsPath"

        * Methods

          * "Path.cwd()"

          * "Path.home()"

          * "Path.from_uri()"

          * "Path.stat()"

          * "Path.chmod()"

          * "Path.exists()"

          * "Path.expanduser()"

          * "Path.glob()"

          * "Path.group()"

          * "Path.is_dir()"

          * "Path.is_file()"

          * "Path.is_junction()"

          * "Path.is_mount()"

          * "Path.is_symlink()"

          * "Path.is_socket()"

          * "Path.is_fifo()"

          * "Path.is_block_device()"

          * "Path.is_char_device()"

          * "Path.iterdir()"

          * "Path.walk()"

          * "Path.lchmod()"

          * "Path.lstat()"

          * "Path.mkdir()"

          * "Path.open()"

          * "Path.owner()"

          * "Path.read_bytes()"

          * "Path.read_text()"

          * "Path.readlink()"

          * "Path.rename()"

          * "Path.replace()"

          * "Path.absolute()"

          * "Path.resolve()"

          * "Path.rglob()"

          * "Path.rmdir()"

          * "Path.samefile()"

          * "Path.symlink_to()"

          * "Path.hardlink_to()"

          * "Path.touch()"

          * "Path.unlink()"

          * "Path.write_bytes()"

          * "Path.write_text()"

      * Correspondence to tools in the "os" module

    * "os.path" --- Common pathname manipulations

      * "abspath()"

      * "basename()"

      * "commonpath()"

      * "commonprefix()"

      * "dirname()"

      * "exists()"

      * "lexists()"

      * "expanduser()"

      * "expandvars()"

      * "getatime()"

      * "getmtime()"

      * "getctime()"

      * "getsize()"

      * "isabs()"

      * "isfile()"

      * "isdir()"

      * "isjunction()"

      * "islink()"

      * "ismount()"

      * "isdevdrive()"

      * "join()"

      * "normcase()"

      * "normpath()"

      * "realpath()"

      * "relpath()"

      * "samefile()"

      * "sameopenfile()"

      * "samestat()"

      * "split()"

      * "splitdrive()"

      * "splitroot()"

      * "splitext()"

      * "supports_unicode_filenames"

    * "fileinput" --- Iterate over lines from multiple input streams

      * "input()"

      * "filename()"

      * "fileno()"

      * "lineno()"

      * "filelineno()"

      * "isfirstline()"

      * "isstdin()"

      * "nextfile()"

      * "close()"

      * "FileInput"

      * "hook_compressed()"

      * "hook_encoded()"

    * "stat" --- Interpreting "stat()" results

      * "S_ISDIR()"

      * "S_ISCHR()"

      * "S_ISBLK()"

      * "S_ISREG()"

      * "S_ISFIFO()"

      * "S_ISLNK()"

      * "S_ISSOCK()"

      * "S_ISDOOR()"

      * "S_ISPORT()"

      * "S_ISWHT()"

      * "S_IMODE()"

      * "S_IFMT()"

      * "filemode()"

      * "ST_MODE"

      * "ST_INO"

      * "ST_DEV"

      * "ST_NLINK"

      * "ST_UID"

      * "ST_GID"

      * "ST_SIZE"

      * "ST_ATIME"

      * "ST_MTIME"

      * "ST_CTIME"

      * "S_IFSOCK"

      * "S_IFLNK"

      * "S_IFREG"

      * "S_IFBLK"

      * "S_IFDIR"

      * "S_IFCHR"

      * "S_IFIFO"

      * "S_IFDOOR"

      * "S_IFPORT"

      * "S_IFWHT"

      * "S_ISUID"

      * "S_ISGID"

      * "S_ISVTX"

      * "S_IRWXU"

      * "S_IRUSR"

      * "S_IWUSR"

      * "S_IXUSR"

      * "S_IRWXG"

      * "S_IRGRP"

      * "S_IWGRP"

      * "S_IXGRP"

      * "S_IRWXO"

      * "S_IROTH"

      * "S_IWOTH"

      * "S_IXOTH"

      * "S_ENFMT"

      * "S_IREAD"

      * "S_IWRITE"

      * "S_IEXEC"

      * "UF_NODUMP"

      * "UF_IMMUTABLE"

      * "UF_APPEND"

      * "UF_OPAQUE"

      * "UF_NOUNLINK"

      * "UF_COMPRESSED"

      * "UF_HIDDEN"

      * "SF_ARCHIVED"

      * "SF_IMMUTABLE"

      * "SF_APPEND"

      * "SF_NOUNLINK"

      * "SF_SNAPSHOT"

      * "FILE_ATTRIBUTE_ARCHIVE"

      * "FILE_ATTRIBUTE_COMPRESSED"

      * "FILE_ATTRIBUTE_DEVICE"

      * "FILE_ATTRIBUTE_DIRECTORY"

      * "FILE_ATTRIBUTE_ENCRYPTED"

      * "FILE_ATTRIBUTE_HIDDEN"

      * "FILE_ATTRIBUTE_INTEGRITY_STREAM"

      * "FILE_ATTRIBUTE_NORMAL"

      * "FILE_ATTRIBUTE_NOT_CONTENT_INDEXED"

      * "FILE_ATTRIBUTE_NO_SCRUB_DATA"

      * "FILE_ATTRIBUTE_OFFLINE"

      * "FILE_ATTRIBUTE_READONLY"

      * "FILE_ATTRIBUTE_REPARSE_POINT"

      * "FILE_ATTRIBUTE_SPARSE_FILE"

      * "FILE_ATTRIBUTE_SYSTEM"

      * "FILE_ATTRIBUTE_TEMPORARY"

      * "FILE_ATTRIBUTE_VIRTUAL"

      * "IO_REPARSE_TAG_SYMLINK"

      * "IO_REPARSE_TAG_MOUNT_POINT"

      * "IO_REPARSE_TAG_APPEXECLINK"

    * "filecmp" --- File and Directory Comparisons

      * "cmp()"

      * "cmpfiles()"

      * "clear_cache()"

      * The "dircmp" class

        * "dircmp"

          * "dircmp.report()"

          * "dircmp.report_partial_closure()"

          * "dircmp.report_full_closure()"

          * "dircmp.left"

          * "dircmp.right"

          * "dircmp.left_list"

          * "dircmp.right_list"

          * "dircmp.common"

          * "dircmp.left_only"

          * "dircmp.right_only"

          * "dircmp.common_dirs"

          * "dircmp.common_files"

          * "dircmp.common_funny"

          * "dircmp.same_files"

          * "dircmp.diff_files"

          * "dircmp.funny_files"

          * "dircmp.subdirs"

        * "DEFAULT_IGNORES"

    * "tempfile" --- Generate temporary files and directories

      * "TemporaryFile()"

      * "NamedTemporaryFile()"

      * "SpooledTemporaryFile"

      * "TemporaryDirectory"

      * "mkstemp()"

      * "mkdtemp()"

      * "gettempdir()"

      * "gettempdirb()"

      * "gettempprefix()"

      * "gettempprefixb()"

      * "tempdir"

      * Examples

      * Deprecated functions and variables

        * "mktemp()"

    * "glob" --- Unix style pathname pattern expansion

      * "glob()"

      * "iglob()"

      * "escape()"

    * "fnmatch" --- Unix filename pattern matching

      * "fnmatch()"

      * "fnmatchcase()"

      * "filter()"

      * "translate()"

    * "linecache" --- Random access to text lines

      * "getline()"

      * "clearcache()"

      * "checkcache()"

      * "lazycache()"

    * "shutil" --- High-level file operations

      * Directory and files operations

        * "copyfileobj()"

        * "copyfile()"

        * "SameFileError"

        * "copymode()"

        * "copystat()"

        * "copy()"

        * "copy2()"

        * "ignore_patterns()"

        * "copytree()"

        * "rmtree()"

          * "rmtree.avoids_symlink_attacks"

        * "move()"

        * "disk_usage()"

        * "chown()"

        * "which()"

        * "Error"

        * Platform-dependent efficient copy operations

        * copytree example

        * rmtree example

      * Archiving operations

        * "make_archive()"

        * "get_archive_formats()"

        * "register_archive_format()"

        * "unregister_archive_format()"

        * "unpack_archive()"

        * "register_unpack_format()"

        * "unregister_unpack_format()"

        * "get_unpack_formats()"

        * Archiving example

        * Archiving example with *base_dir*

      * Querying the size of the output terminal

        * "get_terminal_size()"

  * Data Persistence

    * "pickle" --- Python object serialization

      * Relationship to other Python modules

        * Comparison with "marshal"

        * Comparison with "json"

      * Data stream format

      * Module Interface

        * "HIGHEST_PROTOCOL"

        * "DEFAULT_PROTOCOL"

        * "dump()"

        * "dumps()"

        * "load()"

        * "loads()"

        * "PickleError"

        * "PicklingError"

        * "UnpicklingError"

        * "Pickler"

          * "Pickler.dump()"

          * "Pickler.persistent_id()"

          * "Pickler.dispatch_table"

          * "Pickler.reducer_override()"

          * "Pickler.fast"

        * "Unpickler"

          * "Unpickler.load()"

          * "Unpickler.persistent_load()"

          * "Unpickler.find_class()"

        * "PickleBuffer"

          * "PickleBuffer.raw()"

          * "PickleBuffer.release()"

      * What can be pickled and unpickled?

      * Pickling Class Instances

        * "object.__getnewargs_ex__()"

        * "object.__getnewargs__()"

        * "object.__getstate__()"

        * "object.__setstate__()"

        * "object.__reduce__()"

        * "object.__reduce_ex__()"

        * 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

      * "constructor()"

      * "pickle()"

      * Example

    * "shelve" --- Python object persistence

      * "open()"

      * "Shelf.sync()"

      * "Shelf.close()"

      * Restrictions

        * "Shelf"

        * "BsdDbShelf"

        * "DbfilenameShelf"

      * Example

    * "marshal" --- Internal Python object serialization

      * "dump()"

      * "load()"

      * "dumps()"

      * "loads()"

      * "version"

    * "dbm" --- Interfaces to Unix "databases"

      * "error"

      * "whichdb()"

      * "open()"

      * "dbm.gnu" --- GNU's reinterpretation of dbm

        * "error"

        * "open()"

        * "gdbm.firstkey()"

        * "gdbm.nextkey()"

        * "gdbm.reorganize()"

        * "gdbm.sync()"

        * "gdbm.close()"

        * "gdbm.clear()"

      * "dbm.ndbm" --- Interface based on ndbm

        * "error"

        * "library"

        * "open()"

        * "ndbm.close()"

        * "ndbm.clear()"

      * "dbm.dumb" --- Portable DBM implementation

        * "error"

        * "open()"

        * "dumbdbm.sync()"

        * "dumbdbm.close()"

    * "sqlite3" --- DB-API 2.0 interface for SQLite databases

      * Tutorial

      * Reference

        * Module functions

          * "connect()"

          * "complete_statement()"

          * "enable_callback_tracebacks()"

          * "register_adapter()"

          * "register_converter()"

        * Module constants

          * "LEGACY_TRANSACTION_CONTROL"

          * "PARSE_COLNAMES"

          * "PARSE_DECLTYPES"

          * "SQLITE_OK"

          * "SQLITE_DENY"

          * "SQLITE_IGNORE"

          * "apilevel"

          * "paramstyle"

          * "sqlite_version"

          * "sqlite_version_info"

          * "threadsafety"

          * "version"

          * "version_info"

          * "SQLITE_DBCONFIG_DEFENSIVE"

          * "SQLITE_DBCONFIG_DQS_DDL"

          * "SQLITE_DBCONFIG_DQS_DML"

          * "SQLITE_DBCONFIG_ENABLE_FKEY"

          * "SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER"

          * "SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION"

          * "SQLITE_DBCONFIG_ENABLE_QPSG"

          * "SQLITE_DBCONFIG_ENABLE_TRIGGER"

          * "SQLITE_DBCONFIG_ENABLE_VIEW"

          * "SQLITE_DBCONFIG_LEGACY_ALTER_TABLE"

          * "SQLITE_DBCONFIG_LEGACY_FILE_FORMAT"

          * "SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE"

          * "SQLITE_DBCONFIG_RESET_DATABASE"

          * "SQLITE_DBCONFIG_TRIGGER_EQP"

          * "SQLITE_DBCONFIG_TRUSTED_SCHEMA"

          * "SQLITE_DBCONFIG_WRITABLE_SCHEMA"

        * Connection objects

          * "Connection"

            * "Connection.cursor()"

            * "Connection.blobopen()"

            * "Connection.commit()"

            * "Connection.rollback()"

            * "Connection.close()"

            * "Connection.execute()"

            * "Connection.executemany()"

            * "Connection.executescript()"

            * "Connection.create_function()"

            * "Connection.create_aggregate()"

            * "Connection.create_window_function()"

            * "Connection.create_collation()"

            * "Connection.interrupt()"

            * "Connection.set_authorizer()"

            * "Connection.set_progress_handler()"

            * "Connection.set_trace_callback()"

            * "Connection.enable_load_extension()"

            * "Connection.load_extension()"

            * "Connection.iterdump()"

            * "Connection.backup()"

            * "Connection.getlimit()"

            * "Connection.setlimit()"

            * "Connection.getconfig()"

            * "Connection.setconfig()"

            * "Connection.serialize()"

            * "Connection.deserialize()"

            * "Connection.autocommit"

            * "Connection.in_transaction"

            * "Connection.isolation_level"

            * "Connection.row_factory"

            * "Connection.text_factory"

            * "Connection.total_changes"

        * Cursor objects

          * "Cursor"

            * "Cursor.execute()"

            * "Cursor.executemany()"

            * "Cursor.executescript()"

            * "Cursor.fetchone()"

            * "Cursor.fetchmany()"

            * "Cursor.fetchall()"

            * "Cursor.close()"

            * "Cursor.setinputsizes()"

            * "Cursor.setoutputsize()"

            * "Cursor.arraysize"

            * "Cursor.connection"

            * "Cursor.description"

            * "Cursor.lastrowid"

            * "Cursor.rowcount"

            * "Cursor.row_factory"

        * Row objects

          * "Row"

            * "Row.keys()"

        * Blob objects

          * "Blob"

            * "Blob.close()"

            * "Blob.read()"

            * "Blob.write()"

            * "Blob.tell()"

            * "Blob.seek()"

        * PrepareProtocol objects

          * "PrepareProtocol"

        * Exceptions

          * "Warning"

          * "Error"

            * "Error.sqlite_errorcode"

            * "Error.sqlite_errorname"

          * "InterfaceError"

          * "DatabaseError"

          * "DataError"

          * "OperationalError"

          * "IntegrityError"

          * "InternalError"

          * "ProgrammingError"

          * "NotSupportedError"

        * SQLite and Python types

        * Default adapters and converters (deprecated)

        * Command-line interface

      * How-to guides

        * How to use placeholders to bind values in SQL queries

        * How to adapt custom Python types to SQLite values

          * How to write adaptable objects

          * How to register adapter callables

        * How to convert SQLite values to custom Python types

        * Adapter and converter recipes

        * How to use connection shortcut methods

        * How to use the connection context manager

        * How to work with SQLite URIs

        * How to create and use row factories

      * Explanation

        * Transaction control

          * Transaction control via the "autocommit" attribute

          * Transaction control via the "isolation_level" attribute

  * Data Compression and Archiving

    * "zlib" --- Compression compatible with **gzip**

      * "error"

      * "adler32()"

      * "compress()"

      * "compressobj()"

      * "crc32()"

      * "decompress()"

      * "decompressobj()"

      * "Compress.compress()"

      * "Compress.flush()"

      * "Compress.copy()"

      * "Decompress.unused_data"

      * "Decompress.unconsumed_tail"

      * "Decompress.eof"

      * "Decompress.decompress()"

      * "Decompress.flush()"

      * "Decompress.copy()"

      * "ZLIB_VERSION"

      * "ZLIB_RUNTIME_VERSION"

    * "gzip" --- Support for **gzip** files

      * "open()"

      * "BadGzipFile"

      * "GzipFile"

        * "GzipFile.peek()"

        * "GzipFile.mtime"

        * "GzipFile.name"

      * "compress()"

      * "decompress()"

      * Examples of usage

      * Command Line Interface

        * Command line options

    * "bz2" --- Support for **bzip2** compression

      * (De)compression of files

        * "open()"

        * "BZ2File"

          * "BZ2File.peek()"

      * Incremental (de)compression

        * "BZ2Compressor"

          * "BZ2Compressor.compress()"

          * "BZ2Compressor.flush()"

        * "BZ2Decompressor"

          * "BZ2Decompressor.decompress()"

          * "BZ2Decompressor.eof"

          * "BZ2Decompressor.unused_data"

          * "BZ2Decompressor.needs_input"

      * One-shot (de)compression

        * "compress()"

        * "decompress()"

      * Examples of usage

    * "lzma" --- Compression using the LZMA algorithm

      * "LZMAError"

      * Reading and writing compressed files

        * "open()"

        * "LZMAFile"

          * "LZMAFile.peek()"

      * Compressing and decompressing data in memory

        * "LZMACompressor"

          * "LZMACompressor.compress()"

          * "LZMACompressor.flush()"

        * "LZMADecompressor"

          * "LZMADecompressor.decompress()"

          * "LZMADecompressor.check"

          * "LZMADecompressor.eof"

          * "LZMADecompressor.unused_data"

          * "LZMADecompressor.needs_input"

        * "compress()"

        * "decompress()"

      * Miscellaneous

        * "is_check_supported()"

      * Specifying custom filter chains

      * Examples

    * "zipfile" --- Work with ZIP archives

      * "BadZipFile"

      * "BadZipfile"

      * "LargeZipFile"

      * "ZipInfo"

      * "is_zipfile()"

      * "ZIP_STORED"

      * "ZIP_DEFLATED"

      * "ZIP_BZIP2"

      * "ZIP_LZMA"

      * ZipFile Objects

        * "ZipFile"

          * "ZipFile.close()"

          * "ZipFile.getinfo()"

          * "ZipFile.infolist()"

          * "ZipFile.namelist()"

          * "ZipFile.open()"

          * "ZipFile.extract()"

          * "ZipFile.extractall()"

          * "ZipFile.printdir()"

          * "ZipFile.setpassword()"

          * "ZipFile.read()"

          * "ZipFile.testzip()"

          * "ZipFile.write()"

          * "ZipFile.writestr()"

          * "ZipFile.mkdir()"

          * "ZipFile.filename"

          * "ZipFile.debug"

          * "ZipFile.comment"

      * Path Objects

        * "Path"

          * "Path.name"

          * "Path.open()"

          * "Path.iterdir()"

          * "Path.is_dir()"

          * "Path.is_file()"

          * "Path.exists()"

          * "Path.suffix"

          * "Path.stem"

          * "Path.suffixes"

          * "Path.read_text()"

          * "Path.read_bytes()"

          * "Path.joinpath()"

      * PyZipFile Objects

        * "PyZipFile"

          * "PyZipFile.writepy()"

      * ZipInfo Objects

        * "ZipInfo.from_file()"

        * "ZipInfo.is_dir()"

        * "ZipInfo.filename"

        * "ZipInfo.date_time"

        * "ZipInfo.compress_type"

        * "ZipInfo.comment"

        * "ZipInfo.extra"

        * "ZipInfo.create_system"

        * "ZipInfo.create_version"

        * "ZipInfo.extract_version"

        * "ZipInfo.reserved"

        * "ZipInfo.flag_bits"

        * "ZipInfo.volume"

        * "ZipInfo.internal_attr"

        * "ZipInfo.external_attr"

        * "ZipInfo.header_offset"

        * "ZipInfo.CRC"

        * "ZipInfo.compress_size"

        * "ZipInfo.file_size"

      * 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

      * "open()"

      * "is_tarfile()"

      * "TarError"

      * "ReadError"

      * "CompressionError"

      * "StreamError"

      * "ExtractError"

      * "HeaderError"

      * "FilterError"

        * "FilterError.tarinfo"

      * "AbsolutePathError"

      * "OutsideDestinationError"

      * "SpecialFileError"

      * "AbsoluteLinkError"

      * "LinkOutsideDestinationError"

      * "ENCODING"

      * "USTAR_FORMAT"

      * "GNU_FORMAT"

      * "PAX_FORMAT"

      * "DEFAULT_FORMAT"

      * TarFile Objects

        * "TarFile"

          * "TarFile.open()"

          * "TarFile.getmember()"

          * "TarFile.getmembers()"

          * "TarFile.getnames()"

          * "TarFile.list()"

          * "TarFile.next()"

          * "TarFile.extractall()"

          * "TarFile.extract()"

          * "TarFile.extractfile()"

          * "TarFile.errorlevel"

          * "TarFile.extraction_filter"

          * "TarFile.add()"

          * "TarFile.addfile()"

          * "TarFile.gettarinfo()"

          * "TarFile.close()"

          * "TarFile.pax_headers"

      * TarInfo Objects

        * "TarInfo"

          * "TarInfo.frombuf()"

          * "TarInfo.fromtarfile()"

          * "TarInfo.tobuf()"

          * "TarInfo.name"

          * "TarInfo.size"

          * "TarInfo.mtime"

          * "TarInfo.mode"

          * "TarInfo.type"

          * "TarInfo.linkname"

          * "TarInfo.uid"

          * "TarInfo.gid"

          * "TarInfo.uname"

          * "TarInfo.gname"

          * "TarInfo.pax_headers"

          * "TarInfo.isfile()"

          * "TarInfo.isreg()"

          * "TarInfo.isdir()"

          * "TarInfo.issym()"

          * "TarInfo.islnk()"

          * "TarInfo.ischr()"

          * "TarInfo.isblk()"

          * "TarInfo.isfifo()"

          * "TarInfo.isdev()"

      * Extraction filters

        * Default named filters

          * "fully_trusted_filter()"

          * "tar_filter()"

          * "data_filter()"

        * Filter errors

        * Hints for further verification

        * Supporting older Python versions

        * Stateful extraction filter example

      * Command-Line Interface

        * Command-line options

      * Examples

      * Supported tar formats

      * Unicode issues

  * File Formats

    * "csv" --- CSV File Reading and Writing

      * Module Contents

        * "reader()"

        * "writer()"

        * "register_dialect()"

        * "unregister_dialect()"

        * "get_dialect()"

        * "list_dialects()"

        * "field_size_limit()"

        * "DictReader"

        * "DictWriter"

        * "Dialect"

        * "excel"

        * "excel_tab"

        * "unix_dialect"

        * "Sniffer"

          * "Sniffer.sniff()"

          * "Sniffer.has_header()"

        * "QUOTE_ALL"

        * "QUOTE_MINIMAL"

        * "QUOTE_NONNUMERIC"

        * "QUOTE_NONE"

        * "QUOTE_NOTNULL"

        * "QUOTE_STRINGS"

        * "Error"

      * Dialects and Formatting Parameters

        * "Dialect.delimiter"

        * "Dialect.doublequote"

        * "Dialect.escapechar"

        * "Dialect.lineterminator"

        * "Dialect.quotechar"

        * "Dialect.quoting"

        * "Dialect.skipinitialspace"

        * "Dialect.strict"

      * Reader Objects

        * "csvreader.__next__()"

        * "csvreader.dialect"

        * "csvreader.line_num"

        * "DictReader.fieldnames"

      * Writer Objects

        * "csvwriter.writerow()"

        * "csvwriter.writerows()"

        * "csvwriter.dialect"

        * "DictWriter.writeheader()"

      * Examples

    * "configparser" --- Configuration file parser

      * Quick Start

      * Supported Datatypes

      * Fallback Values

      * Supported INI File Structure

      * Interpolation of values

        * "BasicInterpolation"

        * "ExtendedInterpolation"

      * Mapping Protocol Access

      * Customizing Parser Behaviour

        * "ConfigParser.BOOLEAN_STATES"

        * "ConfigParser.SECTCRE"

      * Legacy API Examples

      * ConfigParser Objects

        * "ConfigParser"

          * "ConfigParser.defaults()"

          * "ConfigParser.sections()"

          * "ConfigParser.add_section()"

          * "ConfigParser.has_section()"

          * "ConfigParser.options()"

          * "ConfigParser.has_option()"

          * "ConfigParser.read()"

          * "ConfigParser.read_file()"

          * "ConfigParser.read_string()"

          * "ConfigParser.read_dict()"

          * "ConfigParser.get()"

          * "ConfigParser.getint()"

          * "ConfigParser.getfloat()"

          * "ConfigParser.getboolean()"

          * "ConfigParser.items()"

          * "ConfigParser.set()"

          * "ConfigParser.write()"

          * "ConfigParser.remove_option()"

          * "ConfigParser.remove_section()"

          * "ConfigParser.optionxform()"

        * "MAX_INTERPOLATION_DEPTH"

      * RawConfigParser Objects

        * "RawConfigParser"

          * "RawConfigParser.add_section()"

          * "RawConfigParser.set()"

      * Exceptions

        * "Error"

        * "NoSectionError"

        * "DuplicateSectionError"

        * "DuplicateOptionError"

        * "NoOptionError"

        * "InterpolationError"

        * "InterpolationDepthError"

        * "InterpolationMissingOptionError"

        * "InterpolationSyntaxError"

        * "MissingSectionHeaderError"

        * "ParsingError"

    * "tomllib" --- Parse TOML files

      * "load()"

      * "loads()"

      * "TOMLDecodeError"

      * Examples

      * Conversion Table

    * "netrc" --- netrc file processing

      * "netrc"

      * "NetrcParseError"

        * "NetrcParseError.msg"

        * "NetrcParseError.filename"

        * "NetrcParseError.lineno"

      * netrc Objects

        * "netrc.authenticators()"

        * "netrc.__repr__()"

        * "netrc.hosts"

        * "netrc.macros"

    * "plistlib" --- Generate and parse Apple ".plist" files

      * "load()"

      * "loads()"

      * "dump()"

      * "dumps()"

      * "UID"

      * "FMT_XML"

      * "FMT_BINARY"

      * Examples

  * Cryptographic Services

    * "hashlib" --- Secure hashes and message digests

      * Hash algorithms

      * Usage

      * Constructors

        * "new()"

        * "md5()"

        * "sha1()"

        * "sha224()"

        * "sha256()"

        * "sha384()"

        * "sha512()"

        * "sha3_224()"

        * "sha3_256()"

        * "sha3_384()"

        * "sha3_512()"

      * Attributes

        * "algorithms_guaranteed"

        * "algorithms_available"

      * Hash Objects

        * "hash.digest_size"

        * "hash.block_size"

        * "hash.name"

        * "hash.update()"

        * "hash.digest()"

        * "hash.hexdigest()"

        * "hash.copy()"

      * SHAKE variable length digests

        * "shake_128()"

        * "shake_256()"

        * "shake.digest()"

        * "shake.hexdigest()"

      * File hashing

        * "file_digest()"

      * Key derivation

        * "pbkdf2_hmac()"

        * "scrypt()"

      * BLAKE2

        * Creating hash objects

          * "blake2b()"

          * "blake2s()"

        * Constants

          * "blake2b.SALT_SIZE"

          * "blake2s.SALT_SIZE"

          * "blake2b.PERSON_SIZE"

          * "blake2s.PERSON_SIZE"

          * "blake2b.MAX_KEY_SIZE"

          * "blake2s.MAX_KEY_SIZE"

          * "blake2b.MAX_DIGEST_SIZE"

          * "blake2s.MAX_DIGEST_SIZE"

        * Examples

          * Simple hashing

          * Using different digest sizes

          * Keyed hashing

          * Randomized hashing

          * Personalization

          * Tree mode

        * Credits

    * "hmac" --- Keyed-Hashing for Message Authentication

      * "new()"

      * "digest()"

      * "HMAC.update()"

      * "HMAC.digest()"

      * "HMAC.hexdigest()"

      * "HMAC.copy()"

      * "HMAC.digest_size"

      * "HMAC.block_size"

      * "HMAC.name"

      * "compare_digest()"

    * "secrets" --- Generate secure random numbers for managing
      secrets

      * Random numbers

        * "SystemRandom"

        * "choice()"

        * "randbelow()"

        * "randbits()"

      * Generating tokens

        * "token_bytes()"

        * "token_hex()"

        * "token_urlsafe()"

        * How many bytes should tokens use?

      * Other functions

        * "compare_digest()"

      * Recipes and best practices

  * Generic Operating System Services

    * "os" --- Miscellaneous operating system interfaces

      * "error"

      * "name"

      * File Names, Command Line Arguments, and Environment Variables

      * Python UTF-8 Mode

      * Process Parameters

        * "ctermid()"

        * "environ"

        * "environb"

        * "fsencode()"

        * "fsdecode()"

        * "fspath()"

        * "PathLike"

          * "PathLike.__fspath__()"

        * "getenv()"

        * "getenvb()"

        * "get_exec_path()"

        * "getegid()"

        * "geteuid()"

        * "getgid()"

        * "getgrouplist()"

        * "getgroups()"

        * "getlogin()"

        * "getpgid()"

        * "getpgrp()"

        * "getpid()"

        * "getppid()"

        * "getpriority()"

        * "PRIO_PROCESS"

        * "PRIO_PGRP"

        * "PRIO_USER"

        * "PRIO_DARWIN_THREAD"

        * "PRIO_DARWIN_PROCESS"

        * "PRIO_DARWIN_BG"

        * "PRIO_DARWIN_NONUI"

        * "getresuid()"

        * "getresgid()"

        * "getuid()"

        * "initgroups()"

        * "putenv()"

        * "setegid()"

        * "seteuid()"

        * "setgid()"

        * "setgroups()"

        * "setns()"

        * "setpgrp()"

        * "setpgid()"

        * "setpriority()"

        * "setregid()"

        * "setresgid()"

        * "setresuid()"

        * "setreuid()"

        * "getsid()"

        * "setsid()"

        * "setuid()"

        * "strerror()"

        * "supports_bytes_environ"

        * "umask()"

        * "uname()"

        * "unsetenv()"

        * "unshare()"

        * "CLONE_FILES"

        * "CLONE_FS"

        * "CLONE_NEWCGROUP"

        * "CLONE_NEWIPC"

        * "CLONE_NEWNET"

        * "CLONE_NEWNS"

        * "CLONE_NEWPID"

        * "CLONE_NEWTIME"

        * "CLONE_NEWUSER"

        * "CLONE_NEWUTS"

        * "CLONE_SIGHAND"

        * "CLONE_SYSVSEM"

        * "CLONE_THREAD"

        * "CLONE_VM"

      * File Object Creation

        * "fdopen()"

      * File Descriptor Operations

        * "close()"

        * "closerange()"

        * "copy_file_range()"

        * "device_encoding()"

        * "dup()"

        * "dup2()"

        * "fchmod()"

        * "fchown()"

        * "fdatasync()"

        * "fpathconf()"

        * "fstat()"

        * "fstatvfs()"

        * "fsync()"

        * "ftruncate()"

        * "get_blocking()"

        * "isatty()"

        * "lockf()"

        * "F_LOCK"

        * "F_TLOCK"

        * "F_ULOCK"

        * "F_TEST"

        * "login_tty()"

        * "lseek()"

        * "SEEK_SET"

        * "SEEK_CUR"

        * "SEEK_END"

        * "SEEK_HOLE"

        * "SEEK_DATA"

        * "open()"

        * "O_RDONLY"

        * "O_WRONLY"

        * "O_RDWR"

        * "O_APPEND"

        * "O_CREAT"

        * "O_EXCL"

        * "O_TRUNC"

        * "O_DSYNC"

        * "O_RSYNC"

        * "O_SYNC"

        * "O_NDELAY"

        * "O_NONBLOCK"

        * "O_NOCTTY"

        * "O_CLOEXEC"

        * "O_BINARY"

        * "O_NOINHERIT"

        * "O_SHORT_LIVED"

        * "O_TEMPORARY"

        * "O_RANDOM"

        * "O_SEQUENTIAL"

        * "O_TEXT"

        * "O_EVTONLY"

        * "O_FSYNC"

        * "O_SYMLINK"

        * "O_NOFOLLOW_ANY"

        * "O_ASYNC"

        * "O_DIRECT"

        * "O_DIRECTORY"

        * "O_NOFOLLOW"

        * "O_NOATIME"

        * "O_PATH"

        * "O_TMPFILE"

        * "O_SHLOCK"

        * "O_EXLOCK"

        * "openpty()"

        * "pipe()"

        * "pipe2()"

        * "posix_fallocate()"

        * "posix_fadvise()"

        * "POSIX_FADV_NORMAL"

        * "POSIX_FADV_SEQUENTIAL"

        * "POSIX_FADV_RANDOM"

        * "POSIX_FADV_NOREUSE"

        * "POSIX_FADV_WILLNEED"

        * "POSIX_FADV_DONTNEED"

        * "pread()"

        * "preadv()"

        * "RWF_NOWAIT"

        * "RWF_HIPRI"

        * "pwrite()"

        * "pwritev()"

        * "RWF_DSYNC"

        * "RWF_SYNC"

        * "RWF_APPEND"

        * "read()"

        * "sendfile()"

        * "SF_NODISKIO"

        * "SF_MNOWAIT"

        * "SF_SYNC"

        * "SF_NOCACHE"

        * "set_blocking()"

        * "splice()"

        * "SPLICE_F_MOVE"

        * "SPLICE_F_NONBLOCK"

        * "SPLICE_F_MORE"

        * "readv()"

        * "tcgetpgrp()"

        * "tcsetpgrp()"

        * "ttyname()"

        * "write()"

        * "writev()"

        * Querying the size of a terminal

          * "get_terminal_size()"

          * "terminal_size"

            * "terminal_size.columns"

            * "terminal_size.lines"

        * Inheritance of File Descriptors

          * "get_inheritable()"

          * "set_inheritable()"

          * "get_handle_inheritable()"

          * "set_handle_inheritable()"

      * Files and Directories

        * "access()"

        * "F_OK"

        * "R_OK"

        * "W_OK"

        * "X_OK"

        * "chdir()"

        * "chflags()"

        * "chmod()"

        * "chown()"

        * "chroot()"

        * "fchdir()"

        * "getcwd()"

        * "getcwdb()"

        * "lchflags()"

        * "lchmod()"

        * "lchown()"

        * "link()"

        * "listdir()"

        * "listdrives()"

        * "listmounts()"

        * "listvolumes()"

        * "lstat()"

        * "mkdir()"

        * "makedirs()"

        * "mkfifo()"

        * "mknod()"

        * "major()"

        * "minor()"

        * "makedev()"

        * "pathconf()"

        * "pathconf_names"

        * "readlink()"

        * "remove()"

        * "removedirs()"

        * "rename()"

        * "renames()"

        * "replace()"

        * "rmdir()"

        * "scandir()"

          * "scandir.close()"

        * "DirEntry"

          * "DirEntry.name"

          * "DirEntry.path"

          * "DirEntry.inode()"

          * "DirEntry.is_dir()"

          * "DirEntry.is_file()"

          * "DirEntry.is_symlink()"

          * "DirEntry.is_junction()"

          * "DirEntry.stat()"

        * "stat()"

        * "stat_result"

          * "stat_result.st_mode"

          * "stat_result.st_ino"

          * "stat_result.st_dev"

          * "stat_result.st_nlink"

          * "stat_result.st_uid"

          * "stat_result.st_gid"

          * "stat_result.st_size"

          * "stat_result.st_atime"

          * "stat_result.st_mtime"

          * "stat_result.st_ctime"

          * "stat_result.st_atime_ns"

          * "stat_result.st_mtime_ns"

          * "stat_result.st_ctime_ns"

          * "stat_result.st_birthtime"

          * "stat_result.st_birthtime_ns"

          * "stat_result.st_blocks"

          * "stat_result.st_blksize"

          * "stat_result.st_rdev"

          * "stat_result.st_flags"

          * "stat_result.st_gen"

          * "stat_result.st_fstype"

          * "stat_result.st_rsize"

          * "stat_result.st_creator"

          * "stat_result.st_type"

          * "stat_result.st_file_attributes"

          * "stat_result.st_reparse_tag"

        * "statvfs()"

        * "supports_dir_fd"

        * "supports_effective_ids"

        * "supports_fd"

        * "supports_follow_symlinks"

        * "symlink()"

        * "sync()"

        * "truncate()"

        * "unlink()"

        * "utime()"

        * "walk()"

        * "fwalk()"

        * "memfd_create()"

        * "MFD_CLOEXEC"

        * "MFD_ALLOW_SEALING"

        * "MFD_HUGETLB"

        * "MFD_HUGE_SHIFT"

        * "MFD_HUGE_MASK"

        * "MFD_HUGE_64KB"

        * "MFD_HUGE_512KB"

        * "MFD_HUGE_1MB"

        * "MFD_HUGE_2MB"

        * "MFD_HUGE_8MB"

        * "MFD_HUGE_16MB"

        * "MFD_HUGE_32MB"

        * "MFD_HUGE_256MB"

        * "MFD_HUGE_512MB"

        * "MFD_HUGE_1GB"

        * "MFD_HUGE_2GB"

        * "MFD_HUGE_16GB"

        * "eventfd()"

        * "eventfd_read()"

        * "eventfd_write()"

        * "EFD_CLOEXEC"

        * "EFD_NONBLOCK"

        * "EFD_SEMAPHORE"

        * Timer File Descriptors

          * "timerfd_create()"

          * "timerfd_settime()"

          * "timerfd_settime_ns()"

          * "timerfd_gettime()"

          * "timerfd_gettime_ns()"

          * "TFD_NONBLOCK"

          * "TFD_CLOEXEC"

          * "TFD_TIMER_ABSTIME"

          * "TFD_TIMER_CANCEL_ON_SET"

        * Linux extended attributes

          * "getxattr()"

          * "listxattr()"

          * "removexattr()"

          * "setxattr()"

          * "XATTR_SIZE_MAX"

          * "XATTR_CREATE"

          * "XATTR_REPLACE"

      * Process Management

        * "abort()"

        * "add_dll_directory()"

        * "execl()"

        * "execle()"

        * "execlp()"

        * "execlpe()"

        * "execv()"

        * "execve()"

        * "execvp()"

        * "execvpe()"

        * "_exit()"

        * "EX_OK"

        * "EX_USAGE"

        * "EX_DATAERR"

        * "EX_NOINPUT"

        * "EX_NOUSER"

        * "EX_NOHOST"

        * "EX_UNAVAILABLE"

        * "EX_SOFTWARE"

        * "EX_OSERR"

        * "EX_OSFILE"

        * "EX_CANTCREAT"

        * "EX_IOERR"

        * "EX_TEMPFAIL"

        * "EX_PROTOCOL"

        * "EX_NOPERM"

        * "EX_CONFIG"

        * "EX_NOTFOUND"

        * "fork()"

        * "forkpty()"

        * "kill()"

        * "killpg()"

        * "nice()"

        * "pidfd_open()"

        * "PIDFD_NONBLOCK"

        * "plock()"

        * "popen()"

        * "posix_spawn()"

        * "POSIX_SPAWN_OPEN"

        * "POSIX_SPAWN_CLOSE"

        * "POSIX_SPAWN_DUP2"

        * "posix_spawnp()"

        * "register_at_fork()"

        * "spawnl()"

        * "spawnle()"

        * "spawnlp()"

        * "spawnlpe()"

        * "spawnv()"

        * "spawnve()"

        * "spawnvp()"

        * "spawnvpe()"

        * "P_NOWAIT"

        * "P_NOWAITO"

        * "P_WAIT"

        * "P_DETACH"

        * "P_OVERLAY"

        * "startfile()"

        * "system()"

        * "times()"

        * "wait()"

        * "waitid()"

        * "waitpid()"

        * "wait3()"

        * "wait4()"

        * "P_PID"

        * "P_PGID"

        * "P_ALL"

        * "P_PIDFD"

        * "WCONTINUED"

        * "WEXITED"

        * "WSTOPPED"

        * "WUNTRACED"

        * "WNOHANG"

        * "WNOWAIT"

        * "CLD_EXITED"

        * "CLD_KILLED"

        * "CLD_DUMPED"

        * "CLD_TRAPPED"

        * "CLD_STOPPED"

        * "CLD_CONTINUED"

        * "waitstatus_to_exitcode()"

        * "WCOREDUMP()"

        * "WIFCONTINUED()"

        * "WIFSTOPPED()"

        * "WIFSIGNALED()"

        * "WIFEXITED()"

        * "WEXITSTATUS()"

        * "WSTOPSIG()"

        * "WTERMSIG()"

      * Interface to the scheduler

        * "SCHED_OTHER"

        * "SCHED_BATCH"

        * "SCHED_IDLE"

        * "SCHED_SPORADIC"

        * "SCHED_FIFO"

        * "SCHED_RR"

        * "SCHED_RESET_ON_FORK"

        * "sched_param"

          * "sched_param.sched_priority"

        * "sched_get_priority_min()"

        * "sched_get_priority_max()"

        * "sched_setscheduler()"

        * "sched_getscheduler()"

        * "sched_setparam()"

        * "sched_getparam()"

        * "sched_rr_get_interval()"

        * "sched_yield()"

        * "sched_setaffinity()"

        * "sched_getaffinity()"

      * Miscellaneous System Information

        * "confstr()"

        * "confstr_names"

        * "cpu_count()"

        * "getloadavg()"

        * "process_cpu_count()"

        * "sysconf()"

        * "sysconf_names"

        * "curdir"

        * "pardir"

        * "sep"

        * "altsep"

        * "extsep"

        * "pathsep"

        * "defpath"

        * "linesep"

        * "devnull"

        * "RTLD_LAZY"

        * "RTLD_NOW"

        * "RTLD_GLOBAL"

        * "RTLD_LOCAL"

        * "RTLD_NODELETE"

        * "RTLD_NOLOAD"

        * "RTLD_DEEPBIND"

      * Random numbers

        * "getrandom()"

        * "urandom()"

        * "GRND_NONBLOCK"

        * "GRND_RANDOM"

    * "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

        * "DEFAULT_BUFFER_SIZE"

        * "open()"

        * "open_code()"

        * "text_encoding()"

        * "BlockingIOError"

        * "UnsupportedOperation"

      * Class hierarchy

        * I/O Base Classes

          * "IOBase"

            * "IOBase.close()"

            * "IOBase.closed"

            * "IOBase.fileno()"

            * "IOBase.flush()"

            * "IOBase.isatty()"

            * "IOBase.readable()"

            * "IOBase.readline()"

            * "IOBase.readlines()"

            * "IOBase.seek()"

            * "IOBase.seekable()"

            * "IOBase.tell()"

            * "IOBase.truncate()"

            * "IOBase.writable()"

            * "IOBase.writelines()"

            * "IOBase.__del__()"

          * "RawIOBase"

            * "RawIOBase.read()"

            * "RawIOBase.readall()"

            * "RawIOBase.readinto()"

            * "RawIOBase.write()"

          * "BufferedIOBase"

            * "BufferedIOBase.raw"

            * "BufferedIOBase.detach()"

            * "BufferedIOBase.read()"

            * "BufferedIOBase.read1()"

            * "BufferedIOBase.readinto()"

            * "BufferedIOBase.readinto1()"

            * "BufferedIOBase.write()"

        * Raw File I/O

          * "FileIO"

            * "FileIO.mode"

            * "FileIO.name"

        * Buffered Streams

          * "BytesIO"

            * "BytesIO.getbuffer()"

            * "BytesIO.getvalue()"

            * "BytesIO.read1()"

            * "BytesIO.readinto1()"

          * "BufferedReader"

            * "BufferedReader.peek()"

            * "BufferedReader.read()"

            * "BufferedReader.read1()"

          * "BufferedWriter"

            * "BufferedWriter.flush()"

            * "BufferedWriter.write()"

          * "BufferedRandom"

          * "BufferedRWPair"

        * Text I/O

          * "TextIOBase"

            * "TextIOBase.encoding"

            * "TextIOBase.errors"

            * "TextIOBase.newlines"

            * "TextIOBase.buffer"

            * "TextIOBase.detach()"

            * "TextIOBase.read()"

            * "TextIOBase.readline()"

            * "TextIOBase.seek()"

            * "TextIOBase.tell()"

            * "TextIOBase.write()"

          * "TextIOWrapper"

            * "TextIOWrapper.line_buffering"

            * "TextIOWrapper.write_through"

            * "TextIOWrapper.reconfigure()"

            * "TextIOWrapper.seek()"

            * "TextIOWrapper.tell()"

          * "StringIO"

            * "StringIO.getvalue()"

          * "IncrementalNewlineDecoder"

      * Performance

        * Binary I/O

        * Text I/O

        * Multi-threading

        * Reentrancy

    * "time" --- Time access and conversions

      * Functions

        * "asctime()"

        * "pthread_getcpuclockid()"

        * "clock_getres()"

        * "clock_gettime()"

        * "clock_gettime_ns()"

        * "clock_settime()"

        * "clock_settime_ns()"

        * "ctime()"

        * "get_clock_info()"

        * "gmtime()"

        * "localtime()"

        * "mktime()"

        * "monotonic()"

        * "monotonic_ns()"

        * "perf_counter()"

        * "perf_counter_ns()"

        * "process_time()"

        * "process_time_ns()"

        * "sleep()"

        * "strftime()"

        * "strptime()"

        * "struct_time"

        * "time()"

        * "time_ns()"

        * "thread_time()"

        * "thread_time_ns()"

        * "tzset()"

      * Clock ID Constants

        * "CLOCK_BOOTTIME"

        * "CLOCK_HIGHRES"

        * "CLOCK_MONOTONIC"

        * "CLOCK_MONOTONIC_RAW"

        * "CLOCK_PROCESS_CPUTIME_ID"

        * "CLOCK_PROF"

        * "CLOCK_TAI"

        * "CLOCK_THREAD_CPUTIME_ID"

        * "CLOCK_UPTIME"

        * "CLOCK_UPTIME_RAW"

        * "CLOCK_REALTIME"

      * Timezone Constants

        * "altzone"

        * "daylight"

        * "timezone"

        * "tzname"

    * "argparse" --- Parser for command-line options, arguments and
      sub-commands

      * Core Functionality

      * Quick Links for add_argument()

      * Example

        * Creating a parser

        * Adding arguments

        * Parsing arguments

      * ArgumentParser objects

        * "ArgumentParser"

        * prog

        * usage

        * description

        * epilog

        * parents

        * formatter_class

          * "RawDescriptionHelpFormatter"

          * "RawTextHelpFormatter"

          * "ArgumentDefaultsHelpFormatter"

          * "MetavarTypeHelpFormatter"

        * prefix_chars

        * fromfile_prefix_chars

        * argument_default

        * allow_abbrev

        * conflict_handler

        * add_help

        * exit_on_error

      * The add_argument() method

        * "ArgumentParser.add_argument()"

        * name or flags

        * action

        * nargs

        * const

        * default

        * type

        * choices

        * required

        * help

        * metavar

        * dest

        * Action classes

          * "Action"

      * The parse_args() method

        * "ArgumentParser.parse_args()"

        * Option value syntax

        * Invalid arguments

        * Arguments containing "-"

        * Argument abbreviations (prefix matching)

        * Beyond "sys.argv"

        * The Namespace object

          * "Namespace"

      * Other utilities

        * Sub-commands

          * "ArgumentParser.add_subparsers()"

        * FileType objects

          * "FileType"

        * Argument groups

          * "ArgumentParser.add_argument_group()"

        * Mutual exclusion

          * "ArgumentParser.add_mutually_exclusive_group()"

        * Parser defaults

          * "ArgumentParser.set_defaults()"

          * "ArgumentParser.get_default()"

        * Printing help

          * "ArgumentParser.print_usage()"

          * "ArgumentParser.print_help()"

          * "ArgumentParser.format_usage()"

          * "ArgumentParser.format_help()"

        * Partial parsing

          * "ArgumentParser.parse_known_args()"

        * Customizing file parsing

          * "ArgumentParser.convert_arg_line_to_args()"

        * Exiting methods

          * "ArgumentParser.exit()"

          * "ArgumentParser.error()"

        * Intermixed parsing

          * "ArgumentParser.parse_intermixed_args()"

          * "ArgumentParser.parse_known_intermixed_args()"

      * Upgrading optparse code

      * Exceptions

        * "ArgumentError"

        * "ArgumentTypeError"

    * "getopt" --- C-style parser for command line options

      * "getopt()"

      * "gnu_getopt()"

      * "GetoptError"

      * "error"

    * "logging" --- Logging facility for Python

      * Logger Objects

        * "Logger"

          * "Logger.propagate"

          * "Logger.setLevel()"

          * "Logger.isEnabledFor()"

          * "Logger.getEffectiveLevel()"

          * "Logger.getChild()"

          * "Logger.getChildren()"

          * "Logger.debug()"

          * "Logger.info()"

          * "Logger.warning()"

          * "Logger.error()"

          * "Logger.critical()"

          * "Logger.log()"

          * "Logger.exception()"

          * "Logger.addFilter()"

          * "Logger.removeFilter()"

          * "Logger.filter()"

          * "Logger.addHandler()"

          * "Logger.removeHandler()"

          * "Logger.findCaller()"

          * "Logger.handle()"

          * "Logger.makeRecord()"

          * "Logger.hasHandlers()"

      * Logging Levels

        * "NOTSET"

        * "DEBUG"

        * "INFO"

        * "WARNING"

        * "ERROR"

        * "CRITICAL"

      * Handler Objects

        * "Handler"

          * "Handler.__init__()"

          * "Handler.createLock()"

          * "Handler.acquire()"

          * "Handler.release()"

          * "Handler.setLevel()"

          * "Handler.setFormatter()"

          * "Handler.addFilter()"

          * "Handler.removeFilter()"

          * "Handler.filter()"

          * "Handler.flush()"

          * "Handler.close()"

          * "Handler.handle()"

          * "Handler.handleError()"

          * "Handler.format()"

          * "Handler.emit()"

      * Formatter Objects

        * "Formatter"

          * "Formatter.format()"

          * "Formatter.formatTime()"

          * "Formatter.formatException()"

          * "Formatter.formatStack()"

        * "BufferingFormatter"

          * "BufferingFormatter.formatHeader()"

          * "BufferingFormatter.formatFooter()"

          * "BufferingFormatter.format()"

      * Filter Objects

        * "Filter"

          * "Filter.filter()"

      * LogRecord Objects

        * "LogRecord"

          * "LogRecord.getMessage()"

      * LogRecord attributes

      * LoggerAdapter Objects

        * "LoggerAdapter"

          * "LoggerAdapter.process()"

          * "LoggerAdapter.manager"

          * "LoggerAdapter._log"

      * Thread Safety

      * Module-Level Functions

        * "getLogger()"

        * "getLoggerClass()"

        * "getLogRecordFactory()"

        * "debug()"

        * "info()"

        * "warning()"

        * "error()"

        * "critical()"

        * "exception()"

        * "log()"

        * "disable()"

        * "addLevelName()"

        * "getLevelNamesMapping()"

        * "getLevelName()"

        * "getHandlerByName()"

        * "getHandlerNames()"

        * "makeLogRecord()"

        * "basicConfig()"

        * "shutdown()"

        * "setLoggerClass()"

        * "setLogRecordFactory()"

      * Module-Level Attributes

        * "lastResort"

      * Integration with the warnings module

        * "captureWarnings()"

    * "logging.config" --- Logging configuration

      * Configuration functions

        * "dictConfig()"

        * "fileConfig()"

        * "listen()"

        * "stopListening()"

      * Security considerations

      * Configuration dictionary schema

        * Dictionary Schema Details

        * Incremental Configuration

        * Object connections

        * User-defined objects

        * Handler configuration order

        * Access to external objects

        * Access to internal objects

        * Import resolution and custom importers

        * Configuring QueueHandler and QueueListener

      * Configuration file format

    * "logging.handlers" --- Logging handlers

      * StreamHandler

        * "StreamHandler"

          * "StreamHandler.emit()"

          * "StreamHandler.flush()"

          * "StreamHandler.setStream()"

          * "StreamHandler.terminator"

      * FileHandler

        * "FileHandler"

          * "FileHandler.close()"

          * "FileHandler.emit()"

      * NullHandler

        * "NullHandler"

          * "NullHandler.emit()"

          * "NullHandler.handle()"

          * "NullHandler.createLock()"

      * WatchedFileHandler

        * "WatchedFileHandler"

          * "WatchedFileHandler.reopenIfNeeded()"

          * "WatchedFileHandler.emit()"

      * BaseRotatingHandler

        * "BaseRotatingHandler"

          * "BaseRotatingHandler.namer"

          * "BaseRotatingHandler.rotator"

          * "BaseRotatingHandler.rotation_filename()"

          * "BaseRotatingHandler.rotate()"

      * RotatingFileHandler

        * "RotatingFileHandler"

          * "RotatingFileHandler.doRollover()"

          * "RotatingFileHandler.emit()"

      * TimedRotatingFileHandler

        * "TimedRotatingFileHandler"

          * "TimedRotatingFileHandler.doRollover()"

          * "TimedRotatingFileHandler.emit()"

          * "TimedRotatingFileHandler.getFilesToDelete()"

      * SocketHandler

        * "SocketHandler"

          * "SocketHandler.close()"

          * "SocketHandler.emit()"

          * "SocketHandler.handleError()"

          * "SocketHandler.makeSocket()"

          * "SocketHandler.makePickle()"

          * "SocketHandler.send()"

          * "SocketHandler.createSocket()"

      * DatagramHandler

        * "DatagramHandler"

          * "DatagramHandler.emit()"

          * "DatagramHandler.makeSocket()"

          * "DatagramHandler.send()"

      * SysLogHandler

        * "SysLogHandler"

          * "SysLogHandler.close()"

          * "SysLogHandler.createSocket()"

          * "SysLogHandler.emit()"

          * "SysLogHandler.encodePriority()"

          * "SysLogHandler.mapPriority()"

      * NTEventLogHandler

        * "NTEventLogHandler"

          * "NTEventLogHandler.close()"

          * "NTEventLogHandler.emit()"

          * "NTEventLogHandler.getEventCategory()"

          * "NTEventLogHandler.getEventType()"

          * "NTEventLogHandler.getMessageID()"

      * SMTPHandler

        * "SMTPHandler"

          * "SMTPHandler.emit()"

          * "SMTPHandler.getSubject()"

      * MemoryHandler

        * "BufferingHandler"

          * "BufferingHandler.emit()"

          * "BufferingHandler.flush()"

          * "BufferingHandler.shouldFlush()"

        * "MemoryHandler"

          * "MemoryHandler.close()"

          * "MemoryHandler.flush()"

          * "MemoryHandler.setTarget()"

          * "MemoryHandler.shouldFlush()"

      * HTTPHandler

        * "HTTPHandler"

          * "HTTPHandler.mapLogRecord()"

          * "HTTPHandler.emit()"

      * QueueHandler

        * "QueueHandler"

          * "QueueHandler.emit()"

          * "QueueHandler.prepare()"

          * "QueueHandler.enqueue()"

          * "QueueHandler.listener"

      * QueueListener

        * "QueueListener"

          * "QueueListener.dequeue()"

          * "QueueListener.prepare()"

          * "QueueListener.handle()"

          * "QueueListener.start()"

          * "QueueListener.stop()"

          * "QueueListener.enqueue_sentinel()"

    * "getpass" --- Portable password input

      * "getpass()"

      * "GetPassWarning"

      * "getuser()"

    * "curses" --- Terminal handling for character-cell displays

      * Functions

        * "error"

        * "baudrate()"

        * "beep()"

        * "can_change_color()"

        * "cbreak()"

        * "color_content()"

        * "color_pair()"

        * "curs_set()"

        * "def_prog_mode()"

        * "def_shell_mode()"

        * "delay_output()"

        * "doupdate()"

        * "echo()"

        * "endwin()"

        * "erasechar()"

        * "filter()"

        * "flash()"

        * "flushinp()"

        * "getmouse()"

        * "getsyx()"

        * "getwin()"

        * "has_colors()"

        * "has_extended_color_support()"

        * "has_ic()"

        * "has_il()"

        * "has_key()"

        * "halfdelay()"

        * "init_color()"

        * "init_pair()"

        * "initscr()"

        * "is_term_resized()"

        * "isendwin()"

        * "keyname()"

        * "killchar()"

        * "longname()"

        * "meta()"

        * "mouseinterval()"

        * "mousemask()"

        * "napms()"

        * "newpad()"

        * "newwin()"

        * "nl()"

        * "nocbreak()"

        * "noecho()"

        * "nonl()"

        * "noqiflush()"

        * "noraw()"

        * "pair_content()"

        * "pair_number()"

        * "putp()"

        * "qiflush()"

        * "raw()"

        * "reset_prog_mode()"

        * "reset_shell_mode()"

        * "resetty()"

        * "resize_term()"

        * "resizeterm()"

        * "savetty()"

        * "get_escdelay()"

        * "set_escdelay()"

        * "get_tabsize()"

        * "set_tabsize()"

        * "setsyx()"

        * "setupterm()"

        * "start_color()"

        * "termattrs()"

        * "termname()"

        * "tigetflag()"

        * "tigetnum()"

        * "tigetstr()"

        * "tparm()"

        * "typeahead()"

        * "unctrl()"

        * "ungetch()"

        * "update_lines_cols()"

        * "unget_wch()"

        * "ungetmouse()"

        * "use_env()"

        * "use_default_colors()"

        * "wrapper()"

      * Window Objects

        * "window.addch()"

        * "window.addnstr()"

        * "window.addstr()"

        * "window.attroff()"

        * "window.attron()"

        * "window.attrset()"

        * "window.bkgd()"

        * "window.bkgdset()"

        * "window.border()"

        * "window.box()"

        * "window.chgat()"

        * "window.clear()"

        * "window.clearok()"

        * "window.clrtobot()"

        * "window.clrtoeol()"

        * "window.cursyncup()"

        * "window.delch()"

        * "window.deleteln()"

        * "window.derwin()"

        * "window.echochar()"

        * "window.enclose()"

        * "window.encoding"

        * "window.erase()"

        * "window.getbegyx()"

        * "window.getbkgd()"

        * "window.getch()"

        * "window.get_wch()"

        * "window.getkey()"

        * "window.getmaxyx()"

        * "window.getparyx()"

        * "window.getstr()"

        * "window.getyx()"

        * "window.hline()"

        * "window.idcok()"

        * "window.idlok()"

        * "window.immedok()"

        * "window.inch()"

        * "window.insch()"

        * "window.insdelln()"

        * "window.insertln()"

        * "window.insnstr()"

        * "window.insstr()"

        * "window.instr()"

        * "window.is_linetouched()"

        * "window.is_wintouched()"

        * "window.keypad()"

        * "window.leaveok()"

        * "window.move()"

        * "window.mvderwin()"

        * "window.mvwin()"

        * "window.nodelay()"

        * "window.notimeout()"

        * "window.noutrefresh()"

        * "window.overlay()"

        * "window.overwrite()"

        * "window.putwin()"

        * "window.redrawln()"

        * "window.redrawwin()"

        * "window.refresh()"

        * "window.resize()"

        * "window.scroll()"

        * "window.scrollok()"

        * "window.setscrreg()"

        * "window.standend()"

        * "window.standout()"

        * "window.subpad()"

        * "window.subwin()"

        * "window.syncdown()"

        * "window.syncok()"

        * "window.syncup()"

        * "window.timeout()"

        * "window.touchline()"

        * "window.touchwin()"

        * "window.untouchwin()"

        * "window.vline()"

      * Constants

        * "ERR"

        * "OK"

        * "version"

        * "__version__"

        * "ncurses_version"

        * "COLORS"

        * "COLOR_PAIRS"

        * "COLS"

        * "LINES"

        * "A_ALTCHARSET"

        * "A_BLINK"

        * "A_BOLD"

        * "A_DIM"

        * "A_INVIS"

        * "A_ITALIC"

        * "A_NORMAL"

        * "A_PROTECT"

        * "A_REVERSE"

        * "A_STANDOUT"

        * "A_UNDERLINE"

        * "A_HORIZONTAL"

        * "A_LEFT"

        * "A_LOW"

        * "A_RIGHT"

        * "A_TOP"

        * "A_VERTICAL"

        * "A_ATTRIBUTES"

        * "A_CHARTEXT"

        * "A_COLOR"

        * "KEY_MIN"

        * "KEY_BREAK"

        * "KEY_DOWN"

        * "KEY_UP"

        * "KEY_LEFT"

        * "KEY_RIGHT"

        * "KEY_HOME"

        * "KEY_BACKSPACE"

        * "KEY_F0"

        * "KEY_Fn"

        * "KEY_DL"

        * "KEY_IL"

        * "KEY_DC"

        * "KEY_IC"

        * "KEY_EIC"

        * "KEY_CLEAR"

        * "KEY_EOS"

        * "KEY_EOL"

        * "KEY_SF"

        * "KEY_SR"

        * "KEY_NPAGE"

        * "KEY_PPAGE"

        * "KEY_STAB"

        * "KEY_CTAB"

        * "KEY_CATAB"

        * "KEY_ENTER"

        * "KEY_SRESET"

        * "KEY_RESET"

        * "KEY_PRINT"

        * "KEY_LL"

        * "KEY_A1"

        * "KEY_A3"

        * "KEY_B2"

        * "KEY_C1"

        * "KEY_C3"

        * "KEY_BTAB"

        * "KEY_BEG"

        * "KEY_CANCEL"

        * "KEY_CLOSE"

        * "KEY_COMMAND"

        * "KEY_COPY"

        * "KEY_CREATE"

        * "KEY_END"

        * "KEY_EXIT"

        * "KEY_FIND"

        * "KEY_HELP"

        * "KEY_MARK"

        * "KEY_MESSAGE"

        * "KEY_MOVE"

        * "KEY_NEXT"

        * "KEY_OPEN"

        * "KEY_OPTIONS"

        * "KEY_PREVIOUS"

        * "KEY_REDO"

        * "KEY_REFERENCE"

        * "KEY_REFRESH"

        * "KEY_REPLACE"

        * "KEY_RESTART"

        * "KEY_RESUME"

        * "KEY_SAVE"

        * "KEY_SBEG"

        * "KEY_SCANCEL"

        * "KEY_SCOMMAND"

        * "KEY_SCOPY"

        * "KEY_SCREATE"

        * "KEY_SDC"

        * "KEY_SDL"

        * "KEY_SELECT"

        * "KEY_SEND"

        * "KEY_SEOL"

        * "KEY_SEXIT"

        * "KEY_SFIND"

        * "KEY_SHELP"

        * "KEY_SHOME"

        * "KEY_SIC"

        * "KEY_SLEFT"

        * "KEY_SMESSAGE"

        * "KEY_SMOVE"

        * "KEY_SNEXT"

        * "KEY_SOPTIONS"

        * "KEY_SPREVIOUS"

        * "KEY_SPRINT"

        * "KEY_SREDO"

        * "KEY_SREPLACE"

        * "KEY_SRIGHT"

        * "KEY_SRSUME"

        * "KEY_SSAVE"

        * "KEY_SSUSPEND"

        * "KEY_SUNDO"

        * "KEY_SUSPEND"

        * "KEY_UNDO"

        * "KEY_MOUSE"

        * "KEY_RESIZE"

        * "KEY_MAX"

        * "ACS_BBSS"

        * "ACS_BLOCK"

        * "ACS_BOARD"

        * "ACS_BSBS"

        * "ACS_BSSB"

        * "ACS_BSSS"

        * "ACS_BTEE"

        * "ACS_BULLET"

        * "ACS_CKBOARD"

        * "ACS_DARROW"

        * "ACS_DEGREE"

        * "ACS_DIAMOND"

        * "ACS_GEQUAL"

        * "ACS_HLINE"

        * "ACS_LANTERN"

        * "ACS_LARROW"

        * "ACS_LEQUAL"

        * "ACS_LLCORNER"

        * "ACS_LRCORNER"

        * "ACS_LTEE"

        * "ACS_NEQUAL"

        * "ACS_PI"

        * "ACS_PLMINUS"

        * "ACS_PLUS"

        * "ACS_RARROW"

        * "ACS_RTEE"

        * "ACS_S1"

        * "ACS_S3"

        * "ACS_S7"

        * "ACS_S9"

        * "ACS_SBBS"

        * "ACS_SBSB"

        * "ACS_SBSS"

        * "ACS_SSBB"

        * "ACS_SSBS"

        * "ACS_SSSB"

        * "ACS_SSSS"

        * "ACS_STERLING"

        * "ACS_TTEE"

        * "ACS_UARROW"

        * "ACS_ULCORNER"

        * "ACS_URCORNER"

        * "ACS_VLINE"

        * "BUTTONn_PRESSED"

        * "BUTTONn_RELEASED"

        * "BUTTONn_CLICKED"

        * "BUTTONn_DOUBLE_CLICKED"

        * "BUTTONn_TRIPLE_CLICKED"

        * "BUTTON_SHIFT"

        * "BUTTON_CTRL"

        * "BUTTON_ALT"

        * "COLOR_BLACK"

        * "COLOR_BLUE"

        * "COLOR_CYAN"

        * "COLOR_GREEN"

        * "COLOR_MAGENTA"

        * "COLOR_RED"

        * "COLOR_WHITE"

        * "COLOR_YELLOW"

    * "curses.textpad" --- Text input widget for curses programs

      * "rectangle()"

      * Textbox objects

        * "Textbox"

          * "Textbox.edit()"

          * "Textbox.do_command()"

          * "Textbox.gather()"

          * "Textbox.stripspaces"

    * "curses.ascii" --- Utilities for ASCII characters

      * "NUL"

      * "SOH"

      * "STX"

      * "ETX"

      * "EOT"

      * "ENQ"

      * "ACK"

      * "BEL"

      * "BS"

      * "TAB"

      * "HT"

      * "LF"

      * "NL"

      * "VT"

      * "FF"

      * "CR"

      * "SO"

      * "SI"

      * "DLE"

      * "DC1"

      * "DC2"

      * "DC3"

      * "DC4"

      * "NAK"

      * "SYN"

      * "ETB"

      * "CAN"

      * "EM"

      * "SUB"

      * "ESC"

      * "FS"

      * "GS"

      * "RS"

      * "US"

      * "SP"

      * "DEL"

      * "isalnum()"

      * "isalpha()"

      * "isascii()"

      * "isblank()"

      * "iscntrl()"

      * "isdigit()"

      * "isgraph()"

      * "islower()"

      * "isprint()"

      * "ispunct()"

      * "isspace()"

      * "isupper()"

      * "isxdigit()"

      * "isctrl()"

      * "ismeta()"

      * "ascii()"

      * "ctrl()"

      * "alt()"

      * "unctrl()"

      * "controlnames"

    * "curses.panel" --- A panel stack extension for curses

      * Functions

        * "bottom_panel()"

        * "new_panel()"

        * "top_panel()"

        * "update_panels()"

      * Panel Objects

        * "Panel.above()"

        * "Panel.below()"

        * "Panel.bottom()"

        * "Panel.hidden()"

        * "Panel.hide()"

        * "Panel.move()"

        * "Panel.replace()"

        * "Panel.set_userptr()"

        * "Panel.show()"

        * "Panel.top()"

        * "Panel.userptr()"

        * "Panel.window()"

    * "platform" ---  Access to underlying platform's identifying data

      * Cross Platform

        * "architecture()"

        * "machine()"

        * "node()"

        * "platform()"

        * "processor()"

        * "python_build()"

        * "python_compiler()"

        * "python_branch()"

        * "python_implementation()"

        * "python_revision()"

        * "python_version()"

        * "python_version_tuple()"

        * "release()"

        * "system()"

        * "system_alias()"

        * "version()"

        * "uname()"

      * Java Platform

        * "java_ver()"

      * Windows Platform

        * "win32_ver()"

        * "win32_edition()"

        * "win32_is_iot()"

      * macOS Platform

        * "mac_ver()"

      * Unix Platforms

        * "libc_ver()"

      * Linux Platforms

        * "freedesktop_os_release()"

    * "errno" --- Standard errno system symbols

      * "errorcode"

      * "EPERM"

      * "ENOENT"

      * "ESRCH"

      * "EINTR"

      * "EIO"

      * "ENXIO"

      * "E2BIG"

      * "ENOEXEC"

      * "EBADF"

      * "ECHILD"

      * "EAGAIN"

      * "ENOMEM"

      * "EACCES"

      * "EFAULT"

      * "ENOTBLK"

      * "EBUSY"

      * "EEXIST"

      * "EXDEV"

      * "ENODEV"

      * "ENOTDIR"

      * "EISDIR"

      * "EINVAL"

      * "ENFILE"

      * "EMFILE"

      * "ENOTTY"

      * "ETXTBSY"

      * "EFBIG"

      * "ENOSPC"

      * "ESPIPE"

      * "EROFS"

      * "EMLINK"

      * "EPIPE"

      * "EDOM"

      * "ERANGE"

      * "EDEADLK"

      * "ENAMETOOLONG"

      * "ENOLCK"

      * "ENOSYS"

      * "ENOTEMPTY"

      * "ELOOP"

      * "EWOULDBLOCK"

      * "ENOMSG"

      * "EIDRM"

      * "ECHRNG"

      * "EL2NSYNC"

      * "EL3HLT"

      * "EL3RST"

      * "ELNRNG"

      * "EUNATCH"

      * "ENOCSI"

      * "EL2HLT"

      * "EBADE"

      * "EBADR"

      * "EXFULL"

      * "ENOANO"

      * "EBADRQC"

      * "EBADSLT"

      * "EDEADLOCK"

      * "EBFONT"

      * "ENOSTR"

      * "ENODATA"

      * "ETIME"

      * "ENOSR"

      * "ENONET"

      * "ENOPKG"

      * "EREMOTE"

      * "ENOLINK"

      * "EADV"

      * "ESRMNT"

      * "ECOMM"

      * "EPROTO"

      * "EMULTIHOP"

      * "EDOTDOT"

      * "EBADMSG"

      * "EOVERFLOW"

      * "ENOTUNIQ"

      * "EBADFD"

      * "EREMCHG"

      * "ELIBACC"

      * "ELIBBAD"

      * "ELIBSCN"

      * "ELIBMAX"

      * "ELIBEXEC"

      * "EILSEQ"

      * "ERESTART"

      * "ESTRPIPE"

      * "EUSERS"

      * "ENOTSOCK"

      * "EDESTADDRREQ"

      * "EMSGSIZE"

      * "EPROTOTYPE"

      * "ENOPROTOOPT"

      * "EPROTONOSUPPORT"

      * "ESOCKTNOSUPPORT"

      * "EOPNOTSUPP"

      * "ENOTSUP"

      * "EPFNOSUPPORT"

      * "EAFNOSUPPORT"

      * "EADDRINUSE"

      * "EADDRNOTAVAIL"

      * "ENETDOWN"

      * "ENETUNREACH"

      * "ENETRESET"

      * "ECONNABORTED"

      * "ECONNRESET"

      * "ENOBUFS"

      * "EISCONN"

      * "ENOTCONN"

      * "ESHUTDOWN"

      * "ETOOMANYREFS"

      * "ETIMEDOUT"

      * "ECONNREFUSED"

      * "EHOSTDOWN"

      * "EHOSTUNREACH"

      * "EALREADY"

      * "EINPROGRESS"

      * "ESTALE"

      * "EUCLEAN"

      * "ENOTNAM"

      * "ENAVAIL"

      * "EISNAM"

      * "EREMOTEIO"

      * "EDQUOT"

      * "EQFULL"

      * "ENOTCAPABLE"

      * "ECANCELED"

      * "EOWNERDEAD"

      * "ENOTRECOVERABLE"

    * "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 variadic functions

        * 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

          * "CDLL"

          * "OleDLL"

          * "WinDLL"

          * "PyDLL"

            * "PyDLL._handle"

            * "PyDLL._name"

          * "LibraryLoader"

            * "LibraryLoader.LoadLibrary()"

        * Foreign functions

          * "_FuncPtr"

            * "_FuncPtr.restype"

            * "_FuncPtr.argtypes"

            * "_FuncPtr.errcheck"

          * "ArgumentError"

        * Function prototypes

          * "CFUNCTYPE()"

          * "WINFUNCTYPE()"

          * "PYFUNCTYPE()"

        * Utility functions

          * "addressof()"

          * "alignment()"

          * "byref()"

          * "cast()"

          * "create_string_buffer()"

          * "create_unicode_buffer()"

          * "DllCanUnloadNow()"

          * "DllGetClassObject()"

          * "find_library()"

          * "find_msvcrt()"

          * "FormatError()"

          * "GetLastError()"

          * "get_errno()"

          * "get_last_error()"

          * "memmove()"

          * "memset()"

          * "POINTER()"

          * "pointer()"

          * "resize()"

          * "set_errno()"

          * "set_last_error()"

          * "sizeof()"

          * "string_at()"

          * "WinError()"

          * "wstring_at()"

        * Data types

          * "_CData"

            * "_CData.from_buffer()"

            * "_CData.from_buffer_copy()"

            * "_CData.from_address()"

            * "_CData.from_param()"

            * "_CData.in_dll()"

            * "_CData._b_base_"

            * "_CData._b_needsfree_"

            * "_CData._objects"

        * Fundamental data types

          * "_SimpleCData"

            * "_SimpleCData.value"

          * "c_byte"

          * "c_char"

          * "c_char_p"

          * "c_double"

          * "c_longdouble"

          * "c_float"

          * "c_int"

          * "c_int8"

          * "c_int16"

          * "c_int32"

          * "c_int64"

          * "c_long"

          * "c_longlong"

          * "c_short"

          * "c_size_t"

          * "c_ssize_t"

          * "c_time_t"

          * "c_ubyte"

          * "c_uint"

          * "c_uint8"

          * "c_uint16"

          * "c_uint32"

          * "c_uint64"

          * "c_ulong"

          * "c_ulonglong"

          * "c_ushort"

          * "c_void_p"

          * "c_wchar"

          * "c_wchar_p"

          * "c_bool"

          * "HRESULT"

          * "py_object"

        * Structured data types

          * "Union"

          * "BigEndianUnion"

          * "LittleEndianUnion"

          * "BigEndianStructure"

          * "LittleEndianStructure"

          * "Structure"

            * "Structure._fields_"

            * "Structure._pack_"

            * "Structure._anonymous_"

        * Arrays and pointers

          * "Array"

            * "Array._length_"

            * "Array._type_"

          * "_Pointer"

            * "_Pointer._type_"

            * "_Pointer.contents"

  * Concurrent Execution

    * "threading" --- Thread-based parallelism

      * "active_count()"

      * "current_thread()"

      * "excepthook()"

      * "__excepthook__"

      * "get_ident()"

      * "get_native_id()"

      * "enumerate()"

      * "main_thread()"

      * "settrace()"

      * "settrace_all_threads()"

      * "gettrace()"

      * "setprofile()"

      * "setprofile_all_threads()"

      * "getprofile()"

      * "stack_size()"

      * "TIMEOUT_MAX"

      * Thread-Local Data

        * "local"

      * Thread Objects

        * "Thread"

          * "Thread.start()"

          * "Thread.run()"

          * "Thread.join()"

          * "Thread.name"

          * "Thread.getName()"

          * "Thread.setName()"

          * "Thread.ident"

          * "Thread.native_id"

          * "Thread.is_alive()"

          * "Thread.daemon"

          * "Thread.isDaemon()"

          * "Thread.setDaemon()"

      * Lock Objects

        * "Lock"

          * "Lock.acquire()"

          * "Lock.release()"

          * "Lock.locked()"

      * RLock Objects

        * "RLock"

          * "RLock.acquire()"

          * "RLock.release()"

      * Condition Objects

        * "Condition"

          * "Condition.acquire()"

          * "Condition.release()"

          * "Condition.wait()"

          * "Condition.wait_for()"

          * "Condition.notify()"

          * "Condition.notify_all()"

      * Semaphore Objects

        * "Semaphore"

          * "Semaphore.acquire()"

          * "Semaphore.release()"

        * "BoundedSemaphore"

        * "Semaphore" Example

      * Event Objects

        * "Event"

          * "Event.is_set()"

          * "Event.set()"

          * "Event.clear()"

          * "Event.wait()"

      * Timer Objects

        * "Timer"

          * "Timer.cancel()"

      * Barrier Objects

        * "Barrier"

          * "Barrier.wait()"

          * "Barrier.reset()"

          * "Barrier.abort()"

          * "Barrier.parties"

          * "Barrier.n_waiting"

          * "Barrier.broken"

        * "BrokenBarrierError"

      * 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

          * "Process"

            * "Process.run()"

            * "Process.start()"

            * "Process.join()"

            * "Process.name"

            * "Process.is_alive()"

            * "Process.daemon"

            * "Process.pid"

            * "Process.exitcode"

            * "Process.authkey"

            * "Process.sentinel"

            * "Process.terminate()"

            * "Process.kill()"

            * "Process.close()"

          * "ProcessError"

          * "BufferTooShort"

          * "AuthenticationError"

          * "TimeoutError"

        * Pipes and Queues

          * "Pipe()"

          * "Queue"

            * "Queue.qsize()"

            * "Queue.empty()"

            * "Queue.full()"

            * "Queue.put()"

            * "Queue.put_nowait()"

            * "Queue.get()"

            * "Queue.get_nowait()"

            * "Queue.close()"

            * "Queue.join_thread()"

            * "Queue.cancel_join_thread()"

          * "SimpleQueue"

            * "SimpleQueue.close()"

            * "SimpleQueue.empty()"

            * "SimpleQueue.get()"

            * "SimpleQueue.put()"

          * "JoinableQueue"

            * "JoinableQueue.task_done()"

            * "JoinableQueue.join()"

        * Miscellaneous

          * "active_children()"

          * "cpu_count()"

          * "current_process()"

          * "parent_process()"

          * "freeze_support()"

          * "get_all_start_methods()"

          * "get_context()"

          * "get_start_method()"

          * "set_executable()"

          * "set_forkserver_preload()"

          * "set_start_method()"

        * Connection Objects

          * "Connection"

            * "Connection.send()"

            * "Connection.recv()"

            * "Connection.fileno()"

            * "Connection.close()"

            * "Connection.poll()"

            * "Connection.send_bytes()"

            * "Connection.recv_bytes()"

            * "Connection.recv_bytes_into()"

        * Synchronization primitives

          * "Barrier"

          * "BoundedSemaphore"

          * "Condition"

          * "Event"

          * "Lock"

            * "Lock.acquire()"

            * "Lock.release()"

          * "RLock"

            * "RLock.acquire()"

            * "RLock.release()"

          * "Semaphore"

        * Shared "ctypes" Objects

          * "Value()"

          * "Array()"

          * The "multiprocessing.sharedctypes" module

            * "RawArray()"

            * "RawValue()"

            * "Array()"

            * "Value()"

            * "copy()"

            * "synchronized()"

        * Managers

          * "multiprocessing.Manager()"

          * "BaseManager"

            * "BaseManager.start()"

            * "BaseManager.get_server()"

            * "BaseManager.connect()"

            * "BaseManager.shutdown()"

            * "BaseManager.register()"

            * "BaseManager.address"

          * "SyncManager"

            * "SyncManager.Barrier()"

            * "SyncManager.BoundedSemaphore()"

            * "SyncManager.Condition()"

            * "SyncManager.Event()"

            * "SyncManager.Lock()"

            * "SyncManager.Namespace()"

            * "SyncManager.Queue()"

            * "SyncManager.RLock()"

            * "SyncManager.Semaphore()"

            * "SyncManager.Array()"

            * "SyncManager.Value()"

            * "SyncManager.dict()"

            * "SyncManager.list()"

          * "Namespace"

          * Customized managers

          * Using a remote manager

        * Proxy Objects

          * "BaseProxy"

            * "BaseProxy._callmethod()"

            * "BaseProxy._getvalue()"

            * "BaseProxy.__repr__()"

            * "BaseProxy.__str__()"

          * Cleanup

        * Process Pools

          * "Pool"

            * "Pool.apply()"

            * "Pool.apply_async()"

            * "Pool.map()"

            * "Pool.map_async()"

            * "Pool.imap()"

            * "Pool.imap_unordered()"

            * "Pool.starmap()"

            * "Pool.starmap_async()"

            * "Pool.close()"

            * "Pool.terminate()"

            * "Pool.join()"

          * "AsyncResult"

            * "AsyncResult.get()"

            * "AsyncResult.wait()"

            * "AsyncResult.ready()"

            * "AsyncResult.successful()"

        * Listeners and Clients

          * "deliver_challenge()"

          * "answer_challenge()"

          * "Client()"

          * "Listener"

            * "Listener.accept()"

            * "Listener.close()"

            * "Listener.address"

            * "Listener.last_accepted"

          * "wait()"

          * Address Formats

        * Authentication keys

        * Logging

          * "get_logger()"

          * "log_to_stderr()"

        * The "multiprocessing.dummy" module

          * "ThreadPool"

      * Programming guidelines

        * All start methods

        * The *spawn* and *forkserver* start methods

      * Examples

    * "multiprocessing.shared_memory" --- Shared memory for direct
      access across processes

      * "SharedMemory"

        * "SharedMemory.close()"

        * "SharedMemory.unlink()"

        * "SharedMemory.buf"

        * "SharedMemory.name"

        * "SharedMemory.size"

      * "SharedMemoryManager"

        * "SharedMemoryManager.SharedMemory()"

        * "SharedMemoryManager.ShareableList()"

      * "ShareableList"

        * "ShareableList.count()"

        * "ShareableList.index()"

        * "ShareableList.format"

        * "ShareableList.shm"

    * The "concurrent" package

    * "concurrent.futures" --- Launching parallel tasks

      * Executor Objects

        * "Executor"

          * "Executor.submit()"

          * "Executor.map()"

          * "Executor.shutdown()"

      * ThreadPoolExecutor

        * "ThreadPoolExecutor"

        * ThreadPoolExecutor Example

      * ProcessPoolExecutor

        * "ProcessPoolExecutor"

        * ProcessPoolExecutor Example

      * Future Objects

        * "Future"

          * "Future.cancel()"

          * "Future.cancelled()"

          * "Future.running()"

          * "Future.done()"

          * "Future.result()"

          * "Future.exception()"

          * "Future.add_done_callback()"

          * "Future.set_running_or_notify_cancel()"

          * "Future.set_result()"

          * "Future.set_exception()"

      * Module Functions

        * "wait()"

        * "as_completed()"

      * Exception classes

        * "CancelledError"

        * "TimeoutError"

        * "BrokenExecutor"

        * "InvalidStateError"

        * "BrokenThreadPool"

        * "BrokenProcessPool"

    * "subprocess" --- Subprocess management

      * Using the "subprocess" Module

        * "run()"

        * "CompletedProcess"

          * "CompletedProcess.args"

          * "CompletedProcess.returncode"

          * "CompletedProcess.stdout"

          * "CompletedProcess.stderr"

          * "CompletedProcess.check_returncode()"

        * "DEVNULL"

        * "PIPE"

        * "STDOUT"

        * "SubprocessError"

        * "TimeoutExpired"

          * "TimeoutExpired.cmd"

          * "TimeoutExpired.timeout"

          * "TimeoutExpired.output"

          * "TimeoutExpired.stdout"

          * "TimeoutExpired.stderr"

        * "CalledProcessError"

          * "CalledProcessError.returncode"

          * "CalledProcessError.cmd"

          * "CalledProcessError.output"

          * "CalledProcessError.stdout"

          * "CalledProcessError.stderr"

        * Frequently Used Arguments

        * Popen Constructor

          * "Popen"

        * Exceptions

      * Security Considerations

      * Popen Objects

        * "Popen.poll()"

        * "Popen.wait()"

        * "Popen.communicate()"

        * "Popen.send_signal()"

        * "Popen.terminate()"

        * "Popen.kill()"

        * "Popen.args"

        * "Popen.stdin"

        * "Popen.stdout"

        * "Popen.stderr"

        * "Popen.pid"

        * "Popen.returncode"

      * Windows Popen Helpers

        * "STARTUPINFO"

          * "STARTUPINFO.dwFlags"

          * "STARTUPINFO.hStdInput"

          * "STARTUPINFO.hStdOutput"

          * "STARTUPINFO.hStdError"

          * "STARTUPINFO.wShowWindow"

          * "STARTUPINFO.lpAttributeList"

        * Windows Constants

          * "STD_INPUT_HANDLE"

          * "STD_OUTPUT_HANDLE"

          * "STD_ERROR_HANDLE"

          * "SW_HIDE"

          * "STARTF_USESTDHANDLES"

          * "STARTF_USESHOWWINDOW"

          * "CREATE_NEW_CONSOLE"

          * "CREATE_NEW_PROCESS_GROUP"

          * "ABOVE_NORMAL_PRIORITY_CLASS"

          * "BELOW_NORMAL_PRIORITY_CLASS"

          * "HIGH_PRIORITY_CLASS"

          * "IDLE_PRIORITY_CLASS"

          * "NORMAL_PRIORITY_CLASS"

          * "REALTIME_PRIORITY_CLASS"

          * "CREATE_NO_WINDOW"

          * "DETACHED_PROCESS"

          * "CREATE_DEFAULT_ERROR_MODE"

          * "CREATE_BREAKAWAY_FROM_JOB"

      * Older high-level API

        * "call()"

        * "check_call()"

        * "check_output()"

      * 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

        * "getstatusoutput()"

        * "getoutput()"

      * Notes

        * Converting an argument sequence to a string on Windows

        * Disabling use of "vfork()" or "posix_spawn()"

    * "sched" --- Event scheduler

      * "scheduler"

      * Scheduler Objects

        * "scheduler.enterabs()"

        * "scheduler.enter()"

        * "scheduler.cancel()"

        * "scheduler.empty()"

        * "scheduler.run()"

        * "scheduler.queue"

    * "queue" --- A synchronized queue class

      * "Queue"

      * "LifoQueue"

      * "PriorityQueue"

      * "SimpleQueue"

      * "Empty"

      * "Full"

      * Queue Objects

        * "Queue.qsize()"

        * "Queue.empty()"

        * "Queue.full()"

        * "Queue.put()"

        * "Queue.put_nowait()"

        * "Queue.get()"

        * "Queue.get_nowait()"

        * "Queue.task_done()"

        * "Queue.join()"

      * SimpleQueue Objects

        * "SimpleQueue.qsize()"

        * "SimpleQueue.empty()"

        * "SimpleQueue.put()"

        * "SimpleQueue.put_nowait()"

        * "SimpleQueue.get()"

        * "SimpleQueue.get_nowait()"

    * "contextvars" --- Context Variables

      * Context Variables

        * "ContextVar"

          * "ContextVar.name"

          * "ContextVar.get()"

          * "ContextVar.set()"

          * "ContextVar.reset()"

        * "Token"

          * "Token.var"

          * "Token.old_value"

          * "Token.MISSING"

      * Manual Context Management

        * "copy_context()"

        * "Context"

          * "Context.run()"

          * "Context.copy()"

          * "Context.get()"

          * "Context.keys()"

          * "Context.values()"

          * "Context.items()"

      * asyncio support

    * "_thread" --- Low-level threading API

      * "error"

      * "LockType"

      * "start_new_thread()"

      * "interrupt_main()"

      * "exit()"

      * "allocate_lock()"

      * "get_ident()"

      * "get_native_id()"

      * "stack_size()"

      * "TIMEOUT_MAX"

      * "lock.acquire()"

      * "lock.release()"

      * "lock.locked()"

  * Networking and Interprocess Communication

    * "asyncio" --- Asynchronous I/O

      * Runners

        * Running an asyncio Program

          * "run()"

        * Runner context manager

          * "Runner"

            * "Runner.run()"

            * "Runner.close()"

            * "Runner.get_loop()"

        * Handling Keyboard Interruption

      * Coroutines and Tasks

        * Coroutines

        * Awaitables

        * Creating Tasks

          * "create_task()"

        * Task Cancellation

        * Task Groups

          * "TaskGroup"

            * "TaskGroup.create_task()"

        * Sleeping

          * "sleep()"

        * Running Tasks Concurrently

          * "gather()"

        * Eager Task Factory

          * "eager_task_factory()"

          * "create_eager_task_factory()"

        * Shielding From Cancellation

          * "shield()"

        * Timeouts

          * "timeout()"

          * "Timeout"

            * "Timeout.when()"

            * "Timeout.reschedule()"

            * "Timeout.expired()"

          * "timeout_at()"

          * "wait_for()"

        * Waiting Primitives

          * "wait()"

          * "as_completed()"

        * Running in Threads

          * "to_thread()"

        * Scheduling From Other Threads

          * "run_coroutine_threadsafe()"

        * Introspection

          * "current_task()"

          * "all_tasks()"

          * "iscoroutine()"

        * Task Object

          * "Task"

            * "Task.done()"

            * "Task.result()"

            * "Task.exception()"

            * "Task.add_done_callback()"

            * "Task.remove_done_callback()"

            * "Task.get_stack()"

            * "Task.print_stack()"

            * "Task.get_coro()"

            * "Task.get_context()"

            * "Task.get_name()"

            * "Task.set_name()"

            * "Task.cancel()"

            * "Task.cancelled()"

            * "Task.uncancel()"

            * "Task.cancelling()"

      * Streams

        * "open_connection()"

        * "start_server()"

        * "open_unix_connection()"

        * "start_unix_server()"

        * StreamReader

          * "StreamReader"

            * "StreamReader.read()"

            * "StreamReader.readline()"

            * "StreamReader.readexactly()"

            * "StreamReader.readuntil()"

            * "StreamReader.at_eof()"

        * StreamWriter

          * "StreamWriter"

            * "StreamWriter.write()"

            * "StreamWriter.writelines()"

            * "StreamWriter.close()"

            * "StreamWriter.can_write_eof()"

            * "StreamWriter.write_eof()"

            * "StreamWriter.transport"

            * "StreamWriter.get_extra_info()"

            * "StreamWriter.drain()"

            * "StreamWriter.start_tls()"

            * "StreamWriter.is_closing()"

            * "StreamWriter.wait_closed()"

        * 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

          * "Lock"

            * "Lock.acquire()"

            * "Lock.release()"

            * "Lock.locked()"

        * Event

          * "Event"

            * "Event.wait()"

            * "Event.set()"

            * "Event.clear()"

            * "Event.is_set()"

        * Condition

          * "Condition"

            * "Condition.acquire()"

            * "Condition.notify()"

            * "Condition.locked()"

            * "Condition.notify_all()"

            * "Condition.release()"

            * "Condition.wait()"

            * "Condition.wait_for()"

        * Semaphore

          * "Semaphore"

            * "Semaphore.acquire()"

            * "Semaphore.locked()"

            * "Semaphore.release()"

        * BoundedSemaphore

          * "BoundedSemaphore"

        * Barrier

          * "Barrier"

            * "Barrier.wait()"

            * "Barrier.reset()"

            * "Barrier.abort()"

            * "Barrier.parties"

            * "Barrier.n_waiting"

            * "Barrier.broken"

          * "BrokenBarrierError"

      * Subprocesses

        * Creating Subprocesses

          * "create_subprocess_exec()"

          * "create_subprocess_shell()"

        * Constants

          * "asyncio.subprocess.PIPE"

          * "asyncio.subprocess.STDOUT"

          * "asyncio.subprocess.DEVNULL"

        * Interacting with Subprocesses

          * "asyncio.subprocess.Process"

            * "asyncio.subprocess.Process.wait()"

            * "asyncio.subprocess.Process.communicate()"

            * "asyncio.subprocess.Process.send_signal()"

            * "asyncio.subprocess.Process.terminate()"

            * "asyncio.subprocess.Process.kill()"

            * "asyncio.subprocess.Process.stdin"

            * "asyncio.subprocess.Process.stdout"

            * "asyncio.subprocess.Process.stderr"

            * "asyncio.subprocess.Process.pid"

            * "asyncio.subprocess.Process.returncode"

          * Subprocess and Threads

          * Examples

      * Queues

        * Queue

          * "Queue"

            * "Queue.maxsize"

            * "Queue.empty()"

            * "Queue.full()"

            * "Queue.get()"

            * "Queue.get_nowait()"

            * "Queue.join()"

            * "Queue.put()"

            * "Queue.put_nowait()"

            * "Queue.qsize()"

            * "Queue.task_done()"

        * Priority Queue

          * "PriorityQueue"

        * LIFO Queue

          * "LifoQueue"

        * Exceptions

          * "QueueEmpty"

          * "QueueFull"

        * Examples

      * Exceptions

        * "TimeoutError"

        * "CancelledError"

        * "InvalidStateError"

        * "SendfileNotAvailableError"

        * "IncompleteReadError"

          * "IncompleteReadError.expected"

          * "IncompleteReadError.partial"

        * "LimitOverrunError"

          * "LimitOverrunError.consumed"

      * Event Loop

        * "get_running_loop()"

        * "get_event_loop()"

        * "set_event_loop()"

        * "new_event_loop()"

        * Event Loop Methods

          * Running and stopping the loop

            * "loop.run_until_complete()"

            * "loop.run_forever()"

            * "loop.stop()"

            * "loop.is_running()"

            * "loop.is_closed()"

            * "loop.close()"

            * "loop.shutdown_asyncgens()"

            * "loop.shutdown_default_executor()"

          * Scheduling callbacks

            * "loop.call_soon()"

            * "loop.call_soon_threadsafe()"

          * Scheduling delayed callbacks

            * "loop.call_later()"

            * "loop.call_at()"

            * "loop.time()"

          * Creating Futures and Tasks

            * "loop.create_future()"

            * "loop.create_task()"

            * "loop.set_task_factory()"

            * "loop.get_task_factory()"

          * Opening network connections

            * "loop.create_connection()"

            * "loop.create_datagram_endpoint()"

            * "loop.create_unix_connection()"

          * Creating network servers

            * "loop.create_server()"

            * "loop.create_unix_server()"

            * "loop.connect_accepted_socket()"

          * Transferring files

            * "loop.sendfile()"

          * TLS Upgrade

            * "loop.start_tls()"

          * Watching file descriptors

            * "loop.add_reader()"

            * "loop.remove_reader()"

            * "loop.add_writer()"

            * "loop.remove_writer()"

          * Working with socket objects directly

            * "loop.sock_recv()"

            * "loop.sock_recv_into()"

            * "loop.sock_recvfrom()"

            * "loop.sock_recvfrom_into()"

            * "loop.sock_sendall()"

            * "loop.sock_sendto()"

            * "loop.sock_connect()"

            * "loop.sock_accept()"

            * "loop.sock_sendfile()"

          * DNS

            * "loop.getaddrinfo()"

            * "loop.getnameinfo()"

          * Working with pipes

            * "loop.connect_read_pipe()"

            * "loop.connect_write_pipe()"

          * Unix signals

            * "loop.add_signal_handler()"

            * "loop.remove_signal_handler()"

          * Executing code in thread or process pools

            * "loop.run_in_executor()"

            * "loop.set_default_executor()"

          * Error Handling API

            * "loop.set_exception_handler()"

            * "loop.get_exception_handler()"

            * "loop.default_exception_handler()"

            * "loop.call_exception_handler()"

          * Enabling debug mode

            * "loop.get_debug()"

            * "loop.set_debug()"

          * Running Subprocesses

            * "loop.subprocess_exec()"

            * "loop.subprocess_shell()"

        * Callback Handles

          * "Handle"

            * "Handle.get_context()"

            * "Handle.cancel()"

            * "Handle.cancelled()"

          * "TimerHandle"

            * "TimerHandle.when()"

        * Server Objects

          * "Server"

            * "Server.close()"

            * "Server.get_loop()"

            * "Server.start_serving()"

            * "Server.serve_forever()"

            * "Server.is_serving()"

            * "Server.wait_closed()"

            * "Server.sockets"

        * Event Loop Implementations

          * "SelectorEventLoop"

          * "ProactorEventLoop"

          * "EventLoop"

          * "AbstractEventLoop"

        * 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

          * "isfuture()"

          * "ensure_future()"

          * "wrap_future()"

        * Future Object

          * "Future"

            * "Future.result()"

            * "Future.set_result()"

            * "Future.set_exception()"

            * "Future.done()"

            * "Future.cancelled()"

            * "Future.add_done_callback()"

            * "Future.remove_done_callback()"

            * "Future.cancel()"

            * "Future.exception()"

            * "Future.get_loop()"

      * Transports and Protocols

        * Transports

          * Transports Hierarchy

            * "BaseTransport"

            * "WriteTransport"

            * "ReadTransport"

            * "Transport"

            * "DatagramTransport"

            * "SubprocessTransport"

          * Base Transport

            * "BaseTransport.close()"

            * "BaseTransport.is_closing()"

            * "BaseTransport.get_extra_info()"

            * "BaseTransport.set_protocol()"

            * "BaseTransport.get_protocol()"

          * Read-only Transports

            * "ReadTransport.is_reading()"

            * "ReadTransport.pause_reading()"

            * "ReadTransport.resume_reading()"

          * Write-only Transports

            * "WriteTransport.abort()"

            * "WriteTransport.can_write_eof()"

            * "WriteTransport.get_write_buffer_size()"

            * "WriteTransport.get_write_buffer_limits()"

            * "WriteTransport.set_write_buffer_limits()"

            * "WriteTransport.write()"

            * "WriteTransport.writelines()"

            * "WriteTransport.write_eof()"

          * Datagram Transports

            * "DatagramTransport.sendto()"

            * "DatagramTransport.abort()"

          * Subprocess Transports

            * "SubprocessTransport.get_pid()"

            * "SubprocessTransport.get_pipe_transport()"

            * "SubprocessTransport.get_returncode()"

            * "SubprocessTransport.kill()"

            * "SubprocessTransport.send_signal()"

            * "SubprocessTransport.terminate()"

            * "SubprocessTransport.close()"

        * Protocols

          * Base Protocols

            * "BaseProtocol"

            * "Protocol"

            * "BufferedProtocol"

            * "DatagramProtocol"

            * "SubprocessProtocol"

          * Base Protocol

            * "BaseProtocol.connection_made()"

            * "BaseProtocol.connection_lost()"

            * "BaseProtocol.pause_writing()"

            * "BaseProtocol.resume_writing()"

          * Streaming Protocols

            * "Protocol.data_received()"

            * "Protocol.eof_received()"

          * Buffered Streaming Protocols

            * "BufferedProtocol.get_buffer()"

            * "BufferedProtocol.buffer_updated()"

            * "BufferedProtocol.eof_received()"

          * Datagram Protocols

            * "DatagramProtocol.datagram_received()"

            * "DatagramProtocol.error_received()"

          * Subprocess Protocols

            * "SubprocessProtocol.pipe_data_received()"

            * "SubprocessProtocol.pipe_connection_lost()"

            * "SubprocessProtocol.process_exited()"

        * 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

          * "get_event_loop_policy()"

          * "set_event_loop_policy()"

        * Policy Objects

          * "AbstractEventLoopPolicy"

            * "AbstractEventLoopPolicy.get_event_loop()"

            * "AbstractEventLoopPolicy.set_event_loop()"

            * "AbstractEventLoopPolicy.new_event_loop()"

            * "AbstractEventLoopPolicy.get_child_watcher()"

            * "AbstractEventLoopPolicy.set_child_watcher()"

          * "DefaultEventLoopPolicy"

          * "WindowsSelectorEventLoopPolicy"

          * "WindowsProactorEventLoopPolicy"

        * Process Watchers

          * "get_child_watcher()"

          * "set_child_watcher()"

          * "AbstractChildWatcher"

            * "AbstractChildWatcher.add_child_handler()"

            * "AbstractChildWatcher.remove_child_handler()"

            * "AbstractChildWatcher.attach_loop()"

            * "AbstractChildWatcher.is_active()"

            * "AbstractChildWatcher.close()"

          * "ThreadedChildWatcher"

          * "MultiLoopChildWatcher"

          * "SafeChildWatcher"

          * "FastChildWatcher"

          * "PidfdChildWatcher"

        * Custom Policies

      * Platform Support

        * All Platforms

        * Windows

          * Subprocess Support on Windows

        * macOS

      * Extending

        * Writing a Custom Event Loop

        * Future and Task private constructors

          * "Future.__init__()"

          * "Task.__init__()"

        * Task lifetime support

          * "_register_task()"

          * "_unregister_task()"

          * "_enter_task()"

          * "_leave_task()"

      * 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

          * "error"

          * "herror"

          * "gaierror"

          * "timeout"

        * Constants

          * "AF_UNIX"

          * "AF_INET"

          * "AF_INET6"

          * "SOCK_STREAM"

          * "SOCK_DGRAM"

          * "SOCK_RAW"

          * "SOCK_RDM"

          * "SOCK_SEQPACKET"

          * "SOCK_CLOEXEC"

          * "SOCK_NONBLOCK"

          * "SOMAXCONN"

          * "AF_CAN"

          * "PF_CAN"

          * "CAN_BCM"

          * "CAN_RAW_FD_FRAMES"

          * "CAN_RAW_JOIN_FILTERS"

          * "CAN_ISOTP"

          * "CAN_J1939"

          * "AF_DIVERT"

          * "PF_DIVERT"

          * "AF_PACKET"

          * "PF_PACKET"

          * "ETH_P_ALL"

          * "AF_RDS"

          * "PF_RDS"

          * "SOL_RDS"

          * "SIO_RCVALL"

          * "SIO_KEEPALIVE_VALS"

          * "SIO_LOOPBACK_FAST_PATH"

          * "AF_ALG"

          * "SOL_ALG"

          * "AF_VSOCK"

          * "IOCTL_VM_SOCKETS_GET_LOCAL_CID"

          * "AF_LINK"

          * "has_ipv6"

          * "BDADDR_ANY"

          * "BDADDR_LOCAL"

          * "HCI_FILTER"

          * "HCI_TIME_STAMP"

          * "HCI_DATA_DIR"

          * "AF_QIPCRTR"

          * "SCM_CREDS2"

          * "LOCAL_CREDS"

          * "LOCAL_CREDS_PERSISTENT"

          * "SO_INCOMING_CPU"

          * "AF_HYPERV"

          * "HV_PROTOCOL_RAW"

          * "HVSOCKET_CONNECT_TIMEOUT"

          * "HVSOCKET_CONNECT_TIMEOUT_MAX"

          * "HVSOCKET_CONNECTED_SUSPEND"

          * "HVSOCKET_ADDRESS_FLAG_PASSTHRU"

          * "HV_GUID_ZERO"

          * "HV_GUID_WILDCARD"

          * "HV_GUID_BROADCAST"

          * "HV_GUID_CHILDREN"

          * "HV_GUID_LOOPBACK"

          * "HV_GUID_PARENT"

          * "ETHERTYPE_ARP"

          * "ETHERTYPE_IP"

          * "ETHERTYPE_IPV6"

          * "ETHERTYPE_VLAN"

        * Functions

          * Creating sockets

            * "socket"

            * "socketpair()"

            * "create_connection()"

            * "create_server()"

            * "has_dualstack_ipv6()"

            * "fromfd()"

            * "fromshare()"

            * "SocketType"

          * Other functions

            * "close()"

            * "getaddrinfo()"

            * "getfqdn()"

            * "gethostbyname()"

            * "gethostbyname_ex()"

            * "gethostname()"

            * "gethostbyaddr()"

            * "getnameinfo()"

            * "getprotobyname()"

            * "getservbyname()"

            * "getservbyport()"

            * "ntohl()"

            * "ntohs()"

            * "htonl()"

            * "htons()"

            * "inet_aton()"

            * "inet_ntoa()"

            * "inet_pton()"

            * "inet_ntop()"

            * "CMSG_LEN()"

            * "CMSG_SPACE()"

            * "getdefaulttimeout()"

            * "setdefaulttimeout()"

            * "sethostname()"

            * "if_nameindex()"

            * "if_nametoindex()"

            * "if_indextoname()"

            * "send_fds()"

            * "recv_fds()"

      * Socket Objects

        * "socket.accept()"

        * "socket.bind()"

        * "socket.close()"

        * "socket.connect()"

        * "socket.connect_ex()"

        * "socket.detach()"

        * "socket.dup()"

        * "socket.fileno()"

        * "socket.get_inheritable()"

        * "socket.getpeername()"

        * "socket.getsockname()"

        * "socket.getsockopt()"

        * "socket.getblocking()"

        * "socket.gettimeout()"

        * "socket.ioctl()"

        * "socket.listen()"

        * "socket.makefile()"

        * "socket.recv()"

        * "socket.recvfrom()"

        * "socket.recvmsg()"

        * "socket.recvmsg_into()"

        * "socket.recvfrom_into()"

        * "socket.recv_into()"

        * "socket.send()"

        * "socket.sendall()"

        * "socket.sendto()"

        * "socket.sendmsg()"

        * "socket.sendmsg_afalg()"

        * "socket.sendfile()"

        * "socket.set_inheritable()"

        * "socket.setblocking()"

        * "socket.settimeout()"

        * "socket.setsockopt()"

        * "socket.shutdown()"

        * "socket.share()"

        * "socket.family"

        * "socket.type"

        * "socket.proto"

      * 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

          * "create_default_context()"

        * Exceptions

          * "SSLError"

            * "SSLError.library"

            * "SSLError.reason"

          * "SSLZeroReturnError"

          * "SSLWantReadError"

          * "SSLWantWriteError"

          * "SSLSyscallError"

          * "SSLEOFError"

          * "SSLCertVerificationError"

            * "SSLCertVerificationError.verify_code"

            * "SSLCertVerificationError.verify_message"

          * "CertificateError"

        * Random generation

          * "RAND_bytes()"

          * "RAND_status()"

          * "RAND_add()"

        * Certificate handling

          * "cert_time_to_seconds()"

          * "get_server_certificate()"

          * "DER_cert_to_PEM_cert()"

          * "PEM_cert_to_DER_cert()"

          * "get_default_verify_paths()"

          * "enum_certificates()"

          * "enum_crls()"

        * Constants

          * "CERT_NONE"

          * "CERT_OPTIONAL"

          * "CERT_REQUIRED"

          * "VerifyMode"

          * "VERIFY_DEFAULT"

          * "VERIFY_CRL_CHECK_LEAF"

          * "VERIFY_CRL_CHECK_CHAIN"

          * "VERIFY_X509_STRICT"

          * "VERIFY_ALLOW_PROXY_CERTS"

          * "VERIFY_X509_TRUSTED_FIRST"

          * "VERIFY_X509_PARTIAL_CHAIN"

          * "VerifyFlags"

          * "PROTOCOL_TLS"

          * "PROTOCOL_TLS_CLIENT"

          * "PROTOCOL_TLS_SERVER"

          * "PROTOCOL_SSLv23"

          * "PROTOCOL_SSLv3"

          * "PROTOCOL_TLSv1"

          * "PROTOCOL_TLSv1_1"

          * "PROTOCOL_TLSv1_2"

          * "OP_ALL"

          * "OP_NO_SSLv2"

          * "OP_NO_SSLv3"

          * "OP_NO_TLSv1"

          * "OP_NO_TLSv1_1"

          * "OP_NO_TLSv1_2"

          * "OP_NO_TLSv1_3"

          * "OP_NO_RENEGOTIATION"

          * "OP_CIPHER_SERVER_PREFERENCE"

          * "OP_SINGLE_DH_USE"

          * "OP_SINGLE_ECDH_USE"

          * "OP_ENABLE_MIDDLEBOX_COMPAT"

          * "OP_NO_COMPRESSION"

          * "Options"

          * "OP_NO_TICKET"

          * "OP_IGNORE_UNEXPECTED_EOF"

          * "OP_ENABLE_KTLS"

          * "OP_LEGACY_SERVER_CONNECT"

          * "HAS_ALPN"

          * "HAS_NEVER_CHECK_COMMON_NAME"

          * "HAS_ECDH"

          * "HAS_SNI"

          * "HAS_NPN"

          * "HAS_SSLv2"

          * "HAS_SSLv3"

          * "HAS_TLSv1"

          * "HAS_TLSv1_1"

          * "HAS_TLSv1_2"

          * "HAS_TLSv1_3"

          * "CHANNEL_BINDING_TYPES"

          * "OPENSSL_VERSION"

          * "OPENSSL_VERSION_INFO"

          * "OPENSSL_VERSION_NUMBER"

          * "ALERT_DESCRIPTION_HANDSHAKE_FAILURE"

          * "ALERT_DESCRIPTION_INTERNAL_ERROR"

          * "AlertDescription"

          * "Purpose.SERVER_AUTH"

          * "Purpose.CLIENT_AUTH"

          * "SSLErrorNumber"

          * "TLSVersion"

            * "TLSVersion.MINIMUM_SUPPORTED"

            * "TLSVersion.MAXIMUM_SUPPORTED"

            * "TLSVersion.SSLv3"

            * "TLSVersion.TLSv1"

            * "TLSVersion.TLSv1_1"

            * "TLSVersion.TLSv1_2"

            * "TLSVersion.TLSv1_3"

      * SSL Sockets

        * "SSLSocket"

          * "SSLSocket.read()"

          * "SSLSocket.write()"

          * "SSLSocket.do_handshake()"

          * "SSLSocket.getpeercert()"

          * "SSLSocket.get_verified_chain()"

          * "SSLSocket.get_unverified_chain()"

          * "SSLSocket.cipher()"

          * "SSLSocket.shared_ciphers()"

          * "SSLSocket.compression()"

          * "SSLSocket.get_channel_binding()"

          * "SSLSocket.selected_alpn_protocol()"

          * "SSLSocket.selected_npn_protocol()"

          * "SSLSocket.unwrap()"

          * "SSLSocket.verify_client_post_handshake()"

          * "SSLSocket.version()"

          * "SSLSocket.pending()"

          * "SSLSocket.context"

          * "SSLSocket.server_side"

          * "SSLSocket.server_hostname"

          * "SSLSocket.session"

          * "SSLSocket.session_reused"

      * SSL Contexts

        * "SSLContext"

          * "SSLContext.cert_store_stats()"

          * "SSLContext.load_cert_chain()"

          * "SSLContext.load_default_certs()"

          * "SSLContext.load_verify_locations()"

          * "SSLContext.get_ca_certs()"

          * "SSLContext.get_ciphers()"

          * "SSLContext.set_default_verify_paths()"

          * "SSLContext.set_ciphers()"

          * "SSLContext.set_alpn_protocols()"

          * "SSLContext.set_npn_protocols()"

          * "SSLContext.sni_callback"

          * "SSLContext.set_servername_callback"

          * "SSLContext.load_dh_params()"

          * "SSLContext.set_ecdh_curve()"

          * "SSLContext.wrap_socket()"

          * "SSLContext.sslsocket_class"

          * "SSLContext.wrap_bio()"

          * "SSLContext.sslobject_class"

          * "SSLContext.session_stats()"

          * "SSLContext.check_hostname"

          * "SSLContext.keylog_filename"

          * "SSLContext.maximum_version"

          * "SSLContext.minimum_version"

          * "SSLContext.num_tickets"

          * "SSLContext.options"

          * "SSLContext.post_handshake_auth"

          * "SSLContext.protocol"

          * "SSLContext.hostname_checks_common_name"

          * "SSLContext.security_level"

          * "SSLContext.verify_flags"

          * "SSLContext.verify_mode"

      * 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

        * "SSLObject"

        * "MemoryBIO"

          * "MemoryBIO.pending"

          * "MemoryBIO.eof"

          * "MemoryBIO.read()"

          * "MemoryBIO.write()"

          * "MemoryBIO.write_eof()"

      * SSL session

        * "SSLSession"

          * "SSLSession.id"

          * "SSLSession.time"

          * "SSLSession.timeout"

          * "SSLSession.ticket_lifetime_hint"

          * "SSLSession.has_ticket"

      * Security considerations

        * Best defaults

        * Manual settings

          * Verifying certificates

          * Protocol versions

          * Cipher selection

        * Multi-processing

      * TLS 1.3

    * "select" --- Waiting for I/O completion

      * "error"

      * "devpoll()"

      * "epoll()"

      * "poll()"

      * "kqueue()"

      * "kevent()"

      * "select()"

      * "PIPE_BUF"

      * "/dev/poll" Polling Objects

        * "devpoll.close()"

        * "devpoll.closed"

        * "devpoll.fileno()"

        * "devpoll.register()"

        * "devpoll.modify()"

        * "devpoll.unregister()"

        * "devpoll.poll()"

      * Edge and Level Trigger Polling (epoll) Objects

        * "epoll.close()"

        * "epoll.closed"

        * "epoll.fileno()"

        * "epoll.fromfd()"

        * "epoll.register()"

        * "epoll.modify()"

        * "epoll.unregister()"

        * "epoll.poll()"

      * Polling Objects

        * "poll.register()"

        * "poll.modify()"

        * "poll.unregister()"

        * "poll.poll()"

      * Kqueue Objects

        * "kqueue.close()"

        * "kqueue.closed"

        * "kqueue.fileno()"

        * "kqueue.fromfd()"

        * "kqueue.control()"

      * Kevent Objects

        * "kevent.ident"

        * "kevent.filter"

        * "kevent.flags"

        * "kevent.fflags"

        * "kevent.data"

        * "kevent.udata"

    * "selectors" --- High-level I/O multiplexing

      * Introduction

      * Classes

        * "EVENT_READ"

        * "EVENT_WRITE"

        * "SelectorKey"

          * "SelectorKey.fileobj"

          * "SelectorKey.fd"

          * "SelectorKey.events"

          * "SelectorKey.data"

        * "BaseSelector"

          * "BaseSelector.register()"

          * "BaseSelector.unregister()"

          * "BaseSelector.modify()"

          * "BaseSelector.select()"

          * "BaseSelector.close()"

          * "BaseSelector.get_key()"

          * "BaseSelector.get_map()"

        * "DefaultSelector"

        * "SelectSelector"

        * "PollSelector"

        * "EpollSelector"

          * "EpollSelector.fileno()"

        * "DevpollSelector"

          * "DevpollSelector.fileno()"

        * "KqueueSelector"

          * "KqueueSelector.fileno()"

      * Examples

    * "signal" --- Set handlers for asynchronous events

      * General rules

        * Execution of Python signal handlers

        * Signals and threads

      * Module contents

        * "Signals"

        * "Handlers"

        * "Sigmasks"

        * "SIG_DFL"

        * "SIG_IGN"

        * "SIGABRT"

        * "SIGALRM"

        * "SIGBREAK"

        * "SIGBUS"

        * "SIGCHLD"

        * "SIGCLD"

        * "SIGCONT"

        * "SIGFPE"

        * "SIGHUP"

        * "SIGILL"

        * "SIGINT"

        * "SIGKILL"

        * "SIGPIPE"

        * "SIGSEGV"

        * "SIGSTKFLT"

        * "SIGTERM"

        * "SIGUSR1"

        * "SIGUSR2"

        * "SIGWINCH"

        * "CTRL_C_EVENT"

        * "CTRL_BREAK_EVENT"

        * "NSIG"

        * "ITIMER_REAL"

        * "ITIMER_VIRTUAL"

        * "ITIMER_PROF"

        * "SIG_BLOCK"

        * "SIG_UNBLOCK"

        * "SIG_SETMASK"

        * "ItimerError"

        * "alarm()"

        * "getsignal()"

        * "strsignal()"

        * "valid_signals()"

        * "pause()"

        * "raise_signal()"

        * "pidfd_send_signal()"

        * "pthread_kill()"

        * "pthread_sigmask()"

        * "setitimer()"

        * "getitimer()"

        * "set_wakeup_fd()"

        * "siginterrupt()"

        * "signal()"

        * "sigpending()"

        * "sigwait()"

        * "sigwaitinfo()"

        * "sigtimedwait()"

      * Examples

      * Note on SIGPIPE

      * Note on Signal Handlers and Exceptions

    * "mmap" --- Memory-mapped file support

      * "mmap"

        * "mmap.close()"

        * "mmap.closed"

        * "mmap.find()"

        * "mmap.flush()"

        * "mmap.madvise()"

        * "mmap.move()"

        * "mmap.read()"

        * "mmap.read_byte()"

        * "mmap.readline()"

        * "mmap.resize()"

        * "mmap.rfind()"

        * "mmap.seek()"

        * "mmap.size()"

        * "mmap.tell()"

        * "mmap.write()"

        * "mmap.write_byte()"

      * MADV_* Constants

        * "MADV_NORMAL"

        * "MADV_RANDOM"

        * "MADV_SEQUENTIAL"

        * "MADV_WILLNEED"

        * "MADV_DONTNEED"

        * "MADV_REMOVE"

        * "MADV_DONTFORK"

        * "MADV_DOFORK"

        * "MADV_HWPOISON"

        * "MADV_MERGEABLE"

        * "MADV_UNMERGEABLE"

        * "MADV_SOFT_OFFLINE"

        * "MADV_HUGEPAGE"

        * "MADV_NOHUGEPAGE"

        * "MADV_DONTDUMP"

        * "MADV_DODUMP"

        * "MADV_FREE"

        * "MADV_NOSYNC"

        * "MADV_AUTOSYNC"

        * "MADV_NOCORE"

        * "MADV_CORE"

        * "MADV_PROTECT"

        * "MADV_FREE_REUSABLE"

        * "MADV_FREE_REUSE"

      * MAP_* Constants

        * "MAP_SHARED"

        * "MAP_PRIVATE"

        * "MAP_DENYWRITE"

        * "MAP_EXECUTABLE"

        * "MAP_ANON"

        * "MAP_ANONYMOUS"

        * "MAP_POPULATE"

        * "MAP_STACK"

        * "MAP_ALIGNED_SUPER"

        * "MAP_CONCEAL"

  * Internet Data Handling

    * "email" --- An email and MIME handling package

      * "email.message": Representing an email message

        * "EmailMessage"

          * "EmailMessage.as_string()"

          * "EmailMessage.__str__()"

          * "EmailMessage.as_bytes()"

          * "EmailMessage.__bytes__()"

          * "EmailMessage.is_multipart()"

          * "EmailMessage.set_unixfrom()"

          * "EmailMessage.get_unixfrom()"

          * "EmailMessage.__len__()"

          * "EmailMessage.__contains__()"

          * "EmailMessage.__getitem__()"

          * "EmailMessage.__setitem__()"

          * "EmailMessage.__delitem__()"

          * "EmailMessage.keys()"

          * "EmailMessage.values()"

          * "EmailMessage.items()"

          * "EmailMessage.get()"

          * "EmailMessage.get_all()"

          * "EmailMessage.add_header()"

          * "EmailMessage.replace_header()"

          * "EmailMessage.get_content_type()"

          * "EmailMessage.get_content_maintype()"

          * "EmailMessage.get_content_subtype()"

          * "EmailMessage.get_default_type()"

          * "EmailMessage.set_default_type()"

          * "EmailMessage.set_param()"

          * "EmailMessage.del_param()"

          * "EmailMessage.get_filename()"

          * "EmailMessage.get_boundary()"

          * "EmailMessage.set_boundary()"

          * "EmailMessage.get_content_charset()"

          * "EmailMessage.get_charsets()"

          * "EmailMessage.is_attachment()"

          * "EmailMessage.get_content_disposition()"

          * "EmailMessage.walk()"

          * "EmailMessage.get_body()"

          * "EmailMessage.iter_attachments()"

          * "EmailMessage.iter_parts()"

          * "EmailMessage.get_content()"

          * "EmailMessage.set_content()"

          * "EmailMessage.make_related()"

          * "EmailMessage.make_alternative()"

          * "EmailMessage.make_mixed()"

          * "EmailMessage.add_related()"

          * "EmailMessage.add_alternative()"

          * "EmailMessage.add_attachment()"

          * "EmailMessage.clear()"

          * "EmailMessage.clear_content()"

          * "EmailMessage.preamble"

          * "EmailMessage.epilogue"

          * "EmailMessage.defects"

        * "MIMEPart"

      * "email.parser": Parsing email messages

        * FeedParser API

          * "BytesFeedParser"

            * "BytesFeedParser.feed()"

            * "BytesFeedParser.close()"

          * "FeedParser"

        * Parser API

          * "BytesParser"

            * "BytesParser.parse()"

            * "BytesParser.parsebytes()"

          * "BytesHeaderParser"

          * "Parser"

            * "Parser.parse()"

            * "Parser.parsestr()"

          * "HeaderParser"

          * "message_from_bytes()"

          * "message_from_binary_file()"

          * "message_from_string()"

          * "message_from_file()"

        * Additional notes

      * "email.generator": Generating MIME documents

        * "BytesGenerator"

          * "BytesGenerator.flatten()"

          * "BytesGenerator.clone()"

          * "BytesGenerator.write()"

        * "Generator"

          * "Generator.flatten()"

          * "Generator.clone()"

          * "Generator.write()"

        * "DecodedGenerator"

      * "email.policy": Policy Objects

        * "Policy"

          * "Policy.max_line_length"

          * "Policy.linesep"

          * "Policy.cte_type"

          * "Policy.raise_on_defect"

          * "Policy.mangle_from_"

          * "Policy.message_factory"

          * "Policy.clone()"

          * "Policy.handle_defect()"

          * "Policy.register_defect()"

          * "Policy.header_max_count()"

          * "Policy.header_source_parse()"

          * "Policy.header_store_parse()"

          * "Policy.header_fetch_parse()"

          * "Policy.fold()"

          * "Policy.fold_binary()"

        * "EmailPolicy"

          * "EmailPolicy.utf8"

          * "EmailPolicy.refold_source"

          * "EmailPolicy.header_factory"

          * "EmailPolicy.content_manager"

          * "EmailPolicy.header_max_count()"

          * "EmailPolicy.header_source_parse()"

          * "EmailPolicy.header_store_parse()"

          * "EmailPolicy.header_fetch_parse()"

          * "EmailPolicy.fold()"

          * "EmailPolicy.fold_binary()"

        * "default"

        * "SMTP"

        * "SMTPUTF8"

        * "HTTP"

        * "strict"

        * "Compat32"

          * "Compat32.mangle_from_"

          * "Compat32.header_source_parse()"

          * "Compat32.header_store_parse()"

          * "Compat32.header_fetch_parse()"

          * "Compat32.fold()"

          * "Compat32.fold_binary()"

        * "compat32"

      * "email.errors": Exception and Defect classes

        * "MessageError"

        * "MessageParseError"

        * "HeaderParseError"

        * "BoundaryError"

        * "MultipartConversionError"

      * "email.headerregistry": Custom Header Objects

        * "BaseHeader"

          * "BaseHeader.name"

          * "BaseHeader.defects"

          * "BaseHeader.max_count"

          * "BaseHeader.fold()"

        * "UnstructuredHeader"

        * "DateHeader"

          * "DateHeader.datetime"

        * "AddressHeader"

          * "AddressHeader.groups"

          * "AddressHeader.addresses"

        * "SingleAddressHeader"

          * "SingleAddressHeader.address"

        * "MIMEVersionHeader"

          * "MIMEVersionHeader.version"

          * "MIMEVersionHeader.major"

          * "MIMEVersionHeader.minor"

        * "ParameterizedMIMEHeader"

          * "ParameterizedMIMEHeader.params"

        * "ContentTypeHeader"

          * "ContentTypeHeader.content_type"

          * "ContentTypeHeader.maintype"

          * "ContentTypeHeader.subtype"

        * "ContentDispositionHeader"

          * "ContentDispositionHeader.content_disposition"

        * "ContentTransferEncoding"

          * "ContentTransferEncoding.cte"

        * "HeaderRegistry"

          * "HeaderRegistry.map_to_type()"

          * "HeaderRegistry.__getitem__()"

          * "HeaderRegistry.__call__()"

        * "Address"

          * "Address.display_name"

          * "Address.username"

          * "Address.domain"

          * "Address.addr_spec"

          * "Address.__str__()"

        * "Group"

          * "Group.display_name"

          * "Group.addresses"

          * "Group.__str__()"

      * "email.contentmanager": Managing MIME Content

        * "ContentManager"

          * "ContentManager.get_content()"

          * "ContentManager.set_content()"

          * "ContentManager.add_get_handler()"

          * "ContentManager.add_set_handler()"

        * Content Manager Instances

          * "raw_data_manager"

          * "get_content()"

          * "set_content()"

      * "email": Examples

      * "email.message.Message": Representing an email message using
        the "compat32" API

        * "Message"

          * "Message.as_string()"

          * "Message.__str__()"

          * "Message.as_bytes()"

          * "Message.__bytes__()"

          * "Message.is_multipart()"

          * "Message.set_unixfrom()"

          * "Message.get_unixfrom()"

          * "Message.attach()"

          * "Message.get_payload()"

          * "Message.set_payload()"

          * "Message.set_charset()"

          * "Message.get_charset()"

          * "Message.__len__()"

          * "Message.__contains__()"

          * "Message.__getitem__()"

          * "Message.__setitem__()"

          * "Message.__delitem__()"

          * "Message.keys()"

          * "Message.values()"

          * "Message.items()"

          * "Message.get()"

          * "Message.get_all()"

          * "Message.add_header()"

          * "Message.replace_header()"

          * "Message.get_content_type()"

          * "Message.get_content_maintype()"

          * "Message.get_content_subtype()"

          * "Message.get_default_type()"

          * "Message.set_default_type()"

          * "Message.get_params()"

          * "Message.get_param()"

          * "Message.set_param()"

          * "Message.del_param()"

          * "Message.set_type()"

          * "Message.get_filename()"

          * "Message.get_boundary()"

          * "Message.set_boundary()"

          * "Message.get_content_charset()"

          * "Message.get_charsets()"

          * "Message.get_content_disposition()"

          * "Message.walk()"

          * "Message.preamble"

          * "Message.epilogue"

          * "Message.defects"

      * "email.mime": Creating email and MIME objects from scratch

        * "MIMEBase"

        * "MIMENonMultipart"

        * "MIMEMultipart"

        * "MIMEApplication"

        * "MIMEAudio"

        * "MIMEImage"

        * "MIMEMessage"

        * "MIMEText"

      * "email.header": Internationalized headers

        * "Header"

          * "Header.append()"

          * "Header.encode()"

          * "Header.__str__()"

          * "Header.__eq__()"

          * "Header.__ne__()"

        * "decode_header()"

        * "make_header()"

      * "email.charset": Representing character sets

        * "Charset"

          * "Charset.input_charset"

          * "Charset.header_encoding"

          * "Charset.body_encoding"

          * "Charset.output_charset"

          * "Charset.input_codec"

          * "Charset.output_codec"

          * "Charset.get_body_encoding()"

          * "Charset.get_output_charset()"

          * "Charset.header_encode()"

          * "Charset.header_encode_lines()"

          * "Charset.body_encode()"

          * "Charset.__str__()"

          * "Charset.__eq__()"

          * "Charset.__ne__()"

        * "add_charset()"

        * "add_alias()"

        * "add_codec()"

      * "email.encoders": Encoders

        * "encode_quopri()"

        * "encode_base64()"

        * "encode_7or8bit()"

        * "encode_noop()"

      * "email.utils": Miscellaneous utilities

        * "localtime()"

        * "make_msgid()"

        * "quote()"

        * "unquote()"

        * "parseaddr()"

        * "formataddr()"

        * "getaddresses()"

        * "parsedate()"

        * "parsedate_tz()"

        * "parsedate_to_datetime()"

        * "mktime_tz()"

        * "formatdate()"

        * "format_datetime()"

        * "decode_rfc2231()"

        * "encode_rfc2231()"

        * "collapse_rfc2231_value()"

        * "decode_params()"

      * "email.iterators": Iterators

        * "body_line_iterator()"

        * "typed_subpart_iterator()"

        * "_structure()"

    * "json" --- JSON encoder and decoder

      * Basic Usage

        * "dump()"

        * "dumps()"

        * "load()"

        * "loads()"

      * Encoders and Decoders

        * "JSONDecoder"

          * "JSONDecoder.decode()"

          * "JSONDecoder.raw_decode()"

        * "JSONEncoder"

          * "JSONEncoder.default()"

          * "JSONEncoder.encode()"

          * "JSONEncoder.iterencode()"

      * Exceptions

        * "JSONDecodeError"

          * "JSONDecodeError.msg"

          * "JSONDecodeError.doc"

          * "JSONDecodeError.pos"

          * "JSONDecodeError.lineno"

          * "JSONDecodeError.colno"

      * 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

    * "mailbox" --- Manipulate mailboxes in various formats

      * "Mailbox" objects

        * "Mailbox"

          * "Mailbox.add()"

          * "Mailbox.remove()"

          * "Mailbox.__delitem__()"

          * "Mailbox.discard()"

          * "Mailbox.__setitem__()"

          * "Mailbox.iterkeys()"

          * "Mailbox.keys()"

          * "Mailbox.itervalues()"

          * "Mailbox.__iter__()"

          * "Mailbox.values()"

          * "Mailbox.iteritems()"

          * "Mailbox.items()"

          * "Mailbox.get()"

          * "Mailbox.__getitem__()"

          * "Mailbox.get_message()"

          * "Mailbox.get_bytes()"

          * "Mailbox.get_string()"

          * "Mailbox.get_file()"

          * "Mailbox.__contains__()"

          * "Mailbox.__len__()"

          * "Mailbox.clear()"

          * "Mailbox.pop()"

          * "Mailbox.popitem()"

          * "Mailbox.update()"

          * "Mailbox.flush()"

          * "Mailbox.lock()"

          * "Mailbox.unlock()"

          * "Mailbox.close()"

        * "Maildir"

          * "Maildir"

            * "Maildir.list_folders()"

            * "Maildir.get_folder()"

            * "Maildir.add_folder()"

            * "Maildir.remove_folder()"

            * "Maildir.clean()"

            * "Maildir.add()"

            * "Maildir.__setitem__()"

            * "Maildir.update()"

            * "Maildir.flush()"

            * "Maildir.lock()"

            * "Maildir.unlock()"

            * "Maildir.close()"

            * "Maildir.get_file()"

        * "mbox"

          * "mbox"

            * "mbox.get_file()"

            * "mbox.lock()"

            * "mbox.unlock()"

        * "MH"

          * "MH"

            * "MH.list_folders()"

            * "MH.get_folder()"

            * "MH.add_folder()"

            * "MH.remove_folder()"

            * "MH.get_sequences()"

            * "MH.set_sequences()"

            * "MH.pack()"

            * "MH.remove()"

            * "MH.__delitem__()"

            * "MH.discard()"

            * "MH.lock()"

            * "MH.unlock()"

            * "MH.get_file()"

            * "MH.flush()"

            * "MH.close()"

        * "Babyl"

          * "Babyl"

            * "Babyl.get_labels()"

            * "Babyl.get_file()"

            * "Babyl.lock()"

            * "Babyl.unlock()"

        * "MMDF"

          * "MMDF"

            * "MMDF.get_file()"

            * "MMDF.lock()"

            * "MMDF.unlock()"

      * "Message" objects

        * "Message"

        * "MaildirMessage"

          * "MaildirMessage"

            * "MaildirMessage.get_subdir()"

            * "MaildirMessage.set_subdir()"

            * "MaildirMessage.get_flags()"

            * "MaildirMessage.set_flags()"

            * "MaildirMessage.add_flag()"

            * "MaildirMessage.remove_flag()"

            * "MaildirMessage.get_date()"

            * "MaildirMessage.set_date()"

            * "MaildirMessage.get_info()"

            * "MaildirMessage.set_info()"

        * "mboxMessage"

          * "mboxMessage"

            * "mboxMessage.get_from()"

            * "mboxMessage.set_from()"

            * "mboxMessage.get_flags()"

            * "mboxMessage.set_flags()"

            * "mboxMessage.add_flag()"

            * "mboxMessage.remove_flag()"

        * "MHMessage"

          * "MHMessage"

            * "MHMessage.get_sequences()"

            * "MHMessage.set_sequences()"

            * "MHMessage.add_sequence()"

            * "MHMessage.remove_sequence()"

        * "BabylMessage"

          * "BabylMessage"

            * "BabylMessage.get_labels()"

            * "BabylMessage.set_labels()"

            * "BabylMessage.add_label()"

            * "BabylMessage.remove_label()"

            * "BabylMessage.get_visible()"

            * "BabylMessage.set_visible()"

            * "BabylMessage.update_visible()"

        * "MMDFMessage"

          * "MMDFMessage"

            * "MMDFMessage.get_from()"

            * "MMDFMessage.set_from()"

            * "MMDFMessage.get_flags()"

            * "MMDFMessage.set_flags()"

            * "MMDFMessage.add_flag()"

            * "MMDFMessage.remove_flag()"

      * Exceptions

        * "Error"

        * "NoSuchMailboxError"

        * "NotEmptyError"

        * "ExternalClashError"

        * "FormatError"

      * Examples

    * "mimetypes" --- Map filenames to MIME types

      * "guess_type()"

      * "guess_all_extensions()"

      * "guess_extension()"

      * "init()"

      * "read_mime_types()"

      * "add_type()"

      * "inited"

      * "knownfiles"

      * "suffix_map"

      * "encodings_map"

      * "types_map"

      * "common_types"

      * MimeTypes Objects

        * "MimeTypes"

          * "MimeTypes.suffix_map"

          * "MimeTypes.encodings_map"

          * "MimeTypes.types_map"

          * "MimeTypes.types_map_inv"

          * "MimeTypes.guess_extension()"

          * "MimeTypes.guess_type()"

          * "MimeTypes.guess_all_extensions()"

          * "MimeTypes.read()"

          * "MimeTypes.readfp()"

          * "MimeTypes.read_windows_registry()"

    * "base64" --- Base16, Base32, Base64, Base85 Data Encodings

      * "b64encode()"

      * "b64decode()"

      * "standard_b64encode()"

      * "standard_b64decode()"

      * "urlsafe_b64encode()"

      * "urlsafe_b64decode()"

      * "b32encode()"

      * "b32decode()"

      * "b32hexencode()"

      * "b32hexdecode()"

      * "b16encode()"

      * "b16decode()"

      * "a85encode()"

      * "a85decode()"

      * "b85encode()"

      * "b85decode()"

      * "decode()"

      * "decodebytes()"

      * "encode()"

      * "encodebytes()"

      * Security Considerations

    * "binascii" --- Convert between binary and ASCII

      * "a2b_uu()"

      * "b2a_uu()"

      * "a2b_base64()"

      * "b2a_base64()"

      * "a2b_qp()"

      * "b2a_qp()"

      * "crc_hqx()"

      * "crc32()"

      * "b2a_hex()"

      * "hexlify()"

      * "a2b_hex()"

      * "unhexlify()"

      * "Error"

      * "Incomplete"

    * "quopri" --- Encode and decode MIME quoted-printable data

      * "decode()"

      * "encode()"

      * "decodestring()"

      * "encodestring()"

  * Structured Markup Processing Tools

    * "html" --- HyperText Markup Language support

      * "escape()"

      * "unescape()"

    * "html.parser" --- Simple HTML and XHTML parser

      * "HTMLParser"

      * Example HTML Parser Application

      * "HTMLParser" Methods

        * "HTMLParser.feed()"

        * "HTMLParser.close()"

        * "HTMLParser.reset()"

        * "HTMLParser.getpos()"

        * "HTMLParser.get_starttag_text()"

        * "HTMLParser.handle_starttag()"

        * "HTMLParser.handle_endtag()"

        * "HTMLParser.handle_startendtag()"

        * "HTMLParser.handle_data()"

        * "HTMLParser.handle_entityref()"

        * "HTMLParser.handle_charref()"

        * "HTMLParser.handle_comment()"

        * "HTMLParser.handle_decl()"

        * "HTMLParser.handle_pi()"

        * "HTMLParser.unknown_decl()"

      * Examples

    * "html.entities" --- Definitions of HTML general entities

      * "html5"

      * "entitydefs"

      * "name2codepoint"

      * "codepoint2name"

    * 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

      * XPath support

        * Example

        * Supported XPath syntax

      * Reference

        * Functions

          * "canonicalize()"

          * "Comment()"

          * "dump()"

          * "fromstring()"

          * "fromstringlist()"

          * "indent()"

          * "iselement()"

          * "iterparse()"

          * "parse()"

          * "ProcessingInstruction()"

          * "register_namespace()"

          * "SubElement()"

          * "tostring()"

          * "tostringlist()"

          * "XML()"

          * "XMLID()"

      * XInclude support

        * Example

      * Reference

        * Functions

          * "xml.etree.ElementInclude.default_loader()"

          * "xml.etree.ElementInclude.include()"

        * Element Objects

          * "Element"

            * "Element.tag"

            * "Element.text"

            * "Element.tail"

            * "Element.attrib"

            * "Element.clear()"

            * "Element.get()"

            * "Element.items()"

            * "Element.keys()"

            * "Element.set()"

            * "Element.append()"

            * "Element.extend()"

            * "Element.find()"

            * "Element.findall()"

            * "Element.findtext()"

            * "Element.insert()"

            * "Element.iter()"

            * "Element.iterfind()"

            * "Element.itertext()"

            * "Element.makeelement()"

            * "Element.remove()"

        * ElementTree Objects

          * "ElementTree"

            * "ElementTree._setroot()"

            * "ElementTree.find()"

            * "ElementTree.findall()"

            * "ElementTree.findtext()"

            * "ElementTree.getroot()"

            * "ElementTree.iter()"

            * "ElementTree.iterfind()"

            * "ElementTree.parse()"

            * "ElementTree.write()"

        * QName Objects

          * "QName"

        * TreeBuilder Objects

          * "TreeBuilder"

            * "TreeBuilder.close()"

            * "TreeBuilder.data()"

            * "TreeBuilder.end()"

            * "TreeBuilder.start()"

            * "TreeBuilder.comment()"

            * "TreeBuilder.pi()"

            * "TreeBuilder.doctype()"

            * "TreeBuilder.start_ns()"

            * "TreeBuilder.end_ns()"

          * "C14NWriterTarget"

        * XMLParser Objects

          * "XMLParser"

            * "XMLParser.close()"

            * "XMLParser.feed()"

        * XMLPullParser Objects

          * "XMLPullParser"

            * "XMLPullParser.feed()"

            * "XMLPullParser.close()"

            * "XMLPullParser.read_events()"

        * Exceptions

          * "ParseError"

            * "ParseError.code"

            * "ParseError.position"

    * "xml.dom" --- The Document Object Model API

      * Module Contents

        * "registerDOMImplementation()"

        * "getDOMImplementation()"

        * "EMPTY_NAMESPACE"

        * "XML_NAMESPACE"

        * "XMLNS_NAMESPACE"

        * "XHTML_NAMESPACE"

      * Objects in the DOM

        * DOMImplementation Objects

          * "DOMImplementation.hasFeature()"

          * "DOMImplementation.createDocument()"

          * "DOMImplementation.createDocumentType()"

        * Node Objects

          * "Node.nodeType"

          * "Node.parentNode"

          * "Node.attributes"

          * "Node.previousSibling"

          * "Node.nextSibling"

          * "Node.childNodes"

          * "Node.firstChild"

          * "Node.lastChild"

          * "Node.localName"

          * "Node.prefix"

          * "Node.namespaceURI"

          * "Node.nodeName"

          * "Node.nodeValue"

          * "Node.hasAttributes()"

          * "Node.hasChildNodes()"

          * "Node.isSameNode()"

          * "Node.appendChild()"

          * "Node.insertBefore()"

          * "Node.removeChild()"

          * "Node.replaceChild()"

          * "Node.normalize()"

          * "Node.cloneNode()"

        * NodeList Objects

          * "NodeList.item()"

          * "NodeList.length"

        * DocumentType Objects

          * "DocumentType.publicId"

          * "DocumentType.systemId"

          * "DocumentType.internalSubset"

          * "DocumentType.name"

          * "DocumentType.entities"

          * "DocumentType.notations"

        * Document Objects

          * "Document.documentElement"

          * "Document.createElement()"

          * "Document.createElementNS()"

          * "Document.createTextNode()"

          * "Document.createComment()"

          * "Document.createProcessingInstruction()"

          * "Document.createAttribute()"

          * "Document.createAttributeNS()"

          * "Document.getElementsByTagName()"

          * "Document.getElementsByTagNameNS()"

        * Element Objects

          * "Element.tagName"

          * "Element.getElementsByTagName()"

          * "Element.getElementsByTagNameNS()"

          * "Element.hasAttribute()"

          * "Element.hasAttributeNS()"

          * "Element.getAttribute()"

          * "Element.getAttributeNode()"

          * "Element.getAttributeNS()"

          * "Element.getAttributeNodeNS()"

          * "Element.removeAttribute()"

          * "Element.removeAttributeNode()"

          * "Element.removeAttributeNS()"

          * "Element.setAttribute()"

          * "Element.setAttributeNode()"

          * "Element.setAttributeNodeNS()"

          * "Element.setAttributeNS()"

        * Attr Objects

          * "Attr.name"

          * "Attr.localName"

          * "Attr.prefix"

          * "Attr.value"

        * NamedNodeMap Objects

          * "NamedNodeMap.length"

          * "NamedNodeMap.item()"

        * Comment Objects

          * "Comment.data"

        * Text and CDATASection Objects

          * "Text.data"

        * ProcessingInstruction Objects

          * "ProcessingInstruction.target"

          * "ProcessingInstruction.data"

        * Exceptions

          * "DOMException"

          * "DomstringSizeErr"

          * "HierarchyRequestErr"

          * "IndexSizeErr"

          * "InuseAttributeErr"

          * "InvalidAccessErr"

          * "InvalidCharacterErr"

          * "InvalidModificationErr"

          * "InvalidStateErr"

          * "NamespaceErr"

          * "NotFoundErr"

          * "NotSupportedErr"

          * "NoDataAllowedErr"

          * "NoModificationAllowedErr"

          * "SyntaxErr"

          * "WrongDocumentErr"

      * Conformance

        * Type Mapping

        * Accessor Methods

    * "xml.dom.minidom" --- Minimal DOM implementation

      * "parse()"

      * "parseString()"

      * DOM Objects

        * "Node.unlink()"

        * "Node.writexml()"

        * "Node.toxml()"

        * "Node.toprettyxml()"

      * DOM Example

      * minidom and the DOM standard

    * "xml.dom.pulldom" --- Support for building partial DOM trees

      * "PullDom"

      * "SAX2DOM"

      * "parse()"

      * "parseString()"

      * "default_bufsize"

      * DOMEventStream Objects

        * "DOMEventStream"

          * "DOMEventStream.getEvent()"

          * "DOMEventStream.expandNode()"

          * "DOMEventStream.reset()"

    * "xml.sax" --- Support for SAX2 parsers

      * "make_parser()"

      * "parse()"

      * "parseString()"

      * "SAXException"

      * "SAXParseException"

      * "SAXNotRecognizedException"

      * "SAXNotSupportedException"

      * SAXException Objects

        * "SAXException.getMessage()"

        * "SAXException.getException()"

    * "xml.sax.handler" --- Base classes for SAX handlers

      * "ContentHandler"

      * "DTDHandler"

      * "EntityResolver"

      * "ErrorHandler"

      * "LexicalHandler"

      * "feature_namespaces"

      * "feature_namespace_prefixes"

      * "feature_string_interning"

      * "feature_validation"

      * "feature_external_ges"

      * "feature_external_pes"

      * "all_features"

      * "property_lexical_handler"

      * "property_declaration_handler"

      * "property_dom_node"

      * "property_xml_string"

      * "all_properties"

      * ContentHandler Objects

        * "ContentHandler.setDocumentLocator()"

        * "ContentHandler.startDocument()"

        * "ContentHandler.endDocument()"

        * "ContentHandler.startPrefixMapping()"

        * "ContentHandler.endPrefixMapping()"

        * "ContentHandler.startElement()"

        * "ContentHandler.endElement()"

        * "ContentHandler.startElementNS()"

        * "ContentHandler.endElementNS()"

        * "ContentHandler.characters()"

        * "ContentHandler.ignorableWhitespace()"

        * "ContentHandler.processingInstruction()"

        * "ContentHandler.skippedEntity()"

      * DTDHandler Objects

        * "DTDHandler.notationDecl()"

        * "DTDHandler.unparsedEntityDecl()"

      * EntityResolver Objects

        * "EntityResolver.resolveEntity()"

      * ErrorHandler Objects

        * "ErrorHandler.error()"

        * "ErrorHandler.fatalError()"

        * "ErrorHandler.warning()"

      * LexicalHandler Objects

        * "LexicalHandler.comment()"

        * "LexicalHandler.startDTD()"

        * "LexicalHandler.endDTD()"

        * "LexicalHandler.startCDATA()"

        * "LexicalHandler.endCDATA()"

    * "xml.sax.saxutils" --- SAX Utilities

      * "escape()"

      * "unescape()"

      * "quoteattr()"

      * "XMLGenerator"

      * "XMLFilterBase"

      * "prepare_input_source()"

    * "xml.sax.xmlreader" --- Interface for XML parsers

      * "XMLReader"

      * "IncrementalParser"

      * "Locator"

      * "InputSource"

      * "AttributesImpl"

      * "AttributesNSImpl"

      * XMLReader Objects

        * "XMLReader.parse()"

        * "XMLReader.getContentHandler()"

        * "XMLReader.setContentHandler()"

        * "XMLReader.getDTDHandler()"

        * "XMLReader.setDTDHandler()"

        * "XMLReader.getEntityResolver()"

        * "XMLReader.setEntityResolver()"

        * "XMLReader.getErrorHandler()"

        * "XMLReader.setErrorHandler()"

        * "XMLReader.setLocale()"

        * "XMLReader.getFeature()"

        * "XMLReader.setFeature()"

        * "XMLReader.getProperty()"

        * "XMLReader.setProperty()"

      * IncrementalParser Objects

        * "IncrementalParser.feed()"

        * "IncrementalParser.close()"

        * "IncrementalParser.reset()"

      * Locator Objects

        * "Locator.getColumnNumber()"

        * "Locator.getLineNumber()"

        * "Locator.getPublicId()"

        * "Locator.getSystemId()"

      * InputSource Objects

        * "InputSource.setPublicId()"

        * "InputSource.getPublicId()"

        * "InputSource.setSystemId()"

        * "InputSource.getSystemId()"

        * "InputSource.setEncoding()"

        * "InputSource.getEncoding()"

        * "InputSource.setByteStream()"

        * "InputSource.getByteStream()"

        * "InputSource.setCharacterStream()"

        * "InputSource.getCharacterStream()"

      * The "Attributes" Interface

        * "Attributes.getLength()"

        * "Attributes.getNames()"

        * "Attributes.getType()"

        * "Attributes.getValue()"

      * The "AttributesNS" Interface

        * "AttributesNS.getValueByQName()"

        * "AttributesNS.getNameByQName()"

        * "AttributesNS.getQNameByName()"

        * "AttributesNS.getQNames()"

    * "xml.parsers.expat" --- Fast XML parsing using Expat

      * "ExpatError"

      * "error"

      * "XMLParserType"

      * "ErrorString()"

      * "ParserCreate()"

      * XMLParser Objects

        * "xmlparser.Parse()"

        * "xmlparser.ParseFile()"

        * "xmlparser.SetBase()"

        * "xmlparser.GetBase()"

        * "xmlparser.GetInputContext()"

        * "xmlparser.ExternalEntityParserCreate()"

        * "xmlparser.SetParamEntityParsing()"

        * "xmlparser.UseForeignDTD()"

        * "xmlparser.buffer_size"

        * "xmlparser.buffer_text"

        * "xmlparser.buffer_used"

        * "xmlparser.ordered_attributes"

        * "xmlparser.specified_attributes"

        * "xmlparser.ErrorByteIndex"

        * "xmlparser.ErrorCode"

        * "xmlparser.ErrorColumnNumber"

        * "xmlparser.ErrorLineNumber"

        * "xmlparser.CurrentByteIndex"

        * "xmlparser.CurrentColumnNumber"

        * "xmlparser.CurrentLineNumber"

        * "xmlparser.XmlDeclHandler()"

        * "xmlparser.StartDoctypeDeclHandler()"

        * "xmlparser.EndDoctypeDeclHandler()"

        * "xmlparser.ElementDeclHandler()"

        * "xmlparser.AttlistDeclHandler()"

        * "xmlparser.StartElementHandler()"

        * "xmlparser.EndElementHandler()"

        * "xmlparser.ProcessingInstructionHandler()"

        * "xmlparser.CharacterDataHandler()"

        * "xmlparser.UnparsedEntityDeclHandler()"

        * "xmlparser.EntityDeclHandler()"

        * "xmlparser.NotationDeclHandler()"

        * "xmlparser.StartNamespaceDeclHandler()"

        * "xmlparser.EndNamespaceDeclHandler()"

        * "xmlparser.CommentHandler()"

        * "xmlparser.StartCdataSectionHandler()"

        * "xmlparser.EndCdataSectionHandler()"

        * "xmlparser.DefaultHandler()"

        * "xmlparser.DefaultHandlerExpand()"

        * "xmlparser.NotStandaloneHandler()"

        * "xmlparser.ExternalEntityRefHandler()"

      * ExpatError Exceptions

        * "ExpatError.code"

        * "ExpatError.lineno"

        * "ExpatError.offset"

      * Example

      * Content Model Descriptions

      * Expat error constants

        * "codes"

        * "messages"

        * "XML_ERROR_ASYNC_ENTITY"

        * "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF"

        * "XML_ERROR_BAD_CHAR_REF"

        * "XML_ERROR_BINARY_ENTITY_REF"

        * "XML_ERROR_DUPLICATE_ATTRIBUTE"

        * "XML_ERROR_INCORRECT_ENCODING"

        * "XML_ERROR_INVALID_TOKEN"

        * "XML_ERROR_JUNK_AFTER_DOC_ELEMENT"

        * "XML_ERROR_MISPLACED_XML_PI"

        * "XML_ERROR_NO_ELEMENTS"

        * "XML_ERROR_NO_MEMORY"

        * "XML_ERROR_PARAM_ENTITY_REF"

        * "XML_ERROR_PARTIAL_CHAR"

        * "XML_ERROR_RECURSIVE_ENTITY_REF"

        * "XML_ERROR_SYNTAX"

        * "XML_ERROR_TAG_MISMATCH"

        * "XML_ERROR_UNCLOSED_TOKEN"

        * "XML_ERROR_UNDEFINED_ENTITY"

        * "XML_ERROR_UNKNOWN_ENCODING"

        * "XML_ERROR_UNCLOSED_CDATA_SECTION"

        * "XML_ERROR_EXTERNAL_ENTITY_HANDLING"

        * "XML_ERROR_NOT_STANDALONE"

        * "XML_ERROR_UNEXPECTED_STATE"

        * "XML_ERROR_ENTITY_DECLARED_IN_PE"

        * "XML_ERROR_FEATURE_REQUIRES_XML_DTD"

        * "XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING"

        * "XML_ERROR_UNBOUND_PREFIX"

        * "XML_ERROR_UNDECLARING_PREFIX"

        * "XML_ERROR_INCOMPLETE_PE"

        * "XML_ERROR_XML_DECL"

        * "XML_ERROR_TEXT_DECL"

        * "XML_ERROR_PUBLICID"

        * "XML_ERROR_SUSPENDED"

        * "XML_ERROR_NOT_SUSPENDED"

        * "XML_ERROR_ABORTED"

        * "XML_ERROR_FINISHED"

        * "XML_ERROR_SUSPEND_PE"

        * "XML_ERROR_RESERVED_PREFIX_XML"

        * "XML_ERROR_RESERVED_PREFIX_XMLNS"

        * "XML_ERROR_RESERVED_NAMESPACE_URI"

        * "XML_ERROR_INVALID_ARGUMENT"

        * "XML_ERROR_NO_BUFFER"

        * "XML_ERROR_AMPLIFICATION_LIMIT_BREACH"

  * Internet Protocols and Support

    * "webbrowser" --- Convenient web-browser controller

      * "Error"

      * "open()"

      * "open_new()"

      * "open_new_tab()"

      * "get()"

      * "register()"

      * Browser Controller Objects

        * "controller.name"

        * "controller.open()"

        * "controller.open_new()"

        * "controller.open_new_tab()"

    * "wsgiref" --- WSGI Utilities and Reference Implementation

      * "wsgiref.util" -- WSGI environment utilities

        * "guess_scheme()"

        * "request_uri()"

        * "application_uri()"

        * "shift_path_info()"

        * "setup_testing_defaults()"

        * "is_hop_by_hop()"

        * "FileWrapper"

      * "wsgiref.headers" -- WSGI response header tools

        * "Headers"

          * "Headers.get_all()"

          * "Headers.add_header()"

      * "wsgiref.simple_server" -- a simple WSGI HTTP server

        * "make_server()"

        * "demo_app()"

        * "WSGIServer"

          * "WSGIServer.set_app()"

          * "WSGIServer.get_app()"

        * "WSGIRequestHandler"

          * "WSGIRequestHandler.get_environ()"

          * "WSGIRequestHandler.get_stderr()"

          * "WSGIRequestHandler.handle()"

      * "wsgiref.validate" --- WSGI conformance checker

        * "validator()"

      * "wsgiref.handlers" -- server/gateway base classes

        * "CGIHandler"

        * "IISCGIHandler"

        * "BaseCGIHandler"

        * "SimpleHandler"

        * "BaseHandler"

          * "BaseHandler.run()"

          * "BaseHandler._write()"

          * "BaseHandler._flush()"

          * "BaseHandler.get_stdin()"

          * "BaseHandler.get_stderr()"

          * "BaseHandler.add_cgi_vars()"

          * "BaseHandler.wsgi_multithread"

          * "BaseHandler.wsgi_multiprocess"

          * "BaseHandler.wsgi_run_once"

          * "BaseHandler.os_environ"

          * "BaseHandler.server_software"

          * "BaseHandler.get_scheme()"

          * "BaseHandler.setup_environ()"

          * "BaseHandler.log_exception()"

          * "BaseHandler.traceback_limit"

          * "BaseHandler.error_output()"

          * "BaseHandler.error_status"

          * "BaseHandler.error_headers"

          * "BaseHandler.error_body"

          * "BaseHandler.wsgi_file_wrapper"

          * "BaseHandler.sendfile()"

          * "BaseHandler.origin_server"

          * "BaseHandler.http_version"

        * "read_environ()"

      * "wsgiref.types" -- WSGI types for static type checking

        * "StartResponse"

        * "WSGIEnvironment"

        * "WSGIApplication"

        * "InputStream"

        * "ErrorStream"

        * "FileWrapper"

      * Examples

    * "urllib" --- URL handling modules

    * "urllib.request" --- Extensible library for opening URLs

      * "urlopen()"

      * "install_opener()"

      * "build_opener()"

      * "pathname2url()"

      * "url2pathname()"

      * "getproxies()"

      * "Request"

      * "OpenerDirector"

      * "BaseHandler"

      * "HTTPDefaultErrorHandler"

      * "HTTPRedirectHandler"

      * "HTTPCookieProcessor"

      * "ProxyHandler"

      * "HTTPPasswordMgr"

      * "HTTPPasswordMgrWithDefaultRealm"

      * "HTTPPasswordMgrWithPriorAuth"

      * "AbstractBasicAuthHandler"

      * "HTTPBasicAuthHandler"

      * "ProxyBasicAuthHandler"

      * "AbstractDigestAuthHandler"

      * "HTTPDigestAuthHandler"

      * "ProxyDigestAuthHandler"

      * "HTTPHandler"

      * "HTTPSHandler"

      * "FileHandler"

      * "DataHandler"

      * "FTPHandler"

      * "CacheFTPHandler"

      * "UnknownHandler"

      * "HTTPErrorProcessor"

      * Request Objects

        * "Request.full_url"

        * "Request.type"

        * "Request.host"

        * "Request.origin_req_host"

        * "Request.selector"

        * "Request.data"

        * "Request.unverifiable"

        * "Request.method"

        * "Request.get_method()"

        * "Request.add_header()"

        * "Request.add_unredirected_header()"

        * "Request.has_header()"

        * "Request.remove_header()"

        * "Request.get_full_url()"

        * "Request.set_proxy()"

        * "Request.get_header()"

        * "Request.header_items()"

      * OpenerDirector Objects

        * "OpenerDirector.add_handler()"

        * "OpenerDirector.open()"

        * "OpenerDirector.error()"

      * BaseHandler Objects

        * "BaseHandler.add_parent()"

        * "BaseHandler.close()"

        * "BaseHandler.parent"

        * "BaseHandler.default_open()"

        * "BaseHandler.unknown_open()"

        * "BaseHandler.http_error_default()"

      * HTTPRedirectHandler Objects

        * "HTTPRedirectHandler.redirect_request()"

        * "HTTPRedirectHandler.http_error_301()"

        * "HTTPRedirectHandler.http_error_302()"

        * "HTTPRedirectHandler.http_error_303()"

        * "HTTPRedirectHandler.http_error_307()"

        * "HTTPRedirectHandler.http_error_308()"

      * HTTPCookieProcessor Objects

        * "HTTPCookieProcessor.cookiejar"

      * ProxyHandler Objects

      * HTTPPasswordMgr Objects

        * "HTTPPasswordMgr.add_password()"

        * "HTTPPasswordMgr.find_user_password()"

      * HTTPPasswordMgrWithPriorAuth Objects

        * "HTTPPasswordMgrWithPriorAuth.add_password()"

        * "HTTPPasswordMgrWithPriorAuth.find_user_password()"

        * "HTTPPasswordMgrWithPriorAuth.update_authenticated()"

        * "HTTPPasswordMgrWithPriorAuth.is_authenticated()"

      * AbstractBasicAuthHandler Objects

        * "AbstractBasicAuthHandler.http_error_auth_reqed()"

      * HTTPBasicAuthHandler Objects

        * "HTTPBasicAuthHandler.http_error_401()"

      * ProxyBasicAuthHandler Objects

        * "ProxyBasicAuthHandler.http_error_407()"

      * AbstractDigestAuthHandler Objects

        * "AbstractDigestAuthHandler.http_error_auth_reqed()"

      * HTTPDigestAuthHandler Objects

        * "HTTPDigestAuthHandler.http_error_401()"

      * ProxyDigestAuthHandler Objects

        * "ProxyDigestAuthHandler.http_error_407()"

      * HTTPHandler Objects

        * "HTTPHandler.http_open()"

      * HTTPSHandler Objects

        * "HTTPSHandler.https_open()"

      * FileHandler Objects

        * "FileHandler.file_open()"

      * DataHandler Objects

        * "DataHandler.data_open()"

      * FTPHandler Objects

        * "FTPHandler.ftp_open()"

      * CacheFTPHandler Objects

        * "CacheFTPHandler.setTimeout()"

        * "CacheFTPHandler.setMaxConns()"

      * UnknownHandler Objects

        * "UnknownHandler.unknown_open()"

      * HTTPErrorProcessor Objects

        * "HTTPErrorProcessor.http_response()"

        * "HTTPErrorProcessor.https_response()"

      * Examples

      * Legacy interface

        * "urlretrieve()"

        * "urlcleanup()"

        * "URLopener"

          * "URLopener.open()"

          * "URLopener.open_unknown()"

          * "URLopener.retrieve()"

          * "URLopener.version"

        * "FancyURLopener"

          * "FancyURLopener.prompt_user_passwd()"

      * "urllib.request" Restrictions

    * "urllib.response" --- Response classes used by urllib

      * "addinfourl"

        * "addinfourl.url"

        * "addinfourl.headers"

        * "addinfourl.status"

        * "addinfourl.geturl()"

        * "addinfourl.info()"

        * "addinfourl.code"

        * "addinfourl.getcode()"

    * "urllib.parse" --- Parse URLs into components

      * URL Parsing

        * "urlparse()"

        * "parse_qs()"

        * "parse_qsl()"

        * "urlunparse()"

        * "urlsplit()"

        * "urlunsplit()"

        * "urljoin()"

        * "urldefrag()"

        * "unwrap()"

      * URL parsing security

      * Parsing ASCII Encoded Bytes

      * Structured Parse Results

        * "urllib.parse.SplitResult.geturl()"

        * "DefragResult"

        * "ParseResult"

        * "SplitResult"

        * "DefragResultBytes"

        * "ParseResultBytes"

        * "SplitResultBytes"

      * URL Quoting

        * "quote()"

        * "quote_plus()"

        * "quote_from_bytes()"

        * "unquote()"

        * "unquote_plus()"

        * "unquote_to_bytes()"

        * "urlencode()"

    * "urllib.error" --- Exception classes raised by urllib.request

      * "URLError"

        * "URLError.reason"

      * "HTTPError"

        * "HTTPError.url"

        * "HTTPError.code"

        * "HTTPError.reason"

        * "HTTPError.headers"

        * "HTTPError.fp"

      * "ContentTooShortError"

        * "ContentTooShortError.content"

    * "urllib.robotparser" ---  Parser for robots.txt

      * "RobotFileParser"

        * "RobotFileParser.set_url()"

        * "RobotFileParser.read()"

        * "RobotFileParser.parse()"

        * "RobotFileParser.can_fetch()"

        * "RobotFileParser.mtime()"

        * "RobotFileParser.modified()"

        * "RobotFileParser.crawl_delay()"

        * "RobotFileParser.request_rate()"

        * "RobotFileParser.site_maps()"

    * "http" --- HTTP modules

      * "HTTPStatus"

      * HTTP status codes

      * HTTP status category

        * "HTTPMethod"

      * HTTP methods

    * "http.client" --- HTTP protocol client

      * "HTTPConnection"

      * "HTTPSConnection"

      * "HTTPResponse"

      * "parse_headers()"

      * "HTTPException"

      * "NotConnected"

      * "InvalidURL"

      * "UnknownProtocol"

      * "UnknownTransferEncoding"

      * "UnimplementedFileMode"

      * "IncompleteRead"

      * "ImproperConnectionState"

      * "CannotSendRequest"

      * "CannotSendHeader"

      * "ResponseNotReady"

      * "BadStatusLine"

      * "LineTooLong"

      * "RemoteDisconnected"

      * "HTTP_PORT"

      * "HTTPS_PORT"

      * "responses"

      * HTTPConnection Objects

        * "HTTPConnection.request()"

        * "HTTPConnection.getresponse()"

        * "HTTPConnection.set_debuglevel()"

        * "HTTPConnection.set_tunnel()"

        * "HTTPConnection.get_proxy_response_headers()"

        * "HTTPConnection.connect()"

        * "HTTPConnection.close()"

        * "HTTPConnection.blocksize"

        * "HTTPConnection.putrequest()"

        * "HTTPConnection.putheader()"

        * "HTTPConnection.endheaders()"

        * "HTTPConnection.send()"

      * HTTPResponse Objects

        * "HTTPResponse.read()"

        * "HTTPResponse.readinto()"

        * "HTTPResponse.getheader()"

        * "HTTPResponse.getheaders()"

        * "HTTPResponse.fileno()"

        * "HTTPResponse.msg"

        * "HTTPResponse.version"

        * "HTTPResponse.url"

        * "HTTPResponse.headers"

        * "HTTPResponse.status"

        * "HTTPResponse.reason"

        * "HTTPResponse.debuglevel"

        * "HTTPResponse.closed"

        * "HTTPResponse.geturl()"

        * "HTTPResponse.info()"

        * "HTTPResponse.getcode()"

      * Examples

      * HTTPMessage Objects

    * "ftplib" --- FTP protocol client

      * "FTP"

      * "error_reply"

      * "error_temp"

      * "error_perm"

      * "error_proto"

      * "all_errors"

      * FTP Objects

        * "FTP.set_debuglevel()"

        * "FTP.connect()"

        * "FTP.getwelcome()"

        * "FTP.login()"

        * "FTP.abort()"

        * "FTP.sendcmd()"

        * "FTP.voidcmd()"

        * "FTP.retrbinary()"

        * "FTP.retrlines()"

        * "FTP.set_pasv()"

        * "FTP.storbinary()"

        * "FTP.storlines()"

        * "FTP.transfercmd()"

        * "FTP.ntransfercmd()"

        * "FTP.mlsd()"

        * "FTP.nlst()"

        * "FTP.dir()"

        * "FTP.rename()"

        * "FTP.delete()"

        * "FTP.cwd()"

        * "FTP.mkd()"

        * "FTP.pwd()"

        * "FTP.rmd()"

        * "FTP.size()"

        * "FTP.quit()"

        * "FTP.close()"

      * FTP_TLS Objects

        * "FTP_TLS.ssl_version"

        * "FTP_TLS.auth()"

        * "FTP_TLS.ccc()"

        * "FTP_TLS.prot_p()"

        * "FTP_TLS.prot_c()"

    * "poplib" --- POP3 protocol client

      * "POP3"

      * "POP3_SSL"

      * "error_proto"

      * POP3 Objects

        * "POP3.set_debuglevel()"

        * "POP3.getwelcome()"

        * "POP3.capa()"

        * "POP3.user()"

        * "POP3.pass_()"

        * "POP3.apop()"

        * "POP3.rpop()"

        * "POP3.stat()"

        * "POP3.list()"

        * "POP3.retr()"

        * "POP3.dele()"

        * "POP3.rset()"

        * "POP3.noop()"

        * "POP3.quit()"

        * "POP3.top()"

        * "POP3.uidl()"

        * "POP3.utf8()"

        * "POP3.stls()"

      * POP3 Example

    * "imaplib" --- IMAP4 protocol client

      * "IMAP4"

        * "IMAP4.error"

        * "IMAP4.abort"

        * "IMAP4.readonly"

      * "IMAP4_SSL"

      * "IMAP4_stream"

      * "Internaldate2tuple()"

      * "Int2AP()"

      * "ParseFlags()"

      * "Time2Internaldate()"

      * IMAP4 Objects

        * "IMAP4.append()"

        * "IMAP4.authenticate()"

        * "IMAP4.check()"

        * "IMAP4.close()"

        * "IMAP4.copy()"

        * "IMAP4.create()"

        * "IMAP4.delete()"

        * "IMAP4.deleteacl()"

        * "IMAP4.enable()"

        * "IMAP4.expunge()"

        * "IMAP4.fetch()"

        * "IMAP4.getacl()"

        * "IMAP4.getannotation()"

        * "IMAP4.getquota()"

        * "IMAP4.getquotaroot()"

        * "IMAP4.list()"

        * "IMAP4.login()"

        * "IMAP4.login_cram_md5()"

        * "IMAP4.logout()"

        * "IMAP4.lsub()"

        * "IMAP4.myrights()"

        * "IMAP4.namespace()"

        * "IMAP4.noop()"

        * "IMAP4.open()"

        * "IMAP4.partial()"

        * "IMAP4.proxyauth()"

        * "IMAP4.read()"

        * "IMAP4.readline()"

        * "IMAP4.recent()"

        * "IMAP4.rename()"

        * "IMAP4.response()"

        * "IMAP4.search()"

        * "IMAP4.select()"

        * "IMAP4.send()"

        * "IMAP4.setacl()"

        * "IMAP4.setannotation()"

        * "IMAP4.setquota()"

        * "IMAP4.shutdown()"

        * "IMAP4.socket()"

        * "IMAP4.sort()"

        * "IMAP4.starttls()"

        * "IMAP4.status()"

        * "IMAP4.store()"

        * "IMAP4.subscribe()"

        * "IMAP4.thread()"

        * "IMAP4.uid()"

        * "IMAP4.unsubscribe()"

        * "IMAP4.unselect()"

        * "IMAP4.xatom()"

        * "IMAP4.PROTOCOL_VERSION"

        * "IMAP4.debug"

        * "IMAP4.utf8_enabled"

      * IMAP4 Example

    * "smtplib" --- SMTP protocol client

      * "SMTP"

      * "SMTP_SSL"

      * "LMTP"

      * "SMTPException"

      * "SMTPServerDisconnected"

      * "SMTPResponseException"

      * "SMTPSenderRefused"

      * "SMTPRecipientsRefused"

      * "SMTPDataError"

      * "SMTPConnectError"

      * "SMTPHeloError"

      * "SMTPNotSupportedError"

      * "SMTPAuthenticationError"

      * SMTP Objects

        * "SMTP.set_debuglevel()"

        * "SMTP.docmd()"

        * "SMTP.connect()"

        * "SMTP.helo()"

        * "SMTP.ehlo()"

        * "SMTP.ehlo_or_helo_if_needed()"

        * "SMTP.has_extn()"

        * "SMTP.verify()"

        * "SMTP.login()"

        * "SMTP.auth()"

        * "SMTP.starttls()"

        * "SMTP.sendmail()"

        * "SMTP.send_message()"

        * "SMTP.quit()"

      * SMTP Example

    * "uuid" --- UUID objects according to **RFC 4122**

      * "SafeUUID"

        * "SafeUUID.safe"

        * "SafeUUID.unsafe"

        * "SafeUUID.unknown"

      * "UUID"

        * "UUID.bytes"

        * "UUID.bytes_le"

        * "UUID.fields"

        * "UUID.time_low"

        * "UUID.time_mid"

        * "UUID.time_hi_version"

        * "UUID.clock_seq_hi_variant"

        * "UUID.clock_seq_low"

        * "UUID.node"

        * "UUID.time"

        * "UUID.clock_seq"

        * "UUID.hex"

        * "UUID.int"

        * "UUID.urn"

        * "UUID.variant"

        * "UUID.version"

        * "UUID.is_safe"

      * "getnode()"

      * "uuid1()"

      * "uuid3()"

      * "uuid4()"

      * "uuid5()"

      * "NAMESPACE_DNS"

      * "NAMESPACE_URL"

      * "NAMESPACE_OID"

      * "NAMESPACE_X500"

      * "RESERVED_NCS"

      * "RFC_4122"

      * "RESERVED_MICROSOFT"

      * "RESERVED_FUTURE"

      * Command-Line Usage

      * Example

      * Command-Line Example

    * "socketserver" --- A framework for network servers

      * "TCPServer"

      * "UDPServer"

      * "UnixStreamServer"

      * "UnixDatagramServer"

      * Server Creation Notes

        * "ForkingMixIn"

        * "ThreadingMixIn"

          * "ThreadingMixIn.block_on_close"

          * "ThreadingMixIn.daemon_threads"

        * "ForkingTCPServer"

        * "ForkingUDPServer"

        * "ThreadingTCPServer"

        * "ThreadingUDPServer"

        * "ForkingUnixStreamServer"

        * "ForkingUnixDatagramServer"

        * "ThreadingUnixStreamServer"

        * "ThreadingUnixDatagramServer"

      * Server Objects

        * "BaseServer"

          * "BaseServer.fileno()"

          * "BaseServer.handle_request()"

          * "BaseServer.serve_forever()"

          * "BaseServer.service_actions()"

          * "BaseServer.shutdown()"

          * "BaseServer.server_close()"

          * "BaseServer.address_family"

          * "BaseServer.RequestHandlerClass"

          * "BaseServer.server_address"

          * "BaseServer.socket"

          * "BaseServer.allow_reuse_address"

          * "BaseServer.request_queue_size"

          * "BaseServer.socket_type"

          * "BaseServer.timeout"

          * "BaseServer.finish_request()"

          * "BaseServer.get_request()"

          * "BaseServer.handle_error()"

          * "BaseServer.handle_timeout()"

          * "BaseServer.process_request()"

          * "BaseServer.server_activate()"

          * "BaseServer.server_bind()"

          * "BaseServer.verify_request()"

      * Request Handler Objects

        * "BaseRequestHandler"

          * "BaseRequestHandler.setup()"

          * "BaseRequestHandler.handle()"

          * "BaseRequestHandler.finish()"

          * "BaseRequestHandler.request"

          * "BaseRequestHandler.client_address"

          * "BaseRequestHandler.server"

        * "StreamRequestHandler"

        * "DatagramRequestHandler"

          * "DatagramRequestHandler.rfile"

          * "DatagramRequestHandler.wfile"

      * Examples

        * "socketserver.TCPServer" Example

        * "socketserver.UDPServer" Example

        * Asynchronous Mixins

    * "http.server" --- HTTP servers

      * "HTTPServer"

      * "ThreadingHTTPServer"

      * "BaseHTTPRequestHandler"

        * "BaseHTTPRequestHandler.client_address"

        * "BaseHTTPRequestHandler.server"

        * "BaseHTTPRequestHandler.close_connection"

        * "BaseHTTPRequestHandler.requestline"

        * "BaseHTTPRequestHandler.command"

        * "BaseHTTPRequestHandler.path"

        * "BaseHTTPRequestHandler.request_version"

        * "BaseHTTPRequestHandler.headers"

        * "BaseHTTPRequestHandler.rfile"

        * "BaseHTTPRequestHandler.wfile"

        * "BaseHTTPRequestHandler.server_version"

        * "BaseHTTPRequestHandler.sys_version"

        * "BaseHTTPRequestHandler.error_message_format"

        * "BaseHTTPRequestHandler.error_content_type"

        * "BaseHTTPRequestHandler.protocol_version"

        * "BaseHTTPRequestHandler.MessageClass"

        * "BaseHTTPRequestHandler.responses"

        * "BaseHTTPRequestHandler.handle()"

        * "BaseHTTPRequestHandler.handle_one_request()"

        * "BaseHTTPRequestHandler.handle_expect_100()"

        * "BaseHTTPRequestHandler.send_error()"

        * "BaseHTTPRequestHandler.send_response()"

        * "BaseHTTPRequestHandler.send_header()"

        * "BaseHTTPRequestHandler.send_response_only()"

        * "BaseHTTPRequestHandler.end_headers()"

        * "BaseHTTPRequestHandler.flush_headers()"

        * "BaseHTTPRequestHandler.log_request()"

        * "BaseHTTPRequestHandler.log_error()"

        * "BaseHTTPRequestHandler.log_message()"

        * "BaseHTTPRequestHandler.version_string()"

        * "BaseHTTPRequestHandler.date_time_string()"

        * "BaseHTTPRequestHandler.log_date_time_string()"

        * "BaseHTTPRequestHandler.address_string()"

      * "SimpleHTTPRequestHandler"

        * "SimpleHTTPRequestHandler.server_version"

        * "SimpleHTTPRequestHandler.extensions_map"

        * "SimpleHTTPRequestHandler.do_HEAD()"

        * "SimpleHTTPRequestHandler.do_GET()"

      * "CGIHTTPRequestHandler"

        * "CGIHTTPRequestHandler.cgi_directories"

        * "CGIHTTPRequestHandler.do_POST()"

      * Security Considerations

    * "http.cookies" --- HTTP state management

      * "CookieError"

      * "BaseCookie"

      * "SimpleCookie"

      * Cookie Objects

        * "BaseCookie.value_decode()"

        * "BaseCookie.value_encode()"

        * "BaseCookie.output()"

        * "BaseCookie.js_output()"

        * "BaseCookie.load()"

      * Morsel Objects

        * "Morsel"

          * "Morsel.value"

          * "Morsel.coded_value"

          * "Morsel.key"

          * "Morsel.set()"

          * "Morsel.isReservedKey()"

          * "Morsel.output()"

          * "Morsel.js_output()"

          * "Morsel.OutputString()"

          * "Morsel.update()"

          * "Morsel.copy()"

          * "Morsel.setdefault()"

      * Example

    * "http.cookiejar" --- Cookie handling for HTTP clients

      * "LoadError"

      * "CookieJar"

      * "FileCookieJar"

      * "CookiePolicy"

      * "DefaultCookiePolicy"

      * "Cookie"

      * CookieJar and FileCookieJar Objects

        * "CookieJar.add_cookie_header()"

        * "CookieJar.extract_cookies()"

        * "CookieJar.set_policy()"

        * "CookieJar.make_cookies()"

        * "CookieJar.set_cookie_if_ok()"

        * "CookieJar.set_cookie()"

        * "CookieJar.clear()"

        * "CookieJar.clear_session_cookies()"

        * "FileCookieJar.save()"

        * "FileCookieJar.load()"

        * "FileCookieJar.revert()"

        * "FileCookieJar.filename"

        * "FileCookieJar.delayload"

      * FileCookieJar subclasses and co-operation with web browsers

        * "MozillaCookieJar"

        * "LWPCookieJar"

      * CookiePolicy Objects

        * "CookiePolicy.set_ok()"

        * "CookiePolicy.return_ok()"

        * "CookiePolicy.domain_return_ok()"

        * "CookiePolicy.path_return_ok()"

        * "CookiePolicy.netscape"

        * "CookiePolicy.rfc2965"

        * "CookiePolicy.hide_cookie2"

      * DefaultCookiePolicy Objects

        * "DefaultCookiePolicy.blocked_domains()"

        * "DefaultCookiePolicy.set_blocked_domains()"

        * "DefaultCookiePolicy.is_blocked()"

        * "DefaultCookiePolicy.allowed_domains()"

        * "DefaultCookiePolicy.set_allowed_domains()"

        * "DefaultCookiePolicy.is_not_allowed()"

        * "DefaultCookiePolicy.rfc2109_as_netscape"

        * "DefaultCookiePolicy.strict_domain"

        * "DefaultCookiePolicy.strict_rfc2965_unverifiable"

        * "DefaultCookiePolicy.strict_ns_unverifiable"

        * "DefaultCookiePolicy.strict_ns_domain"

        * "DefaultCookiePolicy.strict_ns_set_initial_dollar"

        * "DefaultCookiePolicy.strict_ns_set_path"

        * "DefaultCookiePolicy.DomainStrictNoDots"

        * "DefaultCookiePolicy.DomainStrictNonDomain"

        * "DefaultCookiePolicy.DomainRFC2965Match"

        * "DefaultCookiePolicy.DomainLiberal"

        * "DefaultCookiePolicy.DomainStrict"

      * Cookie Objects

        * "Cookie.version"

        * "Cookie.name"

        * "Cookie.value"

        * "Cookie.port"

        * "Cookie.path"

        * "Cookie.secure"

        * "Cookie.expires"

        * "Cookie.discard"

        * "Cookie.comment"

        * "Cookie.comment_url"

        * "Cookie.rfc2109"

        * "Cookie.port_specified"

        * "Cookie.domain_specified"

        * "Cookie.domain_initial_dot"

        * "Cookie.has_nonstandard_attr()"

        * "Cookie.get_nonstandard_attr()"

        * "Cookie.set_nonstandard_attr()"

        * "Cookie.is_expired()"

      * Examples

    * "xmlrpc" --- XMLRPC server and client modules

    * "xmlrpc.client" --- XML-RPC client access

      * "ServerProxy"

      * ServerProxy Objects

        * "ServerProxy.system.listMethods()"

        * "ServerProxy.system.methodSignature()"

        * "ServerProxy.system.methodHelp()"

      * DateTime Objects

        * "DateTime"

          * "DateTime.decode()"

          * "DateTime.encode()"

      * Binary Objects

        * "Binary"

          * "Binary.data"

          * "Binary.decode()"

          * "Binary.encode()"

      * Fault Objects

        * "Fault"

          * "Fault.faultCode"

          * "Fault.faultString"

      * ProtocolError Objects

        * "ProtocolError"

          * "ProtocolError.url"

          * "ProtocolError.errcode"

          * "ProtocolError.errmsg"

          * "ProtocolError.headers"

      * MultiCall Objects

        * "MultiCall"

      * Convenience Functions

        * "dumps()"

        * "loads()"

      * Example of Client Usage

      * Example of Client and Server Usage

    * "xmlrpc.server" --- Basic XML-RPC servers

      * "SimpleXMLRPCServer"

      * "CGIXMLRPCRequestHandler"

      * "SimpleXMLRPCRequestHandler"

      * SimpleXMLRPCServer Objects

        * "SimpleXMLRPCServer.register_function()"

        * "SimpleXMLRPCServer.register_instance()"

        * "SimpleXMLRPCServer.register_introspection_functions()"

        * "SimpleXMLRPCServer.register_multicall_functions()"

        * "SimpleXMLRPCRequestHandler.rpc_paths"

        * SimpleXMLRPCServer Example

      * CGIXMLRPCRequestHandler

        * "CGIXMLRPCRequestHandler.register_function()"

        * "CGIXMLRPCRequestHandler.register_instance()"

        * "CGIXMLRPCRequestHandler.register_introspection_functions()"

        * "CGIXMLRPCRequestHandler.register_multicall_functions()"

        * "CGIXMLRPCRequestHandler.handle_request()"

      * Documenting XMLRPC server

        * "DocXMLRPCServer"

        * "DocCGIXMLRPCRequestHandler"

        * "DocXMLRPCRequestHandler"

      * DocXMLRPCServer Objects

        * "DocXMLRPCServer.set_server_title()"

        * "DocXMLRPCServer.set_server_name()"

        * "DocXMLRPCServer.set_server_documentation()"

      * DocCGIXMLRPCRequestHandler

        * "DocCGIXMLRPCRequestHandler.set_server_title()"

        * "DocCGIXMLRPCRequestHandler.set_server_name()"

        * "DocCGIXMLRPCRequestHandler.set_server_documentation()"

    * "ipaddress" --- IPv4/IPv6 manipulation library

      * Convenience factory functions

        * "ip_address()"

        * "ip_network()"

        * "ip_interface()"

      * IP Addresses

        * Address objects

          * "IPv4Address"

            * "IPv4Address.version"

            * "IPv4Address.max_prefixlen"

            * "IPv4Address.compressed"

            * "IPv4Address.exploded"

            * "IPv4Address.packed"

            * "IPv4Address.reverse_pointer"

            * "IPv4Address.is_multicast"

            * "IPv4Address.is_private"

            * "IPv4Address.is_global"

            * "IPv4Address.is_unspecified"

            * "IPv4Address.is_reserved"

            * "IPv4Address.is_loopback"

            * "IPv4Address.is_link_local"

            * "IPv4Address.__format__()"

          * "IPv6Address"

            * "IPv6Address.compressed"

            * "IPv6Address.exploded"

            * "IPv6Address.packed"

            * "IPv6Address.reverse_pointer"

            * "IPv6Address.version"

            * "IPv6Address.max_prefixlen"

            * "IPv6Address.is_multicast"

            * "IPv6Address.is_private"

            * "IPv6Address.is_global"

            * "IPv6Address.is_unspecified"

            * "IPv6Address.is_reserved"

            * "IPv6Address.is_loopback"

            * "IPv6Address.is_link_local"

            * "IPv6Address.is_site_local"

            * "IPv6Address.ipv4_mapped"

            * "IPv6Address.scope_id"

            * "IPv6Address.sixtofour"

            * "IPv6Address.teredo"

            * "IPv6Address.__format__()"

        * Conversion to Strings and Integers

        * Operators

          * Comparison operators

          * Arithmetic operators

      * IP Network definitions

        * Prefix, net mask and host mask

        * Network objects

          * "IPv4Network"

            * "IPv4Network.version"

            * "IPv4Network.max_prefixlen"

            * "IPv4Network.is_multicast"

            * "IPv4Network.is_private"

            * "IPv4Network.is_unspecified"

            * "IPv4Network.is_reserved"

            * "IPv4Network.is_loopback"

            * "IPv4Network.is_link_local"

            * "IPv4Network.network_address"

            * "IPv4Network.broadcast_address"

            * "IPv4Network.hostmask"

            * "IPv4Network.netmask"

            * "IPv4Network.with_prefixlen"

            * "IPv4Network.compressed"

            * "IPv4Network.exploded"

            * "IPv4Network.with_netmask"

            * "IPv4Network.with_hostmask"

            * "IPv4Network.num_addresses"

            * "IPv4Network.prefixlen"

            * "IPv4Network.hosts()"

            * "IPv4Network.overlaps()"

            * "IPv4Network.address_exclude()"

            * "IPv4Network.subnets()"

            * "IPv4Network.supernet()"

            * "IPv4Network.subnet_of()"

            * "IPv4Network.supernet_of()"

            * "IPv4Network.compare_networks()"

          * "IPv6Network"

            * "IPv6Network.version"

            * "IPv6Network.max_prefixlen"

            * "IPv6Network.is_multicast"

            * "IPv6Network.is_private"

            * "IPv6Network.is_unspecified"

            * "IPv6Network.is_reserved"

            * "IPv6Network.is_loopback"

            * "IPv6Network.is_link_local"

            * "IPv6Network.network_address"

            * "IPv6Network.broadcast_address"

            * "IPv6Network.hostmask"

            * "IPv6Network.netmask"

            * "IPv6Network.with_prefixlen"

            * "IPv6Network.compressed"

            * "IPv6Network.exploded"

            * "IPv6Network.with_netmask"

            * "IPv6Network.with_hostmask"

            * "IPv6Network.num_addresses"

            * "IPv6Network.prefixlen"

            * "IPv6Network.hosts()"

            * "IPv6Network.overlaps()"

            * "IPv6Network.address_exclude()"

            * "IPv6Network.subnets()"

            * "IPv6Network.supernet()"

            * "IPv6Network.subnet_of()"

            * "IPv6Network.supernet_of()"

            * "IPv6Network.compare_networks()"

            * "IPv6Network.is_site_local"

        * Operators

          * Logical operators

          * Iteration

          * Networks as containers of addresses

      * Interface objects

        * "IPv4Interface"

          * "IPv4Interface.ip"

          * "IPv4Interface.network"

          * "IPv4Interface.with_prefixlen"

          * "IPv4Interface.with_netmask"

          * "IPv4Interface.with_hostmask"

        * "IPv6Interface"

          * "IPv6Interface.ip"

          * "IPv6Interface.network"

          * "IPv6Interface.with_prefixlen"

          * "IPv6Interface.with_netmask"

          * "IPv6Interface.with_hostmask"

        * Operators

          * Logical operators

      * Other Module Level Functions

        * "v4_int_to_packed()"

        * "v6_int_to_packed()"

        * "summarize_address_range()"

        * "collapse_addresses()"

        * "get_mixed_type_key()"

      * Custom Exceptions

        * "AddressValueError"

        * "NetmaskValueError"

  * Multimedia Services

    * "wave" --- Read and write WAV files

      * "open()"

      * "Error"

      * Wave_read Objects

        * "Wave_read"

          * "Wave_read.close()"

          * "Wave_read.getnchannels()"

          * "Wave_read.getsampwidth()"

          * "Wave_read.getframerate()"

          * "Wave_read.getnframes()"

          * "Wave_read.getcomptype()"

          * "Wave_read.getcompname()"

          * "Wave_read.getparams()"

          * "Wave_read.readframes()"

          * "Wave_read.rewind()"

          * "Wave_read.getmarkers()"

          * "Wave_read.getmark()"

          * "Wave_read.setpos()"

          * "Wave_read.tell()"

      * Wave_write Objects

        * "Wave_write"

          * "Wave_write.close()"

          * "Wave_write.setnchannels()"

          * "Wave_write.setsampwidth()"

          * "Wave_write.setframerate()"

          * "Wave_write.setnframes()"

          * "Wave_write.setcomptype()"

          * "Wave_write.setparams()"

          * "Wave_write.tell()"

          * "Wave_write.writeframesraw()"

          * "Wave_write.writeframes()"

    * "colorsys" --- Conversions between color systems

      * "rgb_to_yiq()"

      * "yiq_to_rgb()"

      * "rgb_to_hls()"

      * "hls_to_rgb()"

      * "rgb_to_hsv()"

      * "hsv_to_rgb()"

  * Internationalization

    * "gettext" --- Multilingual internationalization services

      * GNU **gettext** API

        * "bindtextdomain()"

        * "textdomain()"

        * "gettext()"

        * "dgettext()"

        * "ngettext()"

        * "dngettext()"

        * "pgettext()"

        * "dpgettext()"

        * "npgettext()"

        * "dnpgettext()"

      * Class-based API

        * "find()"

        * "translation()"

        * "install()"

        * The "NullTranslations" class

          * "NullTranslations"

            * "NullTranslations._parse()"

            * "NullTranslations.add_fallback()"

            * "NullTranslations.gettext()"

            * "NullTranslations.ngettext()"

            * "NullTranslations.pgettext()"

            * "NullTranslations.npgettext()"

            * "NullTranslations.info()"

            * "NullTranslations.charset()"

            * "NullTranslations.install()"

        * The "GNUTranslations" class

          * "GNUTranslations"

            * "GNUTranslations.gettext()"

            * "GNUTranslations.ngettext()"

            * "GNUTranslations.pgettext()"

            * "GNUTranslations.npgettext()"

        * 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

      * "Error"

      * "setlocale()"

      * "localeconv()"

      * "nl_langinfo()"

      * "CODESET"

      * "D_T_FMT"

      * "D_FMT"

      * "T_FMT"

      * "T_FMT_AMPM"

      * "RADIXCHAR"

      * "THOUSEP"

      * "YESEXPR"

      * "NOEXPR"

      * "CRNCYSTR"

      * "ERA"

      * "ERA_D_T_FMT"

      * "ERA_D_FMT"

      * "ERA_T_FMT"

      * "ALT_DIGITS"

      * "getdefaultlocale()"

      * "getlocale()"

      * "getpreferredencoding()"

      * "getencoding()"

      * "normalize()"

      * "strcoll()"

      * "strxfrm()"

      * "format_string()"

      * "currency()"

      * "str()"

      * "delocalize()"

      * "localize()"

      * "atof()"

      * "atoi()"

      * "LC_CTYPE"

      * "LC_COLLATE"

      * "LC_TIME"

      * "LC_MONETARY"

      * "LC_MESSAGES"

      * "LC_NUMERIC"

      * "LC_ALL"

      * "CHAR_MAX"

      * Background, details, hints, tips and caveats

      * For extension writers and programs that embed Python

      * Access to message catalogs

        * "gettext()"

        * "dgettext()"

        * "dcgettext()"

        * "textdomain()"

        * "bindtextdomain()"

  * Program Frameworks

    * "turtle" --- Turtle graphics

      * Introduction

      * Get started

      * Tutorial

        * Starting a turtle environment

        * Basic drawing

          * Pen control

          * The turtle's position

        * Making algorithmic patterns

      * How to...

        * Get started as quickly as possible

        * Use the "turtle" module namespace

        * Use turtle graphics in a script

        * Use object-oriented turtle graphics

      * Turtle graphics reference

        * Turtle methods

        * Methods of TurtleScreen/Screen

      * Methods of RawTurtle/Turtle and corresponding functions

        * Turtle motion

          * "forward()"

          * "fd()"

          * "back()"

          * "bk()"

          * "backward()"

          * "right()"

          * "rt()"

          * "left()"

          * "lt()"

          * "goto()"

          * "setpos()"

          * "setposition()"

          * "teleport()"

          * "setx()"

          * "sety()"

          * "setheading()"

          * "seth()"

          * "home()"

          * "circle()"

          * "dot()"

          * "stamp()"

          * "clearstamp()"

          * "clearstamps()"

          * "undo()"

          * "speed()"

        * Tell Turtle's state

          * "position()"

          * "pos()"

          * "towards()"

          * "xcor()"

          * "ycor()"

          * "heading()"

          * "distance()"

        * Settings for measurement

          * "degrees()"

          * "radians()"

        * Pen control

          * Drawing state

            * "pendown()"

            * "pd()"

            * "down()"

            * "penup()"

            * "pu()"

            * "up()"

            * "pensize()"

            * "width()"

            * "pen()"

            * "isdown()"

          * Color control

            * "pencolor()"

            * "fillcolor()"

            * "color()"

          * Filling

            * "filling()"

            * "begin_fill()"

            * "end_fill()"

          * More drawing control

            * "reset()"

            * "clear()"

            * "write()"

        * Turtle state

          * Visibility

            * "hideturtle()"

            * "ht()"

            * "showturtle()"

            * "st()"

            * "isvisible()"

          * Appearance

            * "shape()"

            * "resizemode()"

            * "shapesize()"

            * "turtlesize()"

            * "shearfactor()"

            * "tilt()"

            * "tiltangle()"

            * "shapetransform()"

            * "get_shapepoly()"

        * Using events

          * "onrelease()"

          * "ondrag()"

        * Special Turtle methods

          * "begin_poly()"

          * "end_poly()"

          * "get_poly()"

          * "clone()"

          * "getturtle()"

          * "getpen()"

          * "getscreen()"

          * "setundobuffer()"

          * "undobufferentries()"

        * Compound shapes

      * Methods of TurtleScreen/Screen and corresponding functions

        * Window control

          * "bgcolor()"

          * "bgpic()"

          * "clearscreen()"

          * "resetscreen()"

          * "screensize()"

          * "setworldcoordinates()"

        * Animation control

          * "delay()"

          * "tracer()"

          * "update()"

        * Using screen events

          * "listen()"

          * "onkey()"

          * "onkeyrelease()"

          * "onkeypress()"

          * "onclick()"

          * "onscreenclick()"

          * "ontimer()"

          * "mainloop()"

          * "done()"

        * Input methods

          * "textinput()"

          * "numinput()"

        * Settings and special methods

          * "mode()"

          * "colormode()"

          * "getcanvas()"

          * "getshapes()"

          * "register_shape()"

          * "addshape()"

          * "turtles()"

          * "window_height()"

          * "window_width()"

        * Methods specific to Screen, not inherited from TurtleScreen

          * "bye()"

          * "exitonclick()"

          * "setup()"

          * "title()"

      * Public classes

        * "RawTurtle"

        * "RawPen"

        * "Turtle"

        * "TurtleScreen"

        * "Screen"

        * "ScrolledCanvas"

        * "Shape"

          * "Shape.addcomponent()"

        * "Vec2D"

      * Explanation

      * Help and configuration

        * How to use help

        * Translation of docstrings into different languages

          * "write_docstringdict()"

        * 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"

      * Cmd Objects

        * "Cmd.cmdloop()"

        * "Cmd.onecmd()"

        * "Cmd.emptyline()"

        * "Cmd.default()"

        * "Cmd.completedefault()"

        * "Cmd.columnize()"

        * "Cmd.precmd()"

        * "Cmd.postcmd()"

        * "Cmd.preloop()"

        * "Cmd.postloop()"

        * "Cmd.prompt"

        * "Cmd.identchars"

        * "Cmd.lastcmd"

        * "Cmd.cmdqueue"

        * "Cmd.intro"

        * "Cmd.doc_header"

        * "Cmd.misc_header"

        * "Cmd.undoc_header"

        * "Cmd.ruler"

        * "Cmd.use_rawinput"

      * Cmd Example

    * "shlex" --- Simple lexical analysis

      * "split()"

      * "join()"

      * "quote()"

      * "shlex"

      * shlex Objects

        * "shlex.get_token()"

        * "shlex.push_token()"

        * "shlex.read_token()"

        * "shlex.sourcehook()"

        * "shlex.push_source()"

        * "shlex.pop_source()"

        * "shlex.error_leader()"

        * "shlex.commenters"

        * "shlex.wordchars"

        * "shlex.whitespace"

        * "shlex.escape"

        * "shlex.quotes"

        * "shlex.escapedquotes"

        * "shlex.whitespace_split"

        * "shlex.infile"

        * "shlex.instream"

        * "shlex.source"

        * "shlex.debug"

        * "shlex.lineno"

        * "shlex.token"

        * "shlex.eof"

        * "shlex.punctuation_chars"

      * Parsing Rules

      * Improved Compatibility with Shells

  * Graphical User Interfaces with Tk

    * "tkinter" --- Python interface to Tcl/Tk

      * Architecture

      * Tkinter Modules

        * "Tk"

          * "Tk.tk"

          * "Tk.master"

          * "Tk.children"

        * "Tcl()"

      * 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

        * "Widget.tk.createfilehandler()"

        * "Widget.tk.deletefilehandler()"

        * "READABLE"

        * "WRITABLE"

        * "EXCEPTION"

    * "tkinter.colorchooser" --- Color choosing dialog

      * "Chooser"

      * "askcolor()"

    * "tkinter.font" --- Tkinter font wrapper

      * "NORMAL"

      * "BOLD"

      * "ITALIC"

      * "ROMAN"

      * "Font"

        * "Font.actual()"

        * "Font.cget()"

        * "Font.config()"

        * "Font.copy()"

        * "Font.measure()"

        * "Font.metrics()"

      * "families()"

      * "names()"

      * "nametofont()"

    * Tkinter Dialogs

      * "tkinter.simpledialog" --- Standard Tkinter input dialogs

        * "askfloat()"

        * "askinteger()"

        * "askstring()"

        * "Dialog"

          * "Dialog.body()"

          * "Dialog.buttonbox()"

      * "tkinter.filedialog" --- File selection dialogs

        * Native Load/Save Dialogs

          * "askopenfile()"

          * "askopenfiles()"

          * "asksaveasfile()"

          * "askopenfilename()"

          * "askopenfilenames()"

          * "asksaveasfilename()"

          * "askdirectory()"

          * "Open"

          * "SaveAs"

          * "Directory"

          * "FileDialog"

            * "FileDialog.cancel_command()"

            * "FileDialog.dirs_double_event()"

            * "FileDialog.dirs_select_event()"

            * "FileDialog.files_double_event()"

            * "FileDialog.files_select_event()"

            * "FileDialog.filter_command()"

            * "FileDialog.get_filter()"

            * "FileDialog.get_selection()"

            * "FileDialog.go()"

            * "FileDialog.ok_event()"

            * "FileDialog.quit()"

            * "FileDialog.set_filter()"

            * "FileDialog.set_selection()"

          * "LoadFileDialog"

            * "LoadFileDialog.ok_command()"

          * "SaveFileDialog"

            * "SaveFileDialog.ok_command()"

      * "tkinter.commondialog" --- Dialog window templates

        * "Dialog"

          * "Dialog.show()"

    * "tkinter.messagebox" --- Tkinter message prompts

      * "Message"

      * "showinfo()"

      * "showwarning()"

      * "showerror()"

      * "askquestion()"

      * "askokcancel()"

      * "askretrycancel()"

      * "askyesno()"

      * "askyesnocancel()"

    * "tkinter.scrolledtext" --- Scrolled Text Widget

      * "ScrolledText"

        * "ScrolledText.frame"

        * "ScrolledText.vbar"

    * "tkinter.dnd" --- Drag and drop support

      * "DndHandler"

        * "DndHandler.cancel()"

        * "DndHandler.finish()"

        * "DndHandler.on_motion()"

        * "DndHandler.on_release()"

      * "dnd_start()"

    * "tkinter.ttk" --- Tk themed widgets

      * Using Ttk

      * Ttk Widgets

      * Widget

        * Standard Options

        * Scrollable Widget Options

        * Label Options

        * Compatibility Options

        * Widget States

        * ttk.Widget

          * "Widget"

            * "Widget.identify()"

            * "Widget.instate()"

            * "Widget.state()"

      * Combobox

        * Options

        * Virtual events

        * ttk.Combobox

          * "Combobox"

            * "Combobox.current()"

            * "Combobox.get()"

            * "Combobox.set()"

      * Spinbox

        * Options

        * Virtual events

        * ttk.Spinbox

          * "Spinbox"

            * "Spinbox.get()"

            * "Spinbox.set()"

      * Notebook

        * Options

        * Tab Options

        * Tab Identifiers

        * Virtual Events

        * ttk.Notebook

          * "Notebook"

            * "Notebook.add()"

            * "Notebook.forget()"

            * "Notebook.hide()"

            * "Notebook.identify()"

            * "Notebook.index()"

            * "Notebook.insert()"

            * "Notebook.select()"

            * "Notebook.tab()"

            * "Notebook.tabs()"

            * "Notebook.enable_traversal()"

      * Progressbar

        * Options

        * ttk.Progressbar

          * "Progressbar"

            * "Progressbar.start()"

            * "Progressbar.step()"

            * "Progressbar.stop()"

      * Separator

        * Options

      * Sizegrip

        * Platform-specific notes

        * Bugs

      * Treeview

        * Options

        * Item Options

        * Tag Options

        * Column Identifiers

        * Virtual Events

        * ttk.Treeview

          * "Treeview"

            * "Treeview.bbox()"

            * "Treeview.get_children()"

            * "Treeview.set_children()"

            * "Treeview.column()"

            * "Treeview.delete()"

            * "Treeview.detach()"

            * "Treeview.exists()"

            * "Treeview.focus()"

            * "Treeview.heading()"

            * "Treeview.identify()"

            * "Treeview.identify_row()"

            * "Treeview.identify_column()"

            * "Treeview.identify_region()"

            * "Treeview.identify_element()"

            * "Treeview.index()"

            * "Treeview.insert()"

            * "Treeview.item()"

            * "Treeview.move()"

            * "Treeview.next()"

            * "Treeview.parent()"

            * "Treeview.prev()"

            * "Treeview.reattach()"

            * "Treeview.see()"

            * "Treeview.selection()"

            * "Treeview.selection_set()"

            * "Treeview.selection_add()"

            * "Treeview.selection_remove()"

            * "Treeview.selection_toggle()"

            * "Treeview.set()"

            * "Treeview.tag_bind()"

            * "Treeview.tag_configure()"

            * "Treeview.tag_has()"

            * "Treeview.xview()"

            * "Treeview.yview()"

      * Ttk Styling

        * "Style"

          * "Style.configure()"

          * "Style.map()"

          * "Style.lookup()"

          * "Style.layout()"

          * "Style.element_create()"

          * "Style.element_names()"

          * "Style.element_options()"

          * "Style.theme_create()"

          * "Style.theme_settings()"

          * "Style.theme_names()"

          * "Style.theme_use()"

        * Layouts

    * 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

        * Search and Replace

        * Completions

        * Calltips

        * Code Context

        * 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

      * idlelib

  * Development Tools

    * "typing" --- Support for type hints

      * Relevant PEPs

      * Type aliases

      * NewType

      * Annotating callable objects

      * Generics

      * Annotating tuples

      * The type of class objects

      * User-defined generic types

      * The "Any" type

      * Nominal vs structural subtyping

      * Module contents

        * Special typing primitives

          * Special types

            * "Any"

            * "AnyStr"

            * "LiteralString"

            * "Never"

            * "NoReturn"

            * "Self"

            * "TypeAlias"

          * Special forms

            * "Union"

            * "Optional"

            * "Concatenate"

            * "Literal"

            * "ClassVar"

            * "Final"

            * "Required"

            * "NotRequired"

            * "Annotated"

            * "TypeGuard"

            * "Unpack"

          * Building generic types and type aliases

            * "Generic"

            * "TypeVar"

              * "TypeVar.__name__"

              * "TypeVar.__covariant__"

              * "TypeVar.__contravariant__"

              * "TypeVar.__infer_variance__"

              * "TypeVar.__bound__"

              * "TypeVar.__constraints__"

            * "TypeVarTuple"

              * "TypeVarTuple.__name__"

            * "ParamSpec"

              * "ParamSpec.args"

              * "ParamSpec.kwargs"

              * "ParamSpec.__name__"

            * "ParamSpecArgs"

            * "ParamSpecKwargs"

            * "TypeAliasType"

              * "TypeAliasType.__name__"

              * "TypeAliasType.__module__"

              * "TypeAliasType.__type_params__"

              * "TypeAliasType.__value__"

          * Other special directives

            * "NamedTuple"

            * "NewType"

              * "NewType.__module__"

              * "NewType.__name__"

              * "NewType.__supertype__"

            * "Protocol"

            * "runtime_checkable()"

            * "TypedDict"

              * "TypedDict.__total__"

              * "TypedDict.__required_keys__"

              * "TypedDict.__optional_keys__"

        * Protocols

          * "SupportsAbs"

          * "SupportsBytes"

          * "SupportsComplex"

          * "SupportsFloat"

          * "SupportsIndex"

          * "SupportsInt"

          * "SupportsRound"

        * ABCs for working with IO

          * "IO"

          * "TextIO"

          * "BinaryIO"

        * Functions and decorators

          * "cast()"

          * "assert_type()"

          * "assert_never()"

          * "reveal_type()"

          * "dataclass_transform()"

          * "overload()"

          * "get_overloads()"

          * "clear_overloads()"

          * "final()"

          * "no_type_check()"

          * "no_type_check_decorator()"

          * "override()"

          * "type_check_only()"

        * Introspection helpers

          * "get_type_hints()"

          * "get_origin()"

          * "get_args()"

          * "get_protocol_members()"

          * "is_protocol()"

          * "is_typeddict()"

          * "ForwardRef"

        * Constant

          * "TYPE_CHECKING"

        * Deprecated aliases

          * Aliases to built-in types

            * "Dict"

            * "List"

            * "Set"

            * "FrozenSet"

            * "Tuple"

            * "Type"

          * Aliases to types in "collections"

            * "DefaultDict"

            * "OrderedDict"

            * "ChainMap"

            * "Counter"

            * "Deque"

          * Aliases to other concrete types

            * "Pattern"

            * "Match"

            * "Text"

          * Aliases to container ABCs in "collections.abc"

            * "AbstractSet"

            * "ByteString"

            * "Collection"

            * "Container"

            * "ItemsView"

            * "KeysView"

            * "Mapping"

            * "MappingView"

            * "MutableMapping"

            * "MutableSequence"

            * "MutableSet"

            * "Sequence"

            * "ValuesView"

          * Aliases to asynchronous ABCs in "collections.abc"

            * "Coroutine"

            * "AsyncGenerator"

            * "AsyncIterable"

            * "AsyncIterator"

            * "Awaitable"

          * Aliases to other ABCs in "collections.abc"

            * "Iterable"

            * "Iterator"

            * "Callable"

            * "Generator"

            * "Hashable"

            * "Reversible"

            * "Sized"

          * Aliases to "contextlib" ABCs

            * "ContextManager"

            * "AsyncContextManager"

      * Deprecation Timeline of Major Features

    * "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

          * "DONT_ACCEPT_TRUE_FOR_1"

          * "DONT_ACCEPT_BLANKLINE"

          * "NORMALIZE_WHITESPACE"

          * "ELLIPSIS"

          * "IGNORE_EXCEPTION_DETAIL"

          * "SKIP"

          * "COMPARISON_FLAGS"

          * "REPORT_UDIFF"

          * "REPORT_CDIFF"

          * "REPORT_NDIFF"

          * "REPORT_ONLY_FIRST_FAILURE"

          * "FAIL_FAST"

          * "REPORTING_FLAGS"

          * "register_optionflag()"

        * Directives

        * Warnings

      * Basic API

        * "testfile()"

        * "testmod()"

        * "run_docstring_examples()"

      * Unittest API

        * "DocFileSuite()"

        * "DocTestSuite()"

        * "set_unittest_reportflags()"

      * Advanced API

        * DocTest Objects

          * "DocTest"

            * "DocTest.examples"

            * "DocTest.globs"

            * "DocTest.name"

            * "DocTest.filename"

            * "DocTest.lineno"

            * "DocTest.docstring"

        * Example Objects

          * "Example"

            * "Example.source"

            * "Example.want"

            * "Example.exc_msg"

            * "Example.lineno"

            * "Example.indent"

            * "Example.options"

        * DocTestFinder objects

          * "DocTestFinder"

            * "DocTestFinder.find()"

        * DocTestParser objects

          * "DocTestParser"

            * "DocTestParser.get_doctest()"

            * "DocTestParser.get_examples()"

            * "DocTestParser.parse()"

        * TestResults objects

          * "TestResults"

            * "TestResults.failed"

            * "TestResults.attempted"

            * "TestResults.skipped"

        * DocTestRunner objects

          * "DocTestRunner"

            * "DocTestRunner.report_start()"

            * "DocTestRunner.report_success()"

            * "DocTestRunner.report_failure()"

            * "DocTestRunner.report_unexpected_exception()"

            * "DocTestRunner.run()"

            * "DocTestRunner.summarize()"

            * "DocTestRunner.tries"

            * "DocTestRunner.failures"

            * "DocTestRunner.skips"

        * OutputChecker objects

          * "OutputChecker"

            * "OutputChecker.check_output()"

            * "OutputChecker.output_difference()"

      * Debugging

        * "script_from_examples()"

        * "testsource()"

        * "debug()"

        * "debug_src()"

        * "DebugRunner"

        * "DocTestFailure"

          * "DocTestFailure.test"

          * "DocTestFailure.example"

          * "DocTestFailure.got"

        * "UnexpectedException"

          * "UnexpectedException.test"

          * "UnexpectedException.example"

          * "UnexpectedException.exc_info"

      * 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

        * "skip()"

        * "skipIf()"

        * "skipUnless()"

        * "expectedFailure()"

        * "SkipTest"

      * Distinguishing test iterations using subtests

      * Classes and functions

        * Test cases

          * "TestCase"

            * "TestCase.setUp()"

            * "TestCase.tearDown()"

            * "TestCase.setUpClass()"

            * "TestCase.tearDownClass()"

            * "TestCase.run()"

            * "TestCase.skipTest()"

            * "TestCase.subTest()"

            * "TestCase.debug()"

            * "TestCase.assertEqual()"

            * "TestCase.assertNotEqual()"

            * "TestCase.assertTrue()"

            * "TestCase.assertFalse()"

            * "TestCase.assertIs()"

            * "TestCase.assertIsNot()"

            * "TestCase.assertIsNone()"

            * "TestCase.assertIsNotNone()"

            * "TestCase.assertIn()"

            * "TestCase.assertNotIn()"

            * "TestCase.assertIsInstance()"

            * "TestCase.assertNotIsInstance()"

            * "TestCase.assertRaises()"

            * "TestCase.assertRaisesRegex()"

            * "TestCase.assertWarns()"

            * "TestCase.assertWarnsRegex()"

            * "TestCase.assertLogs()"

            * "TestCase.records"

            * "TestCase.output"

            * "TestCase.assertNoLogs()"

            * "TestCase.assertAlmostEqual()"

            * "TestCase.assertNotAlmostEqual()"

            * "TestCase.assertGreater()"

            * "TestCase.assertGreaterEqual()"

            * "TestCase.assertLess()"

            * "TestCase.assertLessEqual()"

            * "TestCase.assertRegex()"

            * "TestCase.assertNotRegex()"

            * "TestCase.assertCountEqual()"

            * "TestCase.addTypeEqualityFunc()"

            * "TestCase.assertMultiLineEqual()"

            * "TestCase.assertSequenceEqual()"

            * "TestCase.assertListEqual()"

            * "TestCase.assertTupleEqual()"

            * "TestCase.assertSetEqual()"

            * "TestCase.assertDictEqual()"

            * "TestCase.fail()"

            * "TestCase.failureException"

            * "TestCase.longMessage"

            * "TestCase.maxDiff"

            * "TestCase.countTestCases()"

            * "TestCase.defaultTestResult()"

            * "TestCase.id()"

            * "TestCase.shortDescription()"

            * "TestCase.addCleanup()"

            * "TestCase.enterContext()"

            * "TestCase.doCleanups()"

            * "TestCase.addClassCleanup()"

            * "TestCase.enterClassContext()"

            * "TestCase.doClassCleanups()"

          * "IsolatedAsyncioTestCase"

            * "IsolatedAsyncioTestCase.asyncSetUp()"

            * "IsolatedAsyncioTestCase.asyncTearDown()"

            * "IsolatedAsyncioTestCase.addAsyncCleanup()"

            * "IsolatedAsyncioTestCase.enterAsyncContext()"

            * "IsolatedAsyncioTestCase.run()"

          * "FunctionTestCase"

        * Grouping tests

          * "TestSuite"

            * "TestSuite.addTest()"

            * "TestSuite.addTests()"

            * "TestSuite.run()"

            * "TestSuite.debug()"

            * "TestSuite.countTestCases()"

            * "TestSuite.__iter__()"

        * Loading and running tests

          * "TestLoader"

            * "TestLoader.errors"

            * "TestLoader.loadTestsFromTestCase()"

            * "TestLoader.loadTestsFromModule()"

            * "TestLoader.loadTestsFromName()"

            * "TestLoader.loadTestsFromNames()"

            * "TestLoader.getTestCaseNames()"

            * "TestLoader.discover()"

            * "TestLoader.testMethodPrefix"

            * "TestLoader.sortTestMethodsUsing"

            * "TestLoader.suiteClass"

            * "TestLoader.testNamePatterns"

          * "TestResult"

            * "TestResult.errors"

            * "TestResult.failures"

            * "TestResult.skipped"

            * "TestResult.expectedFailures"

            * "TestResult.unexpectedSuccesses"

            * "TestResult.collectedDurations"

            * "TestResult.shouldStop"

            * "TestResult.testsRun"

            * "TestResult.buffer"

            * "TestResult.failfast"

            * "TestResult.tb_locals"

            * "TestResult.wasSuccessful()"

            * "TestResult.stop()"

            * "TestResult.startTest()"

            * "TestResult.stopTest()"

            * "TestResult.startTestRun()"

            * "TestResult.stopTestRun()"

            * "TestResult.addError()"

            * "TestResult.addFailure()"

            * "TestResult.addSuccess()"

            * "TestResult.addSkip()"

            * "TestResult.addExpectedFailure()"

            * "TestResult.addUnexpectedSuccess()"

            * "TestResult.addSubTest()"

            * "TestResult.addDuration()"

          * "TextTestResult"

          * "defaultTestLoader"

          * "TextTestRunner"

            * "TextTestRunner._makeResult()"

            * "TextTestRunner.run()"

          * "main()"

          * load_tests Protocol

      * Class and Module Fixtures

        * setUpClass and tearDownClass

        * setUpModule and tearDownModule

          * "addModuleCleanup()"

          * "enterModuleContext()"

          * "doModuleCleanups()"

      * Signal Handling

        * "installHandler()"

        * "registerResult()"

        * "removeResult()"

        * "removeHandler()"

    * "unittest.mock" --- mock object library

      * Quick Guide

      * The Mock Class

        * "Mock"

          * "Mock.assert_called()"

          * "Mock.assert_called_once()"

          * "Mock.assert_called_with()"

          * "Mock.assert_called_once_with()"

          * "Mock.assert_any_call()"

          * "Mock.assert_has_calls()"

          * "Mock.assert_not_called()"

          * "Mock.reset_mock()"

          * "Mock.mock_add_spec()"

          * "Mock.attach_mock()"

          * "Mock.configure_mock()"

          * "Mock.__dir__()"

          * "Mock._get_child_mock()"

          * "Mock.called"

          * "Mock.call_count"

          * "Mock.return_value"

          * "Mock.side_effect"

          * "Mock.call_args"

          * "Mock.call_args_list"

          * "Mock.method_calls"

          * "Mock.mock_calls"

          * "Mock.__class__"

        * "NonCallableMock"

        * "PropertyMock"

        * "AsyncMock"

          * "AsyncMock.assert_awaited()"

          * "AsyncMock.assert_awaited_once()"

          * "AsyncMock.assert_awaited_with()"

          * "AsyncMock.assert_awaited_once_with()"

          * "AsyncMock.assert_any_await()"

          * "AsyncMock.assert_has_awaits()"

          * "AsyncMock.assert_not_awaited()"

          * "AsyncMock.reset_mock()"

          * "AsyncMock.await_count"

          * "AsyncMock.await_args"

          * "AsyncMock.await_args_list"

        * "ThreadingMock"

          * "ThreadingMock.wait_until_called()"

          * "ThreadingMock.wait_until_any_call_with()"

          * "ThreadingMock.DEFAULT_TIMEOUT"

        * Calling

        * Deleting Attributes

        * Mock names and the name attribute

        * Attaching Mocks as Attributes

      * The patchers

        * patch

          * "patch()"

        * patch.object

          * "patch.object()"

        * patch.dict

          * "patch.dict()"

        * patch.multiple

          * "patch.multiple()"

        * patch methods: start and stop

          * "patch.stopall()"

        * 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

          * "MagicMock"

          * "NonCallableMagicMock"

      * Helpers

        * sentinel

          * "sentinel"

        * DEFAULT

          * "DEFAULT"

        * call

          * "call()"

            * "call.call_list()"

        * create_autospec

          * "create_autospec()"

        * ANY

          * "ANY"

        * FILTER_DIR

          * "FILTER_DIR"

        * mock_open

          * "mock_open()"

        * Autospeccing

        * Sealing mocks

          * "seal()"

    * "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

        * Using side_effect to return per file content

      * 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

    * "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

      * "TestFailed"

      * "ResourceDenied"

      * "verbose"

      * "is_jython"

      * "is_android"

      * "unix_shell"

      * "LOOPBACK_TIMEOUT"

      * "INTERNET_TIMEOUT"

      * "SHORT_TIMEOUT"

      * "LONG_TIMEOUT"

      * "PGO"

      * "PIPE_MAX_SIZE"

      * "Py_DEBUG"

      * "SOCK_MAX_SIZE"

      * "TEST_SUPPORT_DIR"

      * "TEST_HOME_DIR"

      * "TEST_DATA_DIR"

      * "MAX_Py_ssize_t"

      * "max_memuse"

      * "real_max_memuse"

      * "MISSING_C_DOCSTRINGS"

      * "HAVE_DOCSTRINGS"

      * "TEST_HTTP_URL"

      * "ALWAYS_EQ"

      * "NEVER_EQ"

      * "LARGEST"

      * "SMALLEST"

      * "busy_retry()"

      * "sleeping_retry()"

      * "is_resource_enabled()"

      * "python_is_optimized()"

      * "with_pymalloc()"

      * "requires()"

      * "sortdict()"

      * "findfile()"

      * "match_test()"

      * "set_match_tests()"

      * "run_unittest()"

      * "run_doctest()"

      * "get_pagesize()"

      * "setswitchinterval()"

      * "check_impl_detail()"

      * "set_memlimit()"

      * "record_original_stdout()"

      * "get_original_stdout()"

      * "args_from_interpreter_flags()"

      * "optim_args_from_interpreter_flags()"

      * "captured_stdin()"

      * "captured_stdout()"

      * "captured_stderr()"

      * "disable_faulthandler()"

      * "gc_collect()"

      * "disable_gc()"

      * "swap_attr()"

      * "swap_item()"

      * "flush_std_streams()"

      * "print_warning()"

      * "wait_process()"

      * "calcobjsize()"

      * "calcvobjsize()"

      * "checksizeof()"

      * "anticipate_failure()"

      * "system_must_validate_cert()"

      * "run_with_locale()"

      * "run_with_tz()"

      * "requires_freebsd_version()"

      * "requires_linux_version()"

      * "requires_mac_version()"

      * "requires_IEEE_754()"

      * "requires_zlib()"

      * "requires_gzip()"

      * "requires_bz2()"

      * "requires_lzma()"

      * "requires_resource()"

      * "requires_docstrings()"

      * "requires_limited_api()"

      * "cpython_only()"

      * "impl_detail()"

      * "no_tracing()"

      * "refcount_test()"

      * "bigmemtest()"

      * "bigaddrspacetest()"

      * "check_syntax_error()"

      * "open_urlresource()"

      * "reap_children()"

      * "get_attribute()"

      * "catch_unraisable_exception()"

      * "load_package_tests()"

      * "detect_api_mismatch()"

      * "patch()"

      * "run_in_subinterp()"

      * "check_free_after_iterating()"

      * "missing_compiler_executable()"

      * "check__all__()"

      * "skip_if_broken_multiprocessing_synchronize()"

      * "check_disallow_instantiation()"

      * "adjust_int_max_str_digits()"

      * "SuppressCrashReport"

      * "SaveSignals"

        * "SaveSignals.save()"

        * "SaveSignals.restore()"

      * "Matcher"

        * "Matcher.matches()"

        * "Matcher.match_value()"

    * "test.support.socket_helper" --- Utilities for socket tests

      * "IPV6_ENABLED"

      * "find_unused_port()"

      * "bind_port()"

      * "bind_unix_socket()"

      * "skip_unless_bind_unix_socket()"

      * "transient_internet()"

    * "test.support.script_helper" --- Utilities for the Python
      execution tests

      * "interpreter_requires_environment()"

      * "run_python_until_end()"

      * "assert_python_ok()"

      * "assert_python_failure()"

      * "spawn_python()"

      * "kill_python()"

      * "make_script()"

      * "make_zip_script()"

      * "make_pkg()"

      * "make_zip_pkg()"

    * "test.support.bytecode_helper" --- Support tools for testing
      correct bytecode generation

      * "BytecodeTestCase"

        * "BytecodeTestCase.get_disassembly_as_string()"

        * "BytecodeTestCase.assertInBytecode()"

        * "BytecodeTestCase.assertNotInBytecode()"

    * "test.support.threading_helper" --- Utilities for threading
      tests

      * "join_thread()"

      * "reap_threads()"

      * "start_threads()"

      * "threading_cleanup()"

      * "threading_setup()"

      * "wait_threads_exit()"

      * "catch_threading_exception()"

    * "test.support.os_helper" --- Utilities for os tests

      * "FS_NONASCII"

      * "SAVEDCWD"

      * "TESTFN"

      * "TESTFN_NONASCII"

      * "TESTFN_UNENCODABLE"

      * "TESTFN_UNDECODABLE"

      * "TESTFN_UNICODE"

      * "EnvironmentVarGuard"

        * "EnvironmentVarGuard.set()"

        * "EnvironmentVarGuard.unset()"

      * "FakePath"

      * "can_symlink()"

      * "can_xattr()"

      * "change_cwd()"

      * "create_empty_file()"

      * "fd_count()"

      * "fs_is_case_insensitive()"

      * "make_bad_fd()"

      * "rmdir()"

      * "rmtree()"

      * "skip_unless_symlink()"

      * "skip_unless_xattr()"

      * "temp_cwd()"

      * "temp_dir()"

      * "temp_umask()"

      * "unlink()"

    * "test.support.import_helper" --- Utilities for import tests

      * "forget()"

      * "import_fresh_module()"

      * "import_module()"

      * "modules_setup()"

      * "modules_cleanup()"

      * "unload()"

      * "make_legacy_pyc()"

      * "CleanImport"

      * "DirsOnSysPath"

    * "test.support.warnings_helper" --- Utilities for warnings tests

      * "ignore_warnings()"

      * "check_no_resource_warning()"

      * "check_syntax_warning()"

      * "check_warnings()"

      * "WarningsRecorder"

  * Debugging and Profiling

    * Audit events table

    * "bdb" --- Debugger framework

      * "BdbQuit"

      * "Breakpoint"

        * "Breakpoint.deleteMe()"

        * "Breakpoint.enable()"

        * "Breakpoint.disable()"

        * "Breakpoint.bpformat()"

        * "Breakpoint.bpprint()"

        * "Breakpoint.file"

        * "Breakpoint.line"

        * "Breakpoint.temporary"

        * "Breakpoint.cond"

        * "Breakpoint.funcname"

        * "Breakpoint.enabled"

        * "Breakpoint.bpbynumber"

        * "Breakpoint.bplist"

        * "Breakpoint.ignore"

        * "Breakpoint.hits"

      * "Bdb"

        * "Bdb.canonic()"

        * "Bdb.reset()"

        * "Bdb.trace_dispatch()"

        * "Bdb.dispatch_line()"

        * "Bdb.dispatch_call()"

        * "Bdb.dispatch_return()"

        * "Bdb.dispatch_exception()"

        * "Bdb.is_skipped_line()"

        * "Bdb.stop_here()"

        * "Bdb.break_here()"

        * "Bdb.break_anywhere()"

        * "Bdb.user_call()"

        * "Bdb.user_line()"

        * "Bdb.user_return()"

        * "Bdb.user_exception()"

        * "Bdb.do_clear()"

        * "Bdb.set_step()"

        * "Bdb.set_next()"

        * "Bdb.set_return()"

        * "Bdb.set_until()"

        * "Bdb.set_trace()"

        * "Bdb.set_continue()"

        * "Bdb.set_quit()"

        * "Bdb.set_break()"

        * "Bdb.clear_break()"

        * "Bdb.clear_bpbynumber()"

        * "Bdb.clear_all_file_breaks()"

        * "Bdb.clear_all_breaks()"

        * "Bdb.get_bpbynumber()"

        * "Bdb.get_break()"

        * "Bdb.get_breaks()"

        * "Bdb.get_file_breaks()"

        * "Bdb.get_all_breaks()"

        * "Bdb.get_stack()"

        * "Bdb.format_stack_entry()"

        * "Bdb.run()"

        * "Bdb.runeval()"

        * "Bdb.runctx()"

        * "Bdb.runcall()"

      * "checkfuncname()"

      * "effective()"

      * "set_trace()"

    * "faulthandler" --- Dump the Python traceback

      * Dumping the traceback

        * "dump_traceback()"

      * Fault handler state

        * "enable()"

        * "disable()"

        * "is_enabled()"

      * Dumping the tracebacks after a timeout

        * "dump_traceback_later()"

        * "cancel_dump_traceback_later()"

      * Dumping the traceback on a user signal

        * "register()"

        * "unregister()"

      * Issue with file descriptors

      * Example

    * "pdb" --- The Python Debugger

      * "run()"

      * "runeval()"

      * "runcall()"

      * "set_trace()"

      * "post_mortem()"

      * "pm()"

      * "Pdb"

        * "Pdb.run()"

        * "Pdb.runeval()"

        * "Pdb.runcall()"

        * "Pdb.set_trace()"

      * Debugger Commands

    * The Python Profilers

      * Introduction to the profilers

      * Instant User's Manual

      * "profile" and "cProfile" Module Reference

        * "run()"

        * "runctx()"

        * "Profile"

          * "Profile.enable()"

          * "Profile.disable()"

          * "Profile.create_stats()"

          * "Profile.print_stats()"

          * "Profile.dump_stats()"

          * "Profile.run()"

          * "Profile.runctx()"

          * "Profile.runcall()"

      * The "Stats" Class

        * "Stats"

          * "Stats.strip_dirs()"

          * "Stats.add()"

          * "Stats.dump_stats()"

          * "Stats.sort_stats()"

          * "Stats.reverse_order()"

          * "Stats.print_stats()"

          * "Stats.print_callers()"

          * "Stats.print_callees()"

          * "Stats.get_stats_profile()"

      * What Is Deterministic Profiling?

      * Limitations

      * Calibration

      * Using a custom timer

    * "timeit" --- Measure execution time of small code snippets

      * Basic Examples

      * Python Interface

        * "timeit()"

        * "repeat()"

        * "default_timer()"

        * "Timer"

          * "Timer.timeit()"

          * "Timer.autorange()"

          * "Timer.repeat()"

          * "Timer.print_exc()"

      * Command-Line Interface

      * Examples

    * "trace" --- Trace or track Python statement execution

      * Command-Line Usage

        * Main options

        * Modifiers

        * Filters

      * Programmatic Interface

        * "Trace"

          * "Trace.run()"

          * "Trace.runctx()"

          * "Trace.runfunc()"

          * "Trace.results()"

        * "CoverageResults"

          * "CoverageResults.update()"

          * "CoverageResults.write_results()"

    * "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

          * "clear_traces()"

          * "get_object_traceback()"

          * "get_traceback_limit()"

          * "get_traced_memory()"

          * "reset_peak()"

          * "get_tracemalloc_memory()"

          * "is_tracing()"

          * "start()"

          * "stop()"

          * "take_snapshot()"

        * DomainFilter

          * "DomainFilter"

            * "DomainFilter.inclusive"

            * "DomainFilter.domain"

        * Filter

          * "Filter"

            * "Filter.domain"

            * "Filter.inclusive"

            * "Filter.lineno"

            * "Filter.filename_pattern"

            * "Filter.all_frames"

        * Frame

          * "Frame"

            * "Frame.filename"

            * "Frame.lineno"

        * Snapshot

          * "Snapshot"

            * "Snapshot.compare_to()"

            * "Snapshot.dump()"

            * "Snapshot.filter_traces()"

            * "Snapshot.load()"

            * "Snapshot.statistics()"

            * "Snapshot.traceback_limit"

            * "Snapshot.traces"

        * Statistic

          * "Statistic"

            * "Statistic.count"

            * "Statistic.size"

            * "Statistic.traceback"

        * StatisticDiff

          * "StatisticDiff"

            * "StatisticDiff.count"

            * "StatisticDiff.count_diff"

            * "StatisticDiff.size"

            * "StatisticDiff.size_diff"

            * "StatisticDiff.traceback"

        * Trace

          * "Trace"

            * "Trace.domain"

            * "Trace.size"

            * "Trace.traceback"

        * Traceback

          * "Traceback"

            * "Traceback.total_nframe"

            * "Traceback.format()"

  * Software Packaging and Distribution

    * "ensurepip" --- Bootstrapping the "pip" installer

      * Command line interface

      * Module API

        * "version()"

        * "bootstrap()"

    * "venv" --- Creation of virtual environments

      * Creating virtual environments

      * How venvs work

      * API

        * "EnvBuilder"

          * "EnvBuilder.create()"

          * "EnvBuilder.ensure_directories()"

          * "EnvBuilder.create_configuration()"

          * "EnvBuilder.setup_python()"

          * "EnvBuilder.setup_scripts()"

          * "EnvBuilder.upgrade_dependencies()"

          * "EnvBuilder.post_setup()"

          * "EnvBuilder.install_scripts()"

          * "EnvBuilder.create_git_ignore_file()"

        * "create()"

      * An example of extending "EnvBuilder"

    * "zipapp" --- Manage executable Python zip archives

      * Basic Example

      * Command-Line Interface

      * Python API

        * "create_archive()"

        * "get_interpreter()"

      * Examples

      * Specifying the Interpreter

      * Creating Standalone Applications with zipapp

        * Caveats

      * The Python Zip Application Archive Format

  * Python Runtime Services

    * "sys" --- System-specific parameters and functions

      * "abiflags"

      * "addaudithook()"

      * "argv"

      * "audit()"

      * "base_exec_prefix"

      * "base_prefix"

      * "byteorder"

      * "builtin_module_names"

      * "call_tracing()"

      * "copyright"

      * "_clear_type_cache()"

      * "_current_frames()"

      * "_current_exceptions()"

      * "breakpointhook()"

      * "_debugmallocstats()"

      * "dllhandle"

      * "displayhook()"

      * "dont_write_bytecode"

      * "_emscripten_info"

        * "_emscripten_info.emscripten_version"

        * "_emscripten_info.runtime"

        * "_emscripten_info.pthreads"

        * "_emscripten_info.shared_memory"

      * "pycache_prefix"

      * "excepthook()"

      * "__breakpointhook__"

      * "__displayhook__"

      * "__excepthook__"

      * "__unraisablehook__"

      * "exception()"

      * "exc_info()"

      * "exec_prefix"

      * "executable"

      * "exit()"

      * "flags"

        * "flags.debug"

        * "flags.inspect"

        * "flags.interactive"

        * "flags.isolated"

        * "flags.optimize"

        * "flags.dont_write_bytecode"

        * "flags.no_user_site"

        * "flags.no_site"

        * "flags.ignore_environment"

        * "flags.verbose"

        * "flags.bytes_warning"

        * "flags.quiet"

        * "flags.hash_randomization"

        * "flags.dev_mode"

        * "flags.utf8_mode"

        * "flags.safe_path"

        * "flags.int_max_str_digits"

        * "flags.warn_default_encoding"

      * "float_info"

        * "float_info.epsilon"

        * "float_info.dig"

        * "float_info.mant_dig"

        * "float_info.max"

        * "float_info.max_exp"

        * "float_info.max_10_exp"

        * "float_info.min"

        * "float_info.min_exp"

        * "float_info.min_10_exp"

        * "float_info.radix"

        * "float_info.rounds"

      * "float_repr_style"

      * "getallocatedblocks()"

      * "getunicodeinternedsize()"

      * "getandroidapilevel()"

      * "getdefaultencoding()"

      * "getdlopenflags()"

      * "getfilesystemencoding()"

      * "getfilesystemencodeerrors()"

      * "get_int_max_str_digits()"

      * "getrefcount()"

      * "getrecursionlimit()"

      * "getsizeof()"

      * "getswitchinterval()"

      * "_getframe()"

      * "_getframemodulename()"

      * "getprofile()"

      * "gettrace()"

      * "getwindowsversion()"

      * "get_asyncgen_hooks()"

      * "get_coroutine_origin_tracking_depth()"

      * "hash_info"

        * "hash_info.width"

        * "hash_info.modulus"

        * "hash_info.inf"

        * "hash_info.nan"

        * "hash_info.imag"

        * "hash_info.algorithm"

        * "hash_info.hash_bits"

        * "hash_info.seed_bits"

      * "hexversion"

      * "implementation"

      * "int_info"

        * "int_info.bits_per_digit"

        * "int_info.sizeof_digit"

        * "int_info.default_max_str_digits"

        * "int_info.str_digits_check_threshold"

      * "__interactivehook__"

      * "intern()"

      * "is_finalizing()"

      * "last_exc"

      * "last_type"

      * "last_value"

      * "last_traceback"

      * "maxsize"

      * "maxunicode"

      * "meta_path"

      * "modules"

      * "orig_argv"

      * "path"

      * "path_hooks"

      * "path_importer_cache"

      * "platform"

      * "platlibdir"

      * "prefix"

      * "ps1"

      * "ps2"

      * "setdlopenflags()"

      * "set_int_max_str_digits()"

      * "setprofile()"

      * "setrecursionlimit()"

      * "setswitchinterval()"

      * "settrace()"

      * "set_asyncgen_hooks()"

      * "set_coroutine_origin_tracking_depth()"

      * "activate_stack_trampoline()"

      * "deactivate_stack_trampoline()"

      * "is_stack_trampoline_active()"

      * "_enablelegacywindowsfsencoding()"

      * "stdin"

      * "stdout"

      * "stderr"

      * "__stdin__"

      * "__stdout__"

      * "__stderr__"

      * "stdlib_module_names"

      * "thread_info"

        * "thread_info.name"

        * "thread_info.lock"

        * "thread_info.version"

      * "tracebacklimit"

      * "unraisablehook()"

      * "version"

      * "api_version"

      * "version_info"

      * "warnoptions"

      * "winver"

      * "_xoptions"

    * "sys.monitoring" --- Execution event monitoring

      * Tool identifiers

        * Registering and using tools

          * "use_tool_id()"

          * "free_tool_id()"

          * "get_tool()"

      * Events

        * Local events

        * Ancillary events

        * Other events

        * The STOP_ITERATION event

      * Turning events on and off

        * Setting events globally

          * "get_events()"

          * "set_events()"

        * Per code object events

          * "get_local_events()"

          * "set_local_events()"

        * Disabling events

      * Registering callback functions

        * "register_callback()"

        * Callback function arguments

    * "sysconfig" --- Provide access to Python's configuration
      information

      * Configuration variables

        * "get_config_vars()"

        * "get_config_var()"

      * Installation paths

      * User scheme

        * "posix_user"

        * "nt_user"

        * "osx_framework_user"

      * Home scheme

        * "posix_home"

      * Prefix scheme

        * "posix_prefix"

        * "nt"

      * Installation path functions

        * "get_scheme_names()"

        * "get_default_scheme()"

        * "get_preferred_scheme()"

        * "_get_preferred_schemes()"

        * "get_path_names()"

        * "get_path()"

        * "get_paths()"

      * Other functions

        * "get_python_version()"

        * "get_platform()"

        * "is_python_build()"

        * "parse_config_h()"

        * "get_config_h_filename()"

        * "get_makefile_filename()"

      * 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

        * "warn()"

        * "warn_explicit()"

        * "showwarning()"

        * "formatwarning()"

        * "filterwarnings()"

        * "simplefilter()"

        * "resetwarnings()"

      * Available Context Managers

        * "catch_warnings"

    * "dataclasses" --- Data Classes

      * Module contents

        * "dataclass()"

        * "field()"

        * "Field"

        * "fields()"

        * "asdict()"

        * "astuple()"

        * "make_dataclass()"

        * "replace()"

        * "is_dataclass()"

        * "MISSING"

        * "KW_ONLY"

        * "FrozenInstanceError"

      * Post-init processing

        * "__post_init__()"

      * Class variables

      * Init-only variables

      * Frozen instances

      * Inheritance

      * Re-ordering of keyword-only parameters in "__init__()"

      * Default factory functions

      * Mutable default values

      * Descriptor-typed fields

    * "contextlib" --- Utilities for "with"-statement contexts

      * Utilities

        * "AbstractContextManager"

        * "AbstractAsyncContextManager"

        * "contextmanager()"

        * "asynccontextmanager()"

        * "closing()"

        * "aclosing()"

        * "nullcontext()"

        * "suppress()"

        * "redirect_stdout()"

        * "redirect_stderr()"

        * "chdir()"

        * "ContextDecorator"

        * "AsyncContextDecorator"

        * "ExitStack"

          * "ExitStack.enter_context()"

          * "ExitStack.push()"

          * "ExitStack.callback()"

          * "ExitStack.pop_all()"

          * "ExitStack.close()"

        * "AsyncExitStack"

          * "AsyncExitStack.enter_async_context()"

          * "AsyncExitStack.push_async_exit()"

          * "AsyncExitStack.push_async_callback()"

          * "AsyncExitStack.aclose()"

      * 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

      * "ABC"

      * "ABCMeta"

        * "ABCMeta.register()"

        * "ABCMeta.__subclasshook__()"

      * "abstractmethod()"

      * "abstractclassmethod()"

      * "abstractstaticmethod()"

      * "abstractproperty()"

      * "get_cache_token()"

      * "update_abstractmethods()"

    * "atexit" --- Exit handlers

      * "register()"

      * "unregister()"

      * "atexit" Example

    * "traceback" --- Print or retrieve a stack traceback

      * "print_tb()"

      * "print_exception()"

      * "print_exc()"

      * "print_last()"

      * "print_stack()"

      * "extract_tb()"

      * "extract_stack()"

      * "format_list()"

      * "format_exception_only()"

      * "format_exception()"

      * "format_exc()"

      * "format_tb()"

      * "format_stack()"

      * "clear_frames()"

      * "walk_stack()"

      * "walk_tb()"

      * "TracebackException" Objects

        * "TracebackException"

          * "TracebackException.__cause__"

          * "TracebackException.__context__"

          * "TracebackException.exceptions"

          * "TracebackException.__suppress_context__"

          * "TracebackException.__notes__"

          * "TracebackException.stack"

          * "TracebackException.exc_type"

          * "TracebackException.filename"

          * "TracebackException.lineno"

          * "TracebackException.end_lineno"

          * "TracebackException.text"

          * "TracebackException.offset"

          * "TracebackException.end_offset"

          * "TracebackException.msg"

          * "TracebackException.from_exception()"

          * "TracebackException.print()"

          * "TracebackException.format()"

          * "TracebackException.format_exception_only()"

      * "StackSummary" Objects

        * "StackSummary"

          * "StackSummary.extract()"

          * "StackSummary.from_list()"

          * "StackSummary.format()"

          * "StackSummary.format_frame_summary()"

      * "FrameSummary" Objects

        * "FrameSummary"

      * Traceback Examples

    * "__future__" --- Future statement definitions

      * "_Feature"

        * "_Feature.getOptionalRelease()"

        * "_Feature.getMandatoryRelease()"

        * "_Feature.compiler_flag"

    * "gc" --- Garbage Collector interface

      * "enable()"

      * "disable()"

      * "isenabled()"

      * "collect()"

      * "set_debug()"

      * "get_debug()"

      * "get_objects()"

      * "get_stats()"

      * "set_threshold()"

      * "get_count()"

      * "get_threshold()"

      * "get_referrers()"

      * "get_referents()"

      * "is_tracked()"

      * "is_finalized()"

      * "freeze()"

      * "unfreeze()"

      * "get_freeze_count()"

      * "garbage"

      * "callbacks"

      * "DEBUG_STATS"

      * "DEBUG_COLLECTABLE"

      * "DEBUG_UNCOLLECTABLE"

      * "DEBUG_SAVEALL"

      * "DEBUG_LEAK"

    * "inspect" --- Inspect live objects

      * Types and members

        * "getmembers()"

        * "getmembers_static()"

        * "getmodulename()"

        * "ismodule()"

        * "isclass()"

        * "ismethod()"

        * "isfunction()"

        * "isgeneratorfunction()"

        * "isgenerator()"

        * "iscoroutinefunction()"

        * "markcoroutinefunction()"

        * "iscoroutine()"

        * "isawaitable()"

        * "isasyncgenfunction()"

        * "isasyncgen()"

        * "istraceback()"

        * "isframe()"

        * "iscode()"

        * "isbuiltin()"

        * "ismethodwrapper()"

        * "isroutine()"

        * "isabstract()"

        * "ismethoddescriptor()"

        * "isdatadescriptor()"

        * "isgetsetdescriptor()"

        * "ismemberdescriptor()"

      * Retrieving source code

        * "getdoc()"

        * "getcomments()"

        * "getfile()"

        * "getmodule()"

        * "getsourcefile()"

        * "getsourcelines()"

        * "getsource()"

        * "cleandoc()"

      * Introspecting callables with the Signature object

        * "signature()"

        * "Signature"

          * "Signature.empty"

          * "Signature.parameters"

          * "Signature.return_annotation"

          * "Signature.bind()"

          * "Signature.bind_partial()"

          * "Signature.replace()"

          * "Signature.from_callable()"

        * "Parameter"

          * "Parameter.empty"

          * "Parameter.name"

          * "Parameter.default"

          * "Parameter.annotation"

          * "Parameter.kind"

            * "Parameter.kind.description"

          * "Parameter.replace()"

        * "BoundArguments"

          * "BoundArguments.arguments"

          * "BoundArguments.args"

          * "BoundArguments.kwargs"

          * "BoundArguments.signature"

          * "BoundArguments.apply_defaults()"

      * Classes and functions

        * "getclasstree()"

        * "getfullargspec()"

        * "getargvalues()"

        * "formatargvalues()"

        * "getmro()"

        * "getcallargs()"

        * "getclosurevars()"

        * "unwrap()"

        * "get_annotations()"

      * The interpreter stack

        * "FrameInfo"

          * "FrameInfo.frame"

          * "FrameInfo.filename"

          * "FrameInfo.lineno"

          * "FrameInfo.function"

          * "FrameInfo.code_context"

          * "FrameInfo.index"

          * "FrameInfo.positions"

        * "Traceback"

          * "Traceback.filename"

          * "Traceback.lineno"

          * "Traceback.function"

          * "Traceback.code_context"

          * "Traceback.index"

          * "Traceback.positions"

        * "getframeinfo()"

        * "getouterframes()"

        * "getinnerframes()"

        * "currentframe()"

        * "stack()"

        * "trace()"

      * Fetching attributes statically

        * "getattr_static()"

      * Current State of Generators, Coroutines, and Asynchronous
        Generators

        * "getgeneratorstate()"

        * "getcoroutinestate()"

        * "getasyncgenstate()"

        * "getgeneratorlocals()"

        * "getcoroutinelocals()"

        * "getasyncgenlocals()"

      * Code Objects Bit Flags

        * "CO_OPTIMIZED"

        * "CO_NEWLOCALS"

        * "CO_VARARGS"

        * "CO_VARKEYWORDS"

        * "CO_NESTED"

        * "CO_GENERATOR"

        * "CO_COROUTINE"

        * "CO_ITERABLE_COROUTINE"

        * "CO_ASYNC_GENERATOR"

      * Buffer flags

        * "BufferFlags"

          * "BufferFlags.SIMPLE"

          * "BufferFlags.WRITABLE"

          * "BufferFlags.FORMAT"

          * "BufferFlags.ND"

          * "BufferFlags.STRIDES"

          * "BufferFlags.C_CONTIGUOUS"

          * "BufferFlags.F_CONTIGUOUS"

          * "BufferFlags.ANY_CONTIGUOUS"

          * "BufferFlags.INDIRECT"

          * "BufferFlags.CONTIG"

          * "BufferFlags.CONTIG_RO"

          * "BufferFlags.STRIDED"

          * "BufferFlags.STRIDED_RO"

          * "BufferFlags.RECORDS"

          * "BufferFlags.RECORDS_RO"

          * "BufferFlags.FULL"

          * "BufferFlags.FULL_RO"

          * "BufferFlags.READ"

          * "BufferFlags.WRITE"

      * Command Line Interface

    * "site" --- Site-specific configuration hook

      * "sitecustomize"

      * "usercustomize"

      * Readline configuration

      * Module contents

        * "PREFIXES"

        * "ENABLE_USER_SITE"

        * "USER_SITE"

        * "USER_BASE"

        * "main()"

        * "addsitedir()"

        * "getsitepackages()"

        * "getuserbase()"

        * "getusersitepackages()"

      * Command Line Interface

  * Custom Python Interpreters

    * "code" --- Interpreter base classes

      * "InteractiveInterpreter"

      * "InteractiveConsole"

      * "interact()"

      * "compile_command()"

      * Interactive Interpreter Objects

        * "InteractiveInterpreter.runsource()"

        * "InteractiveInterpreter.runcode()"

        * "InteractiveInterpreter.showsyntaxerror()"

        * "InteractiveInterpreter.showtraceback()"

        * "InteractiveInterpreter.write()"

      * Interactive Console Objects

        * "InteractiveConsole.interact()"

        * "InteractiveConsole.push()"

        * "InteractiveConsole.resetbuffer()"

        * "InteractiveConsole.raw_input()"

    * "codeop" --- Compile Python code

      * "compile_command()"

      * "Compile"

      * "CommandCompiler"

  * Importing Modules

    * "zipimport" --- Import modules from Zip archives

      * "ZipImportError"

      * zipimporter Objects

        * "zipimporter"

          * "zipimporter.create_module()"

          * "zipimporter.exec_module()"

          * "zipimporter.find_spec()"

          * "zipimporter.get_code()"

          * "zipimporter.get_data()"

          * "zipimporter.get_filename()"

          * "zipimporter.get_source()"

          * "zipimporter.is_package()"

          * "zipimporter.load_module()"

          * "zipimporter.invalidate_caches()"

          * "zipimporter.archive"

          * "zipimporter.prefix"

      * Examples

    * "pkgutil" --- Package extension utility

      * "ModuleInfo"

      * "extend_path()"

      * "find_loader()"

      * "get_importer()"

      * "get_loader()"

      * "iter_importers()"

      * "iter_modules()"

      * "walk_packages()"

      * "get_data()"

      * "resolve_name()"

    * "modulefinder" --- Find modules used by a script

      * "AddPackagePath()"

      * "ReplacePackage()"

      * "ModuleFinder"

        * "ModuleFinder.report()"

        * "ModuleFinder.run_script()"

        * "ModuleFinder.modules"

      * Example usage of "ModuleFinder"

    * "runpy" --- Locating and executing Python modules

      * "run_module()"

      * "run_path()"

    * "importlib" --- The implementation of "import"

      * Introduction

      * Functions

        * "__import__()"

        * "import_module()"

        * "invalidate_caches()"

        * "reload()"

      * "importlib.abc" -- Abstract base classes related to import

        * "MetaPathFinder"

          * "MetaPathFinder.find_spec()"

          * "MetaPathFinder.invalidate_caches()"

        * "PathEntryFinder"

          * "PathEntryFinder.find_spec()"

          * "PathEntryFinder.invalidate_caches()"

        * "Loader"

          * "Loader.create_module()"

          * "Loader.exec_module()"

          * "Loader.load_module()"

        * "ResourceLoader"

          * "ResourceLoader.get_data()"

        * "InspectLoader"

          * "InspectLoader.get_code()"

          * "InspectLoader.get_source()"

          * "InspectLoader.is_package()"

          * "InspectLoader.source_to_code()"

          * "InspectLoader.exec_module()"

          * "InspectLoader.load_module()"

        * "ExecutionLoader"

          * "ExecutionLoader.get_filename()"

        * "FileLoader"

          * "FileLoader.name"

          * "FileLoader.path"

          * "FileLoader.load_module()"

          * "FileLoader.get_filename()"

          * "FileLoader.get_data()"

        * "SourceLoader"

          * "SourceLoader.path_stats()"

          * "SourceLoader.path_mtime()"

          * "SourceLoader.set_data()"

          * "SourceLoader.get_code()"

          * "SourceLoader.exec_module()"

          * "SourceLoader.load_module()"

          * "SourceLoader.get_source()"

          * "SourceLoader.is_package()"

        * "ResourceReader"

          * "ResourceReader.open_resource()"

          * "ResourceReader.resource_path()"

          * "ResourceReader.is_resource()"

          * "ResourceReader.contents()"

        * "Traversable"

          * "Traversable.name"

          * "Traversable.iterdir()"

          * "Traversable.is_dir()"

          * "Traversable.is_file()"

          * "Traversable.joinpath()"

          * "Traversable.__truediv__()"

          * "Traversable.open()"

          * "Traversable.read_bytes()"

          * "Traversable.read_text()"

        * "TraversableResources"

          * "TraversableResources.files()"

      * "importlib.machinery" -- Importers and path hooks

        * "SOURCE_SUFFIXES"

        * "DEBUG_BYTECODE_SUFFIXES"

        * "OPTIMIZED_BYTECODE_SUFFIXES"

        * "BYTECODE_SUFFIXES"

        * "EXTENSION_SUFFIXES"

        * "all_suffixes()"

        * "BuiltinImporter"

        * "FrozenImporter"

        * "WindowsRegistryFinder"

        * "PathFinder"

          * "PathFinder.find_spec()"

          * "PathFinder.invalidate_caches()"

        * "FileFinder"

          * "FileFinder.path"

          * "FileFinder.find_spec()"

          * "FileFinder.invalidate_caches()"

          * "FileFinder.path_hook()"

        * "SourceFileLoader"

          * "SourceFileLoader.name"

          * "SourceFileLoader.path"

          * "SourceFileLoader.is_package()"

          * "SourceFileLoader.path_stats()"

          * "SourceFileLoader.set_data()"

          * "SourceFileLoader.load_module()"

        * "SourcelessFileLoader"

          * "SourcelessFileLoader.name"

          * "SourcelessFileLoader.path"

          * "SourcelessFileLoader.is_package()"

          * "SourcelessFileLoader.get_code()"

          * "SourcelessFileLoader.get_source()"

          * "SourcelessFileLoader.load_module()"

        * "ExtensionFileLoader"

          * "ExtensionFileLoader.name"

          * "ExtensionFileLoader.path"

          * "ExtensionFileLoader.create_module()"

          * "ExtensionFileLoader.exec_module()"

          * "ExtensionFileLoader.is_package()"

          * "ExtensionFileLoader.get_code()"

          * "ExtensionFileLoader.get_source()"

          * "ExtensionFileLoader.get_filename()"

        * "ModuleSpec"

          * "ModuleSpec.name"

          * "ModuleSpec.loader"

          * "ModuleSpec.origin"

          * "ModuleSpec.submodule_search_locations"

          * "ModuleSpec.loader_state"

          * "ModuleSpec.cached"

          * "ModuleSpec.parent"

          * "ModuleSpec.has_location"

      * "importlib.util" -- Utility code for importers

        * "MAGIC_NUMBER"

        * "cache_from_source()"

        * "source_from_cache()"

        * "decode_source()"

        * "resolve_name()"

        * "find_spec()"

        * "module_from_spec()"

        * "spec_from_loader()"

        * "spec_from_file_location()"

        * "source_hash()"

        * "_incompatible_extension_module_restrictions()"

        * "LazyLoader"

          * "LazyLoader.factory()"

      * 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()"

    * "importlib.resources" -- Package resource reading, opening and
      access

      * "Anchor"

      * "files()"

      * "as_file()"

    * "importlib.resources.abc" -- Abstract base classes for resources

      * "ResourceReader"

        * "ResourceReader.open_resource()"

        * "ResourceReader.resource_path()"

        * "ResourceReader.is_resource()"

        * "ResourceReader.contents()"

      * "Traversable"

        * "Traversable.name"

        * "Traversable.iterdir()"

        * "Traversable.is_dir()"

        * "Traversable.is_file()"

        * "Traversable.joinpath()"

        * "Traversable.__truediv__()"

        * "Traversable.open()"

        * "Traversable.read_bytes()"

        * "Traversable.read_text()"

      * "TraversableResources"

        * "TraversableResources.files()"

    * "importlib.metadata" -- Accessing package metadata

      * Overview

      * Functional API

        * Entry points

        * Distribution metadata

        * Distribution versions

        * Distribution files

        * Distribution requirements

        * Mapping import to distribution packages

      * Distributions

      * Distribution Discovery

      * Extending the search algorithm

    * The initialization of the "sys.path" module search path

      * Virtual environments

      * _pth files

      * Embedded Python

  * Python Language Services

    * "ast" --- Abstract Syntax Trees

      * Abstract Grammar

      * Node classes

        * "AST"

          * "AST._fields"

          * "AST.lineno"

          * "AST.col_offset"

          * "AST.end_lineno"

          * "AST.end_col_offset"

        * Root nodes

          * "Module"

          * "Expression"

          * "Interactive"

          * "FunctionType"

        * Literals

          * "Constant"

          * "FormattedValue"

          * "JoinedStr"

          * "List"

          * "Tuple"

          * "Set"

          * "Dict"

        * Variables

          * "Name"

          * "Load"

          * "Store"

          * "Del"

          * "Starred"

        * Expressions

          * "Expr"

          * "UnaryOp"

          * "UAdd"

          * "USub"

          * "Not"

          * "Invert"

          * "BinOp"

          * "Add"

          * "Sub"

          * "Mult"

          * "Div"

          * "FloorDiv"

          * "Mod"

          * "Pow"

          * "LShift"

          * "RShift"

          * "BitOr"

          * "BitXor"

          * "BitAnd"

          * "MatMult"

          * "BoolOp"

          * "And"

          * "Or"

          * "Compare"

          * "Eq"

          * "NotEq"

          * "Lt"

          * "LtE"

          * "Gt"

          * "GtE"

          * "Is"

          * "IsNot"

          * "In"

          * "NotIn"

          * "Call"

          * "keyword"

          * "IfExp"

          * "Attribute"

          * "NamedExpr"

          * Subscripting

            * "Subscript"

            * "Slice"

          * Comprehensions

            * "ListComp"

            * "SetComp"

            * "GeneratorExp"

            * "DictComp"

            * "comprehension"

        * Statements

          * "Assign"

            * "Assign.type_comment"

          * "AnnAssign"

          * "AugAssign"

          * "Raise"

          * "Assert"

          * "Delete"

          * "Pass"

          * "TypeAlias"

          * Imports

            * "Import"

            * "ImportFrom"

            * "alias"

        * Control flow

          * "If"

          * "For"

            * "For.type_comment"

          * "While"

          * "Break"

          * "Continue"

          * "Try"

          * "TryStar"

          * "ExceptHandler"

          * "With"

            * "With.type_comment"

          * "withitem"

        * Pattern matching

          * "Match"

          * "match_case"

          * "MatchValue"

          * "MatchSingleton"

          * "MatchSequence"

          * "MatchStar"

          * "MatchMapping"

          * "MatchClass"

          * "MatchAs"

          * "MatchOr"

        * Type parameters

          * "TypeVar"

          * "ParamSpec"

          * "TypeVarTuple"

        * Function and class definitions

          * "FunctionDef"

            * "FunctionDef.type_comment"

          * "Lambda"

          * "arguments"

          * "arg"

            * "arg.type_comment"

          * "Return"

          * "Yield"

          * "YieldFrom"

          * "Global"

          * "Nonlocal"

          * "ClassDef"

        * Async and await

          * "AsyncFunctionDef"

          * "Await"

          * "AsyncFor"

          * "AsyncWith"

      * "ast" Helpers

        * "parse()"

        * "unparse()"

        * "literal_eval()"

        * "get_docstring()"

        * "get_source_segment()"

        * "fix_missing_locations()"

        * "increment_lineno()"

        * "copy_location()"

        * "iter_fields()"

        * "iter_child_nodes()"

        * "walk()"

        * "NodeVisitor"

          * "NodeVisitor.visit()"

          * "NodeVisitor.generic_visit()"

        * "NodeTransformer"

        * "dump()"

      * Compiler Flags

        * "PyCF_ALLOW_TOP_LEVEL_AWAIT"

        * "PyCF_ONLY_AST"

        * "PyCF_TYPE_COMMENTS"

      * Command-Line Usage

    * "symtable" --- Access to the compiler's symbol tables

      * Generating Symbol Tables

        * "symtable()"

      * Examining Symbol Tables

        * "SymbolTable"

          * "SymbolTable.get_type()"

          * "SymbolTable.get_id()"

          * "SymbolTable.get_name()"

          * "SymbolTable.get_lineno()"

          * "SymbolTable.is_optimized()"

          * "SymbolTable.is_nested()"

          * "SymbolTable.has_children()"

          * "SymbolTable.get_identifiers()"

          * "SymbolTable.lookup()"

          * "SymbolTable.get_symbols()"

          * "SymbolTable.get_children()"

        * "Function"

          * "Function.get_parameters()"

          * "Function.get_locals()"

          * "Function.get_globals()"

          * "Function.get_nonlocals()"

          * "Function.get_frees()"

        * "Class"

          * "Class.get_methods()"

        * "Symbol"

          * "Symbol.get_name()"

          * "Symbol.is_referenced()"

          * "Symbol.is_imported()"

          * "Symbol.is_parameter()"

          * "Symbol.is_global()"

          * "Symbol.is_nonlocal()"

          * "Symbol.is_declared_global()"

          * "Symbol.is_local()"

          * "Symbol.is_annotated()"

          * "Symbol.is_free()"

          * "Symbol.is_assigned()"

          * "Symbol.is_namespace()"

          * "Symbol.get_namespaces()"

          * "Symbol.get_namespace()"

    * "token" --- Constants used with Python parse trees

      * "tok_name"

      * "ISTERMINAL()"

      * "ISNONTERMINAL()"

      * "ISEOF()"

      * "ENDMARKER"

      * "NAME"

      * "NUMBER"

      * "STRING"

      * "NEWLINE"

      * "INDENT"

      * "DEDENT"

      * "LPAR"

      * "RPAR"

      * "LSQB"

      * "RSQB"

      * "COLON"

      * "COMMA"

      * "SEMI"

      * "PLUS"

      * "MINUS"

      * "STAR"

      * "SLASH"

      * "VBAR"

      * "AMPER"

      * "LESS"

      * "GREATER"

      * "EQUAL"

      * "DOT"

      * "PERCENT"

      * "LBRACE"

      * "RBRACE"

      * "EQEQUAL"

      * "NOTEQUAL"

      * "LESSEQUAL"

      * "GREATEREQUAL"

      * "TILDE"

      * "CIRCUMFLEX"

      * "LEFTSHIFT"

      * "RIGHTSHIFT"

      * "DOUBLESTAR"

      * "PLUSEQUAL"

      * "MINEQUAL"

      * "STAREQUAL"

      * "SLASHEQUAL"

      * "PERCENTEQUAL"

      * "AMPEREQUAL"

      * "VBAREQUAL"

      * "CIRCUMFLEXEQUAL"

      * "LEFTSHIFTEQUAL"

      * "RIGHTSHIFTEQUAL"

      * "DOUBLESTAREQUAL"

      * "DOUBLESLASH"

      * "DOUBLESLASHEQUAL"

      * "AT"

      * "ATEQUAL"

      * "RARROW"

      * "ELLIPSIS"

      * "COLONEQUAL"

      * "EXCLAMATION"

      * "OP"

      * "TYPE_IGNORE"

      * "TYPE_COMMENT"

      * "SOFT_KEYWORD"

      * "FSTRING_START"

      * "FSTRING_MIDDLE"

      * "FSTRING_END"

      * "COMMENT"

      * "NL"

      * "ERRORTOKEN"

      * "N_TOKENS"

      * "NT_OFFSET"

      * "ENCODING"

    * "keyword" --- Testing for Python keywords

      * "iskeyword()"

      * "kwlist"

      * "issoftkeyword()"

      * "softkwlist"

    * "tokenize" --- Tokenizer for Python source

      * Tokenizing Input

        * "tokenize()"

        * "generate_tokens()"

        * "untokenize()"

        * "detect_encoding()"

        * "open()"

        * "TokenError"

      * Command-Line Usage

      * Examples

    * "tabnanny" --- Detection of ambiguous indentation

      * "check()"

      * "verbose"

      * "filename_only"

      * "NannyNag"

      * "process_tokens()"

    * "pyclbr" --- Python module browser support

      * "readmodule()"

      * "readmodule_ex()"

      * Function Objects

        * "Function.file"

        * "Function.module"

        * "Function.name"

        * "Function.lineno"

        * "Function.parent"

        * "Function.children"

        * "Function.is_async"

      * Class Objects

        * "Class.file"

        * "Class.module"

        * "Class.name"

        * "Class.lineno"

        * "Class.parent"

        * "Class.children"

        * "Class.super"

        * "Class.methods"

    * "py_compile" --- Compile Python source files

      * "PyCompileError"

      * "compile()"

      * "PycInvalidationMode"

        * "PycInvalidationMode.TIMESTAMP"

        * "PycInvalidationMode.CHECKED_HASH"

        * "PycInvalidationMode.UNCHECKED_HASH"

      * Command-Line Interface

    * "compileall" --- Byte-compile Python libraries

      * Command-line use

      * Public functions

        * "compile_dir()"

        * "compile_file()"

        * "compile_path()"

    * "dis" --- Disassembler for Python bytecode

      * Command-line interface

      * Bytecode analysis

        * "Bytecode"

          * "Bytecode.from_traceback()"

          * "Bytecode.codeobj"

          * "Bytecode.first_line"

          * "Bytecode.dis()"

          * "Bytecode.info()"

      * Analysis functions

        * "code_info()"

        * "show_code()"

        * "dis()"

        * "distb()"

        * "disassemble()"

        * "disco()"

        * "get_instructions()"

        * "findlinestarts()"

        * "findlabels()"

        * "stack_effect()"

      * Python Bytecode Instructions

        * "Instruction"

          * "Instruction.opcode"

          * "Instruction.opname"

          * "Instruction.baseopcode"

          * "Instruction.baseopname"

          * "Instruction.arg"

          * "Instruction.oparg"

          * "Instruction.argval"

          * "Instruction.argrepr"

          * "Instruction.offset"

          * "Instruction.start_offset"

          * "Instruction.cache_offset"

          * "Instruction.end_offset"

          * "Instruction.starts_line"

          * "Instruction.line_number"

          * "Instruction.is_jump_target"

          * "Instruction.jump_target"

          * "Instruction.positions"

        * "Positions"

          * "Positions.lineno"

          * "Positions.end_lineno"

          * "Positions.col_offset"

          * "Positions.end_col_offset"

      * Opcode collections

        * "opname"

        * "opmap"

        * "cmp_op"

        * "hasarg"

        * "hasconst"

        * "hasfree"

        * "hasname"

        * "hasjump"

        * "haslocal"

        * "hascompare"

        * "hasexc"

        * "hasjrel"

        * "hasjabs"

    * "pickletools" --- Tools for pickle developers

      * Command line usage

        * Command line options

      * Programmatic Interface

        * "dis()"

        * "genops()"

        * "optimize()"

  * MS Windows Specific Services

    * "msvcrt" --- Useful routines from the MS VC++ runtime

      * File Operations

        * "locking()"

        * "LK_LOCK"

        * "LK_RLCK"

        * "LK_NBLCK"

        * "LK_NBRLCK"

        * "LK_UNLCK"

        * "setmode()"

        * "open_osfhandle()"

        * "get_osfhandle()"

      * Console I/O

        * "kbhit()"

        * "getch()"

        * "getwch()"

        * "getche()"

        * "getwche()"

        * "putch()"

        * "putwch()"

        * "ungetch()"

        * "ungetwch()"

      * Other Functions

        * "heapmin()"

        * "set_error_mode()"

        * "OUT_TO_DEFAULT"

        * "OUT_TO_STDERR"

        * "OUT_TO_MSGBOX"

        * "REPORT_ERRMODE"

        * "CrtSetReportMode()"

        * "CrtSetReportFile()"

        * "CRT_WARN"

        * "CRT_ERROR"

        * "CRT_ASSERT"

        * "CRTDBG_MODE_DEBUG"

        * "CRTDBG_MODE_FILE"

        * "CRTDBG_MODE_WNDW"

        * "CRTDBG_REPORT_MODE"

    * "winreg" --- Windows registry access

      * Functions

        * "CloseKey()"

        * "ConnectRegistry()"

        * "CreateKey()"

        * "CreateKeyEx()"

        * "DeleteKey()"

        * "DeleteKeyEx()"

        * "DeleteValue()"

        * "EnumKey()"

        * "EnumValue()"

        * "ExpandEnvironmentStrings()"

        * "FlushKey()"

        * "LoadKey()"

        * "OpenKey()"

        * "OpenKeyEx()"

        * "QueryInfoKey()"

        * "QueryValue()"

        * "QueryValueEx()"

        * "SaveKey()"

        * "SetValue()"

        * "SetValueEx()"

        * "DisableReflectionKey()"

        * "EnableReflectionKey()"

        * "QueryReflectionKey()"

      * Constants

        * HKEY_* Constants

          * "HKEY_CLASSES_ROOT"

          * "HKEY_CURRENT_USER"

          * "HKEY_LOCAL_MACHINE"

          * "HKEY_USERS"

          * "HKEY_PERFORMANCE_DATA"

          * "HKEY_CURRENT_CONFIG"

          * "HKEY_DYN_DATA"

        * Access Rights

          * "KEY_ALL_ACCESS"

          * "KEY_WRITE"

          * "KEY_READ"

          * "KEY_EXECUTE"

          * "KEY_QUERY_VALUE"

          * "KEY_SET_VALUE"

          * "KEY_CREATE_SUB_KEY"

          * "KEY_ENUMERATE_SUB_KEYS"

          * "KEY_NOTIFY"

          * "KEY_CREATE_LINK"

          * 64-bit Specific

            * "KEY_WOW64_64KEY"

            * "KEY_WOW64_32KEY"

        * Value Types

          * "REG_BINARY"

          * "REG_DWORD"

          * "REG_DWORD_LITTLE_ENDIAN"

          * "REG_DWORD_BIG_ENDIAN"

          * "REG_EXPAND_SZ"

          * "REG_LINK"

          * "REG_MULTI_SZ"

          * "REG_NONE"

          * "REG_QWORD"

          * "REG_QWORD_LITTLE_ENDIAN"

          * "REG_RESOURCE_LIST"

          * "REG_FULL_RESOURCE_DESCRIPTOR"

          * "REG_RESOURCE_REQUIREMENTS_LIST"

          * "REG_SZ"

      * Registry Handle Objects

        * "PyHKEY.Close()"

        * "PyHKEY.Detach()"

        * "PyHKEY.__enter__()"

        * "PyHKEY.__exit__()"

    * "winsound" --- Sound-playing interface for Windows

      * "Beep()"

      * "PlaySound()"

      * "MessageBeep()"

      * "SND_FILENAME"

      * "SND_ALIAS"

      * "SND_LOOP"

      * "SND_MEMORY"

      * "SND_PURGE"

      * "SND_ASYNC"

      * "SND_NODEFAULT"

      * "SND_NOSTOP"

      * "SND_NOWAIT"

      * "MB_ICONASTERISK"

      * "MB_ICONEXCLAMATION"

      * "MB_ICONHAND"

      * "MB_ICONQUESTION"

      * "MB_OK"

  * Unix Specific Services

    * "posix" --- The most common POSIX system calls

      * Large File Support

      * Notable Module Contents

        * "environ"

    * "pwd" --- The password database

      * "getpwuid()"

      * "getpwnam()"

      * "getpwall()"

    * "grp" --- The group database

      * "getgrgid()"

      * "getgrnam()"

      * "getgrall()"

    * "termios" --- POSIX style tty control

      * "tcgetattr()"

      * "tcsetattr()"

      * "tcsendbreak()"

      * "tcdrain()"

      * "tcflush()"

      * "tcflow()"

      * "tcgetwinsize()"

      * "tcsetwinsize()"

      * Example

    * "tty" --- Terminal control functions

      * "cfmakeraw()"

      * "cfmakecbreak()"

      * "setraw()"

      * "setcbreak()"

    * "pty" --- Pseudo-terminal utilities

      * "fork()"

      * "openpty()"

      * "spawn()"

      * Example

    * "fcntl" --- The "fcntl" and "ioctl" system calls

      * "fcntl()"

      * "ioctl()"

      * "flock()"

      * "lockf()"

    * "resource" --- Resource usage information

      * "error"

      * Resource Limits

        * "RLIM_INFINITY"

        * "getrlimit()"

        * "setrlimit()"

        * "prlimit()"

        * "RLIMIT_CORE"

        * "RLIMIT_CPU"

        * "RLIMIT_FSIZE"

        * "RLIMIT_DATA"

        * "RLIMIT_STACK"

        * "RLIMIT_RSS"

        * "RLIMIT_NPROC"

        * "RLIMIT_NOFILE"

        * "RLIMIT_OFILE"

        * "RLIMIT_MEMLOCK"

        * "RLIMIT_VMEM"

        * "RLIMIT_AS"

        * "RLIMIT_MSGQUEUE"

        * "RLIMIT_NICE"

        * "RLIMIT_RTPRIO"

        * "RLIMIT_RTTIME"

        * "RLIMIT_SIGPENDING"

        * "RLIMIT_SBSIZE"

        * "RLIMIT_SWAP"

        * "RLIMIT_NPTS"

        * "RLIMIT_KQUEUES"

      * Resource Usage

        * "getrusage()"

        * "getpagesize()"

        * "RUSAGE_SELF"

        * "RUSAGE_CHILDREN"

        * "RUSAGE_BOTH"

        * "RUSAGE_THREAD"

    * "syslog" --- Unix syslog library routines

      * "syslog()"

      * "openlog()"

      * "closelog()"

      * "setlogmask()"

      * Examples

        * Simple example

  * Modules command-line interface (CLI)

  * Superseded Modules

    * "getopt" --- C-style parser for command line options

      * "getopt()"

      * "gnu_getopt()"

      * "GetoptError"

      * "error"

    * "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

            * "OptionGroup"

            * "OptionParser.get_option_group()"

        * Printing a version string

          * "OptionParser.print_version()"

          * "OptionParser.get_version()"

        * How "optparse" handles errors

        * Putting it all together

      * Reference Guide

        * Creating the parser

          * "OptionParser"

        * Populating the parser

        * Defining options

          * "OptionParser.add_option()"

          * "Values"

        * Option attributes

          * "Option"

            * "Option.action"

            * "Option.type"

            * "Option.dest"

            * "Option.default"

            * "Option.nargs"

            * "Option.const"

            * "Option.choices"

            * "Option.callback"

            * "Option.callback_args"

            * "Option.callback_kwargs"

            * "Option.help"

            * "Option.metavar"

        * Standard option actions

        * Standard option types

        * Parsing arguments

          * "OptionParser.parse_args()"

        * Querying and manipulating your option parser

          * "OptionParser.disable_interspersed_args()"

          * "OptionParser.enable_interspersed_args()"

          * "OptionParser.get_option()"

          * "OptionParser.has_option()"

          * "OptionParser.remove_option()"

        * Conflicts between options

        * Cleanup

        * Other methods

          * "OptionParser.set_usage()"

          * "OptionParser.print_usage()"

          * "OptionParser.get_usage()"

          * "OptionParser.set_defaults()"

      * 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

          * "Option.TYPES"

          * "Option.TYPE_CHECKER"

        * Adding new actions

          * "Option.ACTIONS"

          * "Option.STORE_ACTIONS"

          * "Option.TYPED_ACTIONS"

          * "Option.ALWAYS_TYPED_ACTIONS"

      * Exceptions

        * "OptionError"

        * "OptionConflictError"

        * "OptionValueError"

        * "BadOptionError"

        * "AmbiguousOptionError"

  * 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 setuptools

    * 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

    * Unstable C API

    * Stable Application Binary Interface

      * Limited C API

      * Stable ABI

      * 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

    * Support for Perf Maps

  * 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

  * Concrete Objects Layer

    * Fundamental Objects

      * Type Objects

        * Creating Heap-Allocated Types

      * The "None" Object

    * Numeric Objects

      * Integer Objects

      * Boolean Objects

      * Floating Point Objects

        * Pack and Unpack functions

          * Pack functions

          * Unpack functions

      * 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

          * 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

      * Extra information

    * 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

      * Frame Objects

        * Internal Frames

      * 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

      * A Per-Interpreter GIL

      * 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

        * Member flags

        * Member types

        * Defining Getters and Setters

    * 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

      * Querying Garbage Collector State

  * API and ABI Versioning

* 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

  * How to port Python 2 Code to Python 3

    * The Short Explanation

    * Details

      * Different versions of Python 2

      * Make sure you specify the proper version support in your
        "setup.py" file

      * Have good test coverage

      * Be aware of the differences between Python 2 and 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__

  * Enum HOWTO

    * 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

    * Dataclass support

    * Pickling

    * Functional API

    * Derived Enumerations

      * IntEnum

      * StrEnum

      * IntFlag

      * Flag

      * Others

    * When to use "__new__()" vs. "__init__()"

      * Finer Points

        * Supported "__dunder__" names

        * Supported "_sunder_" names

        * _Private__names

        * "Enum" member type

        * Creating members that are mixed with other data types

        * Boolean value of "Enum" classes and members

        * "Enum" classes with methods

        * Combining members of "Flag"

        * "Flag" and "IntFlag" minutia

    * How are Enums and Flags different?

      * Enum Classes

      * Flag Classes

      * Enum Members (aka instances)

      * Flag Members

    * Enum Cookbook

      * Omitting values

        * Using "auto"

        * Using "object"

        * Using a descriptive string

        * Using a custom "__new__()"

      * OrderedEnum

      * DuplicateFreeEnum

      * Planet

      * TimePeriod

    * Subclassing EnumType

  * 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

        * "logging.Formatter.__init__()"

      * 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

    * Other resources

  * Logging Cookbook

    * Using logging in multiple modules

    * Logging from multiple threads

    * Multiple handlers and formatters

    * Logging to multiple destinations

    * Custom handling of levels

    * 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

    * Use of "contextvars"

    * Imparting contextual information in handlers

    * 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

    * Sending logging messages to email, with buffering

    * Formatting times using UTC (GMT) via configuration

    * Using a context manager for selective logging

    * A CLI application starter template

    * A Qt GUI for logging

    * Logging to syslog with RFC5424 support

    * How to treat a logger like an output stream

    * 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

    * Other resources

  * 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

    * Decorate-Sort-Undecorate

    * Comparison Functions

    * Odds 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

      * Specifying ambiguous arguments

      * Conflicting options

    * How to translate the argparse output

    * 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

  * Instrumenting CPython with DTrace and SystemTap

    * Enabling the static markers

    * Static DTrace probes

    * Static SystemTap markers

    * Available static markers

    * SystemTap Tapsets

    * Examples

  * Python support for the Linux "perf" profiler

    * How to enable "perf" profiling support

    * How to obtain the best results

  * 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

  * Isolating Extension Modules

    * Who should read this

    * Background

      * Enter Per-Module State

      * Isolated Module Objects

      * Surprising Edge Cases

    * Making Modules Safe with Multiple Interpreters

      * Managing Global State

      * Managing Per-Module State

      * Opt-Out: Limiting to One Module Object per Process

      * Module State Access from Functions

    * Heap Types

      * Changing Static Types to Heap Types

      * Defining Heap Types

      * Garbage-Collection Protocol

      * Module State Access from Classes

      * Module State Access from Regular Methods

      * Module State Access from Slot Methods, Getters and Setters

      * Lifetime of the Module State

    * Open Issues

      * Per-Class Scope

      * Lossless Conversion to Heap Types

  * timer file descriptor HOWTO

    * Examples

* 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?

    * How do I solve the missing api-ms-win-crt-runtime-l1-1-0.dll
      error?

  * 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.13.0a0

    * 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.13.0a0
      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
