python_doc_md/Beginner/whatsnew/3.9.md

# What\'s New In Python 3.9

Editor
:   Łukasz Langa

> \* Anyone can add text to this document. Your text might get rewritten to some degree.
>
> \* The maintainer will go through Misc/NEWS periodically and add changes; it\'s therefore more important to add your changes to Misc/NEWS than to this file.
>
> \* This is not a complete list of every single change; completeness is the purpose of Misc/NEWS. Some changes will be too small or esoteric to include. If such a change is added to the text, it might get removed during final editing.
>
> \* If you want to draw your new text to the attention of the maintainer, add \'XXX\' to the beginning of the paragraph or section.
>
> \* It\'s OK to just add a fragmentary note about a change. For example: \"XXX Describe the transmogrify() function added to the socket module.\" The maintainer will research the change and write the necessary text.
>
> \* You can comment out your additions if you like, but it\'s not necessary (especially when a final release is some months away).
>
> \* Credit the author of a patch or bugfix. Just the name is sufficient; the e-mail address isn\'t necessary.
>
> - It\'s helpful to add the bug/patch number as a comment:
>
> XXX Describe the transmogrify() function added to the socket module. (Contributed by P.Y. Developer in `12345`{.interpreted-text role="issue"}.)
>
> This saves the maintainer the effort of going through the Mercurial log when researching a change.

This article explains the new features in Python 3.9, compared to 3.8. Python 3.9 was released on October 5, 2020. For full details, see the `changelog <changelog>`{.interpreted-text role="ref"}.

::: seealso
`596`{.interpreted-text role="pep"} - Python 3.9 Release Schedule
:::

## Summary \-- Release highlights

New syntax features:

- `584`{.interpreted-text role="pep"}, union operators added to `dict`;
- `585`{.interpreted-text role="pep"}, type hinting generics in standard collections;
- `614`{.interpreted-text role="pep"}, relaxed grammar restrictions on decorators.

New built-in features:

- `616`{.interpreted-text role="pep"}, string methods to remove prefixes and suffixes.

New features in the standard library:

- `593`{.interpreted-text role="pep"}, flexible function and variable annotations;
- `os.pidfd_open`{.interpreted-text role="func"} added that allows process management without races and signals.

Interpreter improvements:

- `573`{.interpreted-text role="pep"}, fast access to module state from methods of C extension types;
- `617`{.interpreted-text role="pep"}, CPython now uses a new parser based on PEG;
- a number of Python builtins (range, tuple, set, frozenset, list, dict) are now sped up using `590`{.interpreted-text role="pep"} vectorcall;
- garbage collection does not block on resurrected objects;
- a number of Python modules (`!_abc`{.interpreted-text role="mod"}, `!audioop`{.interpreted-text role="mod"}, `!_bz2`{.interpreted-text role="mod"}, `!_codecs`{.interpreted-text role="mod"}, `!_contextvars`{.interpreted-text role="mod"}, `!_crypt`{.interpreted-text role="mod"}, `!_functools`{.interpreted-text role="mod"}, `!_json`{.interpreted-text role="mod"}, `!_locale`{.interpreted-text role="mod"}, `math`{.interpreted-text role="mod"}, `operator`{.interpreted-text role="mod"}, `resource`{.interpreted-text role="mod"}, `time`{.interpreted-text role="mod"}, `!_weakref`{.interpreted-text role="mod"}) now use multiphase initialization as defined by PEP 489;
- a number of standard library modules (`!audioop`{.interpreted-text role="mod"}, `ast`{.interpreted-text role="mod"}, `grp`{.interpreted-text role="mod"}, `!_hashlib`{.interpreted-text role="mod"}, `pwd`{.interpreted-text role="mod"}, `!_posixsubprocess`{.interpreted-text role="mod"}, `random`{.interpreted-text role="mod"}, `select`{.interpreted-text role="mod"}, `struct`{.interpreted-text role="mod"}, `termios`{.interpreted-text role="mod"}, `zlib`{.interpreted-text role="mod"}) are now using the stable ABI defined by PEP 384.

New library modules:

- `615`{.interpreted-text role="pep"}, the IANA Time Zone Database is now present in the standard library in the `zoneinfo`{.interpreted-text role="mod"} module;
- an implementation of a topological sort of a graph is now provided in the new `graphlib`{.interpreted-text role="mod"} module.

Release process changes:

- `602`{.interpreted-text role="pep"}, CPython adopts an annual release cycle.

## You should check for DeprecationWarning in your code

When Python 2.7 was still supported, a lot of functionality in Python 3 was kept for backward compatibility with Python 2.7. With the end of Python 2 support, these backward compatibility layers have been removed, or will be removed soon. Most of them emitted a `DeprecationWarning`{.interpreted-text role="exc"} warning for several years. For example, using `collections.Mapping` instead of `collections.abc.Mapping` emits a `DeprecationWarning`{.interpreted-text role="exc"} since Python 3.3, released in 2012.

Test your application with the `-W`{.interpreted-text role="option"} `default` command-line option to see `DeprecationWarning`{.interpreted-text role="exc"} and `PendingDeprecationWarning`{.interpreted-text role="exc"}, or even with `-W`{.interpreted-text role="option"} `error` to treat them as errors. `Warnings Filter
<warning-filter>`{.interpreted-text role="ref"} can be used to ignore warnings from third-party code.

Python 3.9 is the last version providing those Python 2 backward compatibility layers, to give more time to Python projects maintainers to organize the removal of the Python 2 support and add support for Python 3.9.

Aliases to `Abstract Base Classes <collections-abstract-base-classes>`{.interpreted-text role="ref"} in the `collections`{.interpreted-text role="mod"} module, like `collections.Mapping` alias to `collections.abc.Mapping`{.interpreted-text role="class"}, are kept for one last release for backward compatibility. They will be removed from Python 3.10.

More generally, try to run your tests in the `Python Development Mode
<devmode>`{.interpreted-text role="ref"} which helps to prepare your code to make it compatible with the next Python version.

Note: a number of pre-existing deprecations were removed in this version of Python as well. Consult the `removed-in-python-39`{.interpreted-text role="ref"} section.

## New Features

### Dictionary Merge & Update Operators

Merge (`|`) and update (`|=`) operators have been added to the built-in `dict`{.interpreted-text role="class"} class. Those complement the existing `dict.update` and `{**d1, **d2}` methods of merging dictionaries.

Example:

    >>> x = {"key1": "value1 from x", "key2": "value2 from x"}
    >>> y = {"key2": "value2 from y", "key3": "value3 from y"}
    >>> x | y
    {'key1': 'value1 from x', 'key2': 'value2 from y', 'key3': 'value3 from y'}
    >>> y | x
    {'key2': 'value2 from x', 'key3': 'value3 from y', 'key1': 'value1 from x'}

See `584`{.interpreted-text role="pep"} for a full description. (Contributed by Brandt Bucher in `36144`{.interpreted-text role="issue"}.)

### New String Methods to Remove Prefixes and Suffixes

`str.removeprefix(prefix)<str.removeprefix>`{.interpreted-text role="meth"} and `str.removesuffix(suffix)<str.removesuffix>`{.interpreted-text role="meth"} have been added to easily remove an unneeded prefix or a suffix from a string. Corresponding `bytes`, `bytearray`, and `collections.UserString` methods have also been added. See `616`{.interpreted-text role="pep"} for a full description. (Contributed by Dennis Sweeney in `39939`{.interpreted-text role="issue"}.)

### Type Hinting Generics in Standard Collections

In type annotations you can now use built-in collection types such as `list` and `dict` as generic types instead of importing the corresponding capitalized types (e.g. `List` or `Dict`) from `typing`. Some other types in the standard library are also now generic, for example `queue.Queue`.

Example:

``` python
def greet_all(names: list[str]) -> None:
    for name in names:
        print("Hello", name)
```

See `585`{.interpreted-text role="pep"} for more details. (Contributed by Guido van Rossum, Ethan Smith, and Batuhan Taşkaya in `39481`{.interpreted-text role="issue"}.)

### New Parser

Python 3.9 uses a new parser, based on [PEG](https://en.wikipedia.org/wiki/Parsing_expression_grammar) instead of [LL(1)](https://en.wikipedia.org/wiki/LL_parser). The new parser\'s performance is roughly comparable to that of the old parser, but the PEG formalism is more flexible than LL(1) when it comes to designing new language features. We\'ll start using this flexibility in Python 3.10 and later.

The `ast`{.interpreted-text role="mod"} module uses the new parser and produces the same AST as the old parser.

In Python 3.10, the old parser will be deleted and so will all functionality that depends on it (primarily the `!parser`{.interpreted-text role="mod"} module, which has long been deprecated). In Python 3.9 *only*, you can switch back to the LL(1) parser using a command line switch (`-X oldparser`) or an environment variable (`PYTHONOLDPARSER=1`).

See `617`{.interpreted-text role="pep"} for more details. (Contributed by Guido van Rossum, Pablo Galindo and Lysandros Nikolaou in `40334`{.interpreted-text role="issue"}.)

## Other Language Changes

- `__import__`{.interpreted-text role="func"} now raises `ImportError`{.interpreted-text role="exc"} instead of `ValueError`{.interpreted-text role="exc"}, which used to occur when a relative import went past its top-level package. (Contributed by Ngalim Siregar in `37444`{.interpreted-text role="issue"}.)

- Python now gets the absolute path of the script filename specified on the command line (ex: `python3 script.py`): the `__file__` attribute of the `__main__`{.interpreted-text role="mod"} module became an absolute path, rather than a relative path. These paths now remain valid after the current directory is changed by `os.chdir`{.interpreted-text role="func"}. As a side effect, the traceback also displays the absolute path for `__main__`{.interpreted-text role="mod"} module frames in this case. (Contributed by Victor Stinner in `20443`{.interpreted-text role="issue"}.)

- In the `Python Development Mode <devmode>`{.interpreted-text role="ref"} and in `debug build <debug-build>`{.interpreted-text role="ref"}, the *encoding* and *errors* arguments are now checked for string encoding and decoding operations. Examples: `open`{.interpreted-text role="func"}, `str.encode`{.interpreted-text role="meth"} and `bytes.decode`{.interpreted-text role="meth"}.

  By default, for best performance, the *errors* argument is only checked at the first encoding/decoding error and the *encoding* argument is sometimes ignored for empty strings. (Contributed by Victor Stinner in `37388`{.interpreted-text role="issue"}.)

- `"".replace("", s, n)` now returns `s` instead of an empty string for all non-zero `n`. It is now consistent with `"".replace("", s)`. There are similar changes for `bytes`{.interpreted-text role="class"} and `bytearray`{.interpreted-text role="class"} objects. (Contributed by Serhiy Storchaka in `28029`{.interpreted-text role="issue"}.)

- Any valid expression can now be used as a `decorator`{.interpreted-text role="term"}. Previously, the grammar was much more restrictive. See `614`{.interpreted-text role="pep"} for details. (Contributed by Brandt Bucher in `39702`{.interpreted-text role="issue"}.)

- Improved help for the `typing`{.interpreted-text role="mod"} module. Docstrings are now shown for all special forms and special generic aliases (like `Union` and `List`). Using `help`{.interpreted-text role="func"} with generic alias like `List[int]` will show the help for the correspondent concrete type (`list` in this case). (Contributed by Serhiy Storchaka in `40257`{.interpreted-text role="issue"}.)

- Parallel running of `~agen.aclose`{.interpreted-text role="meth"} / `~agen.asend`{.interpreted-text role="meth"} / `~agen.athrow`{.interpreted-text role="meth"} is now prohibited, and `ag_running` now reflects the actual running status of the async generator. (Contributed by Yury Selivanov in `30773`{.interpreted-text role="issue"}.)

- Unexpected errors in calling the `__iter__` method are no longer masked by `TypeError` in the `in`{.interpreted-text role="keyword"} operator and functions `~operator.contains`{.interpreted-text role="func"}, `~operator.indexOf`{.interpreted-text role="func"} and `~operator.countOf`{.interpreted-text role="func"} of the `operator`{.interpreted-text role="mod"} module. (Contributed by Serhiy Storchaka in `40824`{.interpreted-text role="issue"}.)

- Unparenthesized lambda expressions can no longer be the expression part in an `if` clause in comprehensions and generator expressions. See `41848`{.interpreted-text role="issue"} and `43755`{.interpreted-text role="issue"} for details.

## New Modules

### zoneinfo

The `zoneinfo`{.interpreted-text role="mod"} module brings support for the IANA time zone database to the standard library. It adds `zoneinfo.ZoneInfo`{.interpreted-text role="class"}, a concrete `datetime.tzinfo`{.interpreted-text role="class"} implementation backed by the system\'s time zone data.

Example:

    >>> from zoneinfo import ZoneInfo
    >>> from datetime import datetime, timedelta

    >>> # Daylight saving time
    >>> dt = datetime(2020, 10, 31, 12, tzinfo=ZoneInfo("America/Los_Angeles"))
    >>> print(dt)
    2020-10-31 12:00:00-07:00
    >>> dt.tzname()
    'PDT'

    >>> # Standard time
    >>> dt += timedelta(days=7)
    >>> print(dt)
    2020-11-07 12:00:00-08:00
    >>> print(dt.tzname())
    PST

As a fall-back source of data for platforms that don\'t ship the IANA database, the `tzdata`{.interpreted-text role="pypi"} module was released as a first-party package \-- distributed via PyPI and maintained by the CPython core team.

::: seealso

`615`{.interpreted-text role="pep"} \-- Support for the IANA Time Zone Database in the Standard Library

:   PEP written and implemented by Paul Ganssle
:::

### graphlib

A new module, `graphlib`{.interpreted-text role="mod"}, was added that contains the `graphlib.TopologicalSorter`{.interpreted-text role="class"} class to offer functionality to perform topological sorting of graphs. (Contributed by Pablo Galindo, Tim Peters and Larry Hastings in `17005`{.interpreted-text role="issue"}.)

## Improved Modules

### ast

Added the *indent* option to `~ast.dump`{.interpreted-text role="func"} which allows it to produce a multiline indented output. (Contributed by Serhiy Storchaka in `37995`{.interpreted-text role="issue"}.)

Added `ast.unparse`{.interpreted-text role="func"} as a function in the `ast`{.interpreted-text role="mod"} module that can be used to unparse an `ast.AST`{.interpreted-text role="class"} object and produce a string with code that would produce an equivalent `ast.AST`{.interpreted-text role="class"} object when parsed. (Contributed by Pablo Galindo and Batuhan Taskaya in `38870`{.interpreted-text role="issue"}.)

Added docstrings to AST nodes that contains the ASDL signature used to construct that node. (Contributed by Batuhan Taskaya in `39638`{.interpreted-text role="issue"}.)

### asyncio

Due to significant security concerns, the *reuse_address* parameter of `asyncio.loop.create_datagram_endpoint`{.interpreted-text role="meth"} is no longer supported. This is because of the behavior of the socket option `SO_REUSEADDR` in UDP. For more details, see the documentation for `loop.create_datagram_endpoint()`. (Contributed by Kyle Stanley, Antoine Pitrou, and Yury Selivanov in `37228`{.interpreted-text role="issue"}.)

Added a new `coroutine`{.interpreted-text role="term"} `~asyncio.loop.shutdown_default_executor`{.interpreted-text role="meth"} that schedules a shutdown for the default executor that waits on the `~concurrent.futures.ThreadPoolExecutor`{.interpreted-text role="class"} to finish closing. Also, `asyncio.run`{.interpreted-text role="func"} has been updated to use the new `coroutine`{.interpreted-text role="term"}. (Contributed by Kyle Stanley in `34037`{.interpreted-text role="issue"}.)

Added `!asyncio.PidfdChildWatcher`{.interpreted-text role="class"}, a Linux-specific child watcher implementation that polls process file descriptors. (`38692`{.interpreted-text role="issue"})

Added a new `coroutine`{.interpreted-text role="term"} `asyncio.to_thread`{.interpreted-text role="func"}. It is mainly used for running IO-bound functions in a separate thread to avoid blocking the event loop, and essentially works as a high-level version of `~asyncio.loop.run_in_executor`{.interpreted-text role="meth"} that can directly take keyword arguments. (Contributed by Kyle Stanley and Yury Selivanov in `32309`{.interpreted-text role="issue"}.)

When cancelling the task due to a timeout, `asyncio.wait_for`{.interpreted-text role="meth"} will now wait until the cancellation is complete also in the case when *timeout* is \<= 0, like it does with positive timeouts. (Contributed by Elvis Pranskevichus in `32751`{.interpreted-text role="issue"}.)

`asyncio`{.interpreted-text role="mod"} now raises `TypeError`{.interpreted-text role="exc"} when calling incompatible methods with an `ssl.SSLSocket`{.interpreted-text role="class"} socket. (Contributed by Ido Michael in `37404`{.interpreted-text role="issue"}.)

### compileall

Added new possibility to use hardlinks for duplicated `.pyc` files: *hardlink_dupes* parameter and \--hardlink-dupes command line option. (Contributed by Lumír \'Frenzy\' Balhar in `40495`{.interpreted-text role="issue"}.)

Added new options for path manipulation in resulting `.pyc` files: *stripdir*, *prependdir*, *limit_sl_dest* parameters and -s, -p, -e command line options. Added the possibility to specify the option for an optimization level multiple times. (Contributed by Lumír \'Frenzy\' Balhar in `38112`{.interpreted-text role="issue"}.)

### concurrent.futures

Added a new *cancel_futures* parameter to `concurrent.futures.Executor.shutdown`{.interpreted-text role="meth"} that cancels all pending futures which have not started running, instead of waiting for them to complete before shutting down the executor. (Contributed by Kyle Stanley in `39349`{.interpreted-text role="issue"}.)

Removed daemon threads from `~concurrent.futures.ThreadPoolExecutor`{.interpreted-text role="class"} and `~concurrent.futures.ProcessPoolExecutor`{.interpreted-text role="class"}. This improves compatibility with subinterpreters and predictability in their shutdown processes. (Contributed by Kyle Stanley in `39812`{.interpreted-text role="issue"}.)

Workers in `~concurrent.futures.ProcessPoolExecutor`{.interpreted-text role="class"} are now spawned on demand, only when there are no available idle workers to reuse. This optimizes startup overhead and reduces the amount of lost CPU time to idle workers. (Contributed by Kyle Stanley in `39207`{.interpreted-text role="issue"}.)

### curses

Added `curses.get_escdelay`{.interpreted-text role="func"}, `curses.set_escdelay`{.interpreted-text role="func"}, `curses.get_tabsize`{.interpreted-text role="func"}, and `curses.set_tabsize`{.interpreted-text role="func"} functions. (Contributed by Anthony Sottile in `38312`{.interpreted-text role="issue"}.)

### datetime

The `~datetime.date.isocalendar`{.interpreted-text role="meth"} of `datetime.date`{.interpreted-text role="class"} and `~datetime.datetime.isocalendar`{.interpreted-text role="meth"} of `datetime.datetime`{.interpreted-text role="class"} methods now returns a `~collections.namedtuple`{.interpreted-text role="func"} instead of a `tuple`{.interpreted-text role="class"}. (Contributed by Donghee Na in `24416`{.interpreted-text role="issue"}.)

### distutils

The `upload`{.interpreted-text role="command"} command now creates SHA2-256 and Blake2b-256 hash digests. It skips MD5 on platforms that block MD5 digest. (Contributed by Christian Heimes in `40698`{.interpreted-text role="issue"}.)

### fcntl

Added constants `!fcntl.F_OFD_GETLK`{.interpreted-text role="const"}, `!fcntl.F_OFD_SETLK`{.interpreted-text role="const"} and `!fcntl.F_OFD_SETLKW`{.interpreted-text role="const"}. (Contributed by Donghee Na in `38602`{.interpreted-text role="issue"}.)

### ftplib

`~ftplib.FTP`{.interpreted-text role="class"} and `~ftplib.FTP_TLS`{.interpreted-text role="class"} now raise a `ValueError`{.interpreted-text role="class"} if the given timeout for their constructor is zero to prevent the creation of a non-blocking socket. (Contributed by Donghee Na in `39259`{.interpreted-text role="issue"}.)

### gc

When the garbage collector makes a collection in which some objects resurrect (they are reachable from outside the isolated cycles after the finalizers have been executed), do not block the collection of all objects that are still unreachable. (Contributed by Pablo Galindo and Tim Peters in `38379`{.interpreted-text role="issue"}.)

Added a new function `gc.is_finalized`{.interpreted-text role="func"} to check if an object has been finalized by the garbage collector. (Contributed by Pablo Galindo in `39322`{.interpreted-text role="issue"}.)

### hashlib

The `hashlib`{.interpreted-text role="mod"} module can now use SHA3 hashes and SHAKE XOF from OpenSSL when available. (Contributed by Christian Heimes in `37630`{.interpreted-text role="issue"}.)

Builtin hash modules can now be disabled with `./configure --without-builtin-hashlib-hashes` or selectively enabled with e.g. `./configure --with-builtin-hashlib-hashes=sha3,blake2` to force use of OpenSSL based implementation. (Contributed by Christian Heimes in `40479`{.interpreted-text role="issue"})

### http

HTTP status codes `103 EARLY_HINTS`, `418 IM_A_TEAPOT` and `425 TOO_EARLY` are added to `http.HTTPStatus`{.interpreted-text role="class"}. (Contributed by Donghee Na in `39509`{.interpreted-text role="issue"} and Ross Rhodes in `39507`{.interpreted-text role="issue"}.)

### IDLE and idlelib

Added option to toggle cursor blink off. (Contributed by Zackery Spytz in `4603`{.interpreted-text role="issue"}.)

Escape key now closes IDLE completion windows. (Contributed by Johnny Najera in `38944`{.interpreted-text role="issue"}.)

Added keywords to module name completion list. (Contributed by Terry J. Reedy in `37765`{.interpreted-text role="issue"}.)

New in 3.9 maintenance releases

Make IDLE invoke `sys.excepthook`{.interpreted-text role="func"} (when started without \'-n\'). User hooks were previously ignored. (Contributed by Ken Hilton in `43008`{.interpreted-text role="issue"}.)

The changes above have been backported to 3.8 maintenance releases.

Rearrange the settings dialog. Split the General tab into Windows and Shell/Ed tabs. Move help sources, which extend the Help menu, to the Extensions tab. Make space for new options and shorten the dialog. The latter makes the dialog better fit small screens. (Contributed by Terry Jan Reedy in `40468`{.interpreted-text role="issue"}.) Move the indent space setting from the Font tab to the new Windows tab. (Contributed by Mark Roseman and Terry Jan Reedy in `33962`{.interpreted-text role="issue"}.)

Apply syntax highlighting to `.pyi` files. (Contributed by Alex Waygood and Terry Jan Reedy in `45447`{.interpreted-text role="issue"}.)

### imaplib

`~imaplib.IMAP4`{.interpreted-text role="class"} and `~imaplib.IMAP4_SSL`{.interpreted-text role="class"} now have an optional *timeout* parameter for their constructors. Also, the `~imaplib.IMAP4.open`{.interpreted-text role="meth"} method now has an optional *timeout* parameter with this change. The overridden methods of `~imaplib.IMAP4_SSL`{.interpreted-text role="class"} and `~imaplib.IMAP4_stream`{.interpreted-text role="class"} were applied to this change. (Contributed by Donghee Na in `38615`{.interpreted-text role="issue"}.)

`imaplib.IMAP4.unselect`{.interpreted-text role="meth"} is added. `imaplib.IMAP4.unselect`{.interpreted-text role="meth"} frees server\'s resources associated with the selected mailbox and returns the server to the authenticated state. This command performs the same actions as `imaplib.IMAP4.close`{.interpreted-text role="meth"}, except that no messages are permanently removed from the currently selected mailbox. (Contributed by Donghee Na in `40375`{.interpreted-text role="issue"}.)

### importlib

To improve consistency with import statements, `importlib.util.resolve_name`{.interpreted-text role="func"} now raises `ImportError`{.interpreted-text role="exc"} instead of `ValueError`{.interpreted-text role="exc"} for invalid relative import attempts. (Contributed by Ngalim Siregar in `37444`{.interpreted-text role="issue"}.)

Import loaders which publish immutable module objects can now publish immutable packages in addition to individual modules. (Contributed by Dino Viehland in `39336`{.interpreted-text role="issue"}.)

Added `importlib.resources.files`{.interpreted-text role="func"} function with support for subdirectories in package data, matching backport in `importlib_resources` version 1.5. (Contributed by Jason R. Coombs in `39791`{.interpreted-text role="issue"}.)

Refreshed `importlib.metadata` from `importlib_metadata` version 1.6.1.

### inspect

`inspect.BoundArguments.arguments`{.interpreted-text role="attr"} is changed from `OrderedDict` to regular dict. (Contributed by Inada Naoki in `36350`{.interpreted-text role="issue"} and `39775`{.interpreted-text role="issue"}.)

### ipaddress

`ipaddress`{.interpreted-text role="mod"} now supports IPv6 Scoped Addresses (IPv6 address with suffix `%<scope_id>`).

Scoped IPv6 addresses can be parsed using `ipaddress.IPv6Address`{.interpreted-text role="class"}. If present, scope zone ID is available through the `~ipaddress.IPv6Address.scope_id`{.interpreted-text role="attr"} attribute. (Contributed by Oleksandr Pavliuk in `34788`{.interpreted-text role="issue"}.)

Starting with Python 3.9.5 the `ipaddress`{.interpreted-text role="mod"} module no longer accepts any leading zeros in IPv4 address strings. (Contributed by Christian Heimes in `36384`{.interpreted-text role="issue"}).

### math

Expanded the `math.gcd`{.interpreted-text role="func"} function to handle multiple arguments. Formerly, it only supported two arguments. (Contributed by Serhiy Storchaka in `39648`{.interpreted-text role="issue"}.)

Added `math.lcm`{.interpreted-text role="func"}: return the least common multiple of specified arguments. (Contributed by Mark Dickinson, Ananthakrishnan and Serhiy Storchaka in `39479`{.interpreted-text role="issue"} and `39648`{.interpreted-text role="issue"}.)

Added `math.nextafter`{.interpreted-text role="func"}: return the next floating-point value after *x* towards *y*. (Contributed by Victor Stinner in `39288`{.interpreted-text role="issue"}.)

Added `math.ulp`{.interpreted-text role="func"}: return the value of the least significant bit of a float. (Contributed by Victor Stinner in `39310`{.interpreted-text role="issue"}.)

### multiprocessing

The `multiprocessing.SimpleQueue`{.interpreted-text role="class"} class has a new `~multiprocessing.SimpleQueue.close`{.interpreted-text role="meth"} method to explicitly close the queue. (Contributed by Victor Stinner in `30966`{.interpreted-text role="issue"}.)

### nntplib

`!NNTP`{.interpreted-text role="class"} and `!NNTP_SSL`{.interpreted-text role="class"} now raise a `ValueError`{.interpreted-text role="class"} if the given timeout for their constructor is zero to prevent the creation of a non-blocking socket. (Contributed by Donghee Na in `39259`{.interpreted-text role="issue"}.)

### os

Added `~os.CLD_KILLED`{.interpreted-text role="const"} and `~os.CLD_STOPPED`{.interpreted-text role="const"} for `!si_code`{.interpreted-text role="attr"}. (Contributed by Donghee Na in `38493`{.interpreted-text role="issue"}.)

Exposed the Linux-specific `os.pidfd_open`{.interpreted-text role="func"} (`38692`{.interpreted-text role="issue"}) and `os.P_PIDFD`{.interpreted-text role="const"} (`38713`{.interpreted-text role="issue"}) for process management with file descriptors.

The `os.unsetenv`{.interpreted-text role="func"} function is now also available on Windows. (Contributed by Victor Stinner in `39413`{.interpreted-text role="issue"}.)

The `os.putenv`{.interpreted-text role="func"} and `os.unsetenv`{.interpreted-text role="func"} functions are now always available. (Contributed by Victor Stinner in `39395`{.interpreted-text role="issue"}.)

Added `os.waitstatus_to_exitcode`{.interpreted-text role="func"} function: convert a wait status to an exit code. (Contributed by Victor Stinner in `40094`{.interpreted-text role="issue"}.)

### pathlib

Added `pathlib.Path.readlink`{.interpreted-text role="meth"} which acts similarly to `os.readlink`{.interpreted-text role="func"}. (Contributed by Girts Folkmanis in `30618`{.interpreted-text role="issue"})

### pdb

On Windows now `~pdb.Pdb`{.interpreted-text role="class"} supports `~/.pdbrc`. (Contributed by Tim Hopper and Dan Lidral-Porter in `20523`{.interpreted-text role="issue"}.)

### poplib

`~poplib.POP3`{.interpreted-text role="class"} and `~poplib.POP3_SSL`{.interpreted-text role="class"} now raise a `ValueError`{.interpreted-text role="class"} if the given timeout for their constructor is zero to prevent the creation of a non-blocking socket. (Contributed by Donghee Na in `39259`{.interpreted-text role="issue"}.)

### pprint

`pprint`{.interpreted-text role="mod"} can now pretty-print `types.SimpleNamespace`{.interpreted-text role="class"}. (Contributed by Carl Bordum Hansen in `37376`{.interpreted-text role="issue"}.)

### pydoc

The documentation string is now shown not only for class, function, method etc, but for any object that has its own `~definition.__doc__`{.interpreted-text role="attr"} attribute. (Contributed by Serhiy Storchaka in `40257`{.interpreted-text role="issue"}.)

### random

Added a new `random.Random.randbytes`{.interpreted-text role="meth"} method: generate random bytes. (Contributed by Victor Stinner in `40286`{.interpreted-text role="issue"}.)

### signal

Exposed the Linux-specific `signal.pidfd_send_signal`{.interpreted-text role="func"} for sending to signals to a process using a file descriptor instead of a pid. (`38712`{.interpreted-text role="issue"})

### smtplib

`~smtplib.SMTP`{.interpreted-text role="class"} and `~smtplib.SMTP_SSL`{.interpreted-text role="class"} now raise a `ValueError`{.interpreted-text role="class"} if the given timeout for their constructor is zero to prevent the creation of a non-blocking socket. (Contributed by Donghee Na in `39259`{.interpreted-text role="issue"}.)

`~smtplib.LMTP`{.interpreted-text role="class"} constructor now has an optional *timeout* parameter. (Contributed by Donghee Na in `39329`{.interpreted-text role="issue"}.)

### socket

The `socket`{.interpreted-text role="mod"} module now exports the `~socket.CAN_RAW_JOIN_FILTERS`{.interpreted-text role="const"} constant on Linux 4.1 and greater. (Contributed by Stefan Tatschner and Zackery Spytz in `25780`{.interpreted-text role="issue"}.)

The socket module now supports the `~socket.CAN_J1939`{.interpreted-text role="const"} protocol on platforms that support it. (Contributed by Karl Ding in `40291`{.interpreted-text role="issue"}.)

The socket module now has the `socket.send_fds`{.interpreted-text role="func"} and `socket.recv_fds`{.interpreted-text role="func"} functions. (Contributed by Joannah Nanjekye, Shinya Okano and Victor Stinner in `28724`{.interpreted-text role="issue"}.)

### time

On AIX, `~time.thread_time`{.interpreted-text role="func"} is now implemented with `thread_cputime()` which has nanosecond resolution, rather than `clock_gettime(CLOCK_THREAD_CPUTIME_ID)` which has a resolution of 10 milliseconds. (Contributed by Batuhan Taskaya in `40192`{.interpreted-text role="issue"})

### sys

Added a new `sys.platlibdir`{.interpreted-text role="data"} attribute: name of the platform-specific library directory. It is used to build the path of standard library and the paths of installed extension modules. It is equal to `"lib"` on most platforms. On Fedora and SuSE, it is equal to `"lib64"` on 64-bit platforms. (Contributed by Jan Matějek, Matěj Cepl, Charalampos Stratakis and Victor Stinner in `1294959`{.interpreted-text role="issue"}.)

Previously, `sys.stderr`{.interpreted-text role="data"} was block-buffered when non-interactive. Now `stderr` defaults to always being line-buffered. (Contributed by Jendrik Seipp in `13601`{.interpreted-text role="issue"}.)

### tracemalloc

Added `tracemalloc.reset_peak`{.interpreted-text role="func"} to set the peak size of traced memory blocks to the current size, to measure the peak of specific pieces of code. (Contributed by Huon Wilson in `40630`{.interpreted-text role="issue"}.)

### typing

`593`{.interpreted-text role="pep"} introduced an `typing.Annotated`{.interpreted-text role="data"} type to decorate existing types with context-specific metadata and new `include_extras` parameter to `typing.get_type_hints`{.interpreted-text role="func"} to access the metadata at runtime. (Contributed by Till Varoquaux and Konstantin Kashin.)

### unicodedata

The Unicode database has been updated to version 13.0.0. (`39926`{.interpreted-text role="issue"}).

### venv

The activation scripts provided by `venv`{.interpreted-text role="mod"} now all specify their prompt customization consistently by always using the value specified by `__VENV_PROMPT__`. Previously some scripts unconditionally used `__VENV_PROMPT__`, others only if it happened to be set (which was the default case), and one used `__VENV_NAME__` instead. (Contributed by Brett Cannon in `37663`{.interpreted-text role="issue"}.)

### xml

White space characters within attributes are now preserved when serializing `xml.etree.ElementTree`{.interpreted-text role="mod"} to XML file. EOLNs are no longer normalized to \"n\". This is the result of discussion about how to interpret section 2.11 of XML spec. (Contributed by Mefistotelis in `39011`{.interpreted-text role="issue"}.)

## Optimizations

- Optimized the idiom for assignment a temporary variable in comprehensions. Now `for y in [expr]` in comprehensions is as fast as a simple assignment `y = expr`. For example:

  > sums = \[s for s in \[0\] for x in data for s in \[s + x\]\]

  Unlike the `:=` operator this idiom does not leak a variable to the outer scope.

  (Contributed by Serhiy Storchaka in `32856`{.interpreted-text role="issue"}.)

- Optimized signal handling in multithreaded applications. If a thread different than the main thread gets a signal, the bytecode evaluation loop is no longer interrupted at each bytecode instruction to check for pending signals which cannot be handled. Only the main thread of the main interpreter can handle signals.

  Previously, the bytecode evaluation loop was interrupted at each instruction until the main thread handles signals. (Contributed by Victor Stinner in `40010`{.interpreted-text role="issue"}.)

- Optimized the `subprocess`{.interpreted-text role="mod"} module on FreeBSD using `closefrom()`. (Contributed by Ed Maste, Conrad Meyer, Kyle Evans, Kubilay Kocak and Victor Stinner in `38061`{.interpreted-text role="issue"}.)

- `PyLong_FromDouble`{.interpreted-text role="c:func"} is now up to 1.87x faster for values that fit into `long`{.interpreted-text role="c:expr"}. (Contributed by Sergey Fedoseev in `37986`{.interpreted-text role="issue"}.)

- A number of Python builtins (`range`{.interpreted-text role="class"}, `tuple`{.interpreted-text role="class"}, `set`{.interpreted-text role="class"}, `frozenset`{.interpreted-text role="class"}, `list`{.interpreted-text role="class"}, `dict`{.interpreted-text role="class"}) are now sped up by using `590`{.interpreted-text role="pep"} vectorcall protocol. (Contributed by Donghee Na, Mark Shannon, Jeroen Demeyer and Petr Viktorin in `37207`{.interpreted-text role="issue"}.)

- Optimized `!set.difference_update`{.interpreted-text role="meth"} for the case when the other set is much larger than the base set. (Suggested by Evgeny Kapun with code contributed by Michele Orrù in `8425`{.interpreted-text role="issue"}.)

- Python\'s small object allocator (`obmalloc.c`) now allows (no more than) one empty arena to remain available for immediate reuse, without returning it to the OS. This prevents thrashing in simple loops where an arena could be created and destroyed anew on each iteration. (Contributed by Tim Peters in `37257`{.interpreted-text role="issue"}.)

- `floor division`{.interpreted-text role="term"} of float operation now has a better performance. Also the message of `ZeroDivisionError`{.interpreted-text role="exc"} for this operation is updated. (Contributed by Donghee Na in `39434`{.interpreted-text role="issue"}.)

- Decoding short ASCII strings with UTF-8 and ascii codecs is now about 15% faster. (Contributed by Inada Naoki in `37348`{.interpreted-text role="issue"}.)

Here\'s a summary of performance improvements from Python 3.4 through Python 3.9:

``` none
Python version                       3.4     3.5     3.6     3.7     3.8    3.9
--------------                       ---     ---     ---     ---     ---    ---

Variable and attribute read access:
    read_local                       7.1     7.1     5.4     5.1     3.9    3.9
    read_nonlocal                    7.1     8.1     5.8     5.4     4.4    4.5
    read_global                     15.5    19.0    14.3    13.6     7.6    7.8
    read_builtin                    21.1    21.6    18.5    19.0     7.5    7.8
    read_classvar_from_class        25.6    26.5    20.7    19.5    18.4   17.9
    read_classvar_from_instance     22.8    23.5    18.8    17.1    16.4   16.9
    read_instancevar                32.4    33.1    28.0    26.3    25.4   25.3
    read_instancevar_slots          27.8    31.3    20.8    20.8    20.2   20.5
    read_namedtuple                 73.8    57.5    45.0    46.8    18.4   18.7
    read_boundmethod                37.6    37.9    29.6    26.9    27.7   41.1

Variable and attribute write access:
    write_local                      8.7     9.3     5.5     5.3     4.3    4.3
    write_nonlocal                  10.5    11.1     5.6     5.5     4.7    4.8
    write_global                    19.7    21.2    18.0    18.0    15.8   16.7
    write_classvar                  92.9    96.0   104.6   102.1    39.2   39.8
    write_instancevar               44.6    45.8    40.0    38.9    35.5   37.4
    write_instancevar_slots         35.6    36.1    27.3    26.6    25.7   25.8

Data structure read access:
    read_list                       24.2    24.5    20.8    20.8    19.0   19.5
    read_deque                      24.7    25.5    20.2    20.6    19.8   20.2
    read_dict                       24.3    25.7    22.3    23.0    21.0   22.4
    read_strdict                    22.6    24.3    19.5    21.2    18.9   21.5

Data structure write access:
    write_list                      27.1    28.5    22.5    21.6    20.0   20.0
    write_deque                     28.7    30.1    22.7    21.8    23.5   21.7
    write_dict                      31.4    33.3    29.3    29.2    24.7   25.4
    write_strdict                   28.4    29.9    27.5    25.2    23.1   24.5

Stack (or queue) operations:
    list_append_pop                 93.4   112.7    75.4    74.2    50.8   50.6
    deque_append_pop                43.5    57.0    49.4    49.2    42.5   44.2
    deque_append_popleft            43.7    57.3    49.7    49.7    42.8   46.4

Timing loop:
    loop_overhead                    0.5     0.6     0.4     0.3     0.3    0.3
```

These results were generated from the variable access benchmark script at: `Tools/scripts/var_access_benchmark.py`. The benchmark script displays timings in nanoseconds. The benchmarks were measured on an [Intel® Core™ i7-4960HQ processor](https://ark.intel.com/content/www/us/en/ark/products/76088/intel-core-i7-4960hq-processor-6m-cache-up-to-3-80-ghz.html) running the macOS 64-bit builds found at [python.org](https://www.python.org/downloads/macos/).

## Deprecated

- The distutils `bdist_msi` command is now deprecated, use `bdist_wheel` (wheel packages) instead. (Contributed by Hugo van Kemenade in `39586`{.interpreted-text role="issue"}.)

- Currently `math.factorial`{.interpreted-text role="func"} accepts `float`{.interpreted-text role="class"} instances with non-negative integer values (like `5.0`). It raises a `ValueError`{.interpreted-text role="exc"} for non-integral and negative floats. It is now deprecated. In future Python versions it will raise a `TypeError`{.interpreted-text role="exc"} for all floats. (Contributed by Serhiy Storchaka in `37315`{.interpreted-text role="issue"}.)

- The `!parser`{.interpreted-text role="mod"} and `!symbol`{.interpreted-text role="mod"} modules are deprecated and will be removed in future versions of Python. For the majority of use cases, users can leverage the Abstract Syntax Tree (AST) generation and compilation stage, using the `ast`{.interpreted-text role="mod"} module.

- The Public C API functions `!PyParser_SimpleParseStringFlags`{.interpreted-text role="c:func"}, `!PyParser_SimpleParseStringFlagsFilename`{.interpreted-text role="c:func"}, `!PyParser_SimpleParseFileFlags`{.interpreted-text role="c:func"} and `!PyNode_Compile`{.interpreted-text role="c:func"} are deprecated and will be removed in Python 3.10 together with the old parser.

- Using `NotImplemented`{.interpreted-text role="data"} in a boolean context has been deprecated, as it is almost exclusively the result of incorrect rich comparator implementations. It will be made a `TypeError`{.interpreted-text role="exc"} in a future version of Python. (Contributed by Josh Rosenberg in `35712`{.interpreted-text role="issue"}.)

- The `random`{.interpreted-text role="mod"} module currently accepts any hashable type as a possible seed value. Unfortunately, some of those types are not guaranteed to have a deterministic hash value. After Python 3.9, the module will restrict its seeds to `None`{.interpreted-text role="const"}, `int`{.interpreted-text role="class"}, `float`{.interpreted-text role="class"}, `str`{.interpreted-text role="class"}, `bytes`{.interpreted-text role="class"}, and `bytearray`{.interpreted-text role="class"}.

- Opening the `~gzip.GzipFile`{.interpreted-text role="class"} file for writing without specifying the *mode* argument is deprecated. In future Python versions it will always be opened for reading by default. Specify the *mode* argument for opening it for writing and silencing a warning. (Contributed by Serhiy Storchaka in `28286`{.interpreted-text role="issue"}.)

- Deprecated the `split()` method of `!_tkinter.TkappType`{.interpreted-text role="class"} in favour of the `splitlist()` method which has more consistent and predictable behavior. (Contributed by Serhiy Storchaka in `38371`{.interpreted-text role="issue"}.)

- The explicit passing of coroutine objects to `asyncio.wait`{.interpreted-text role="func"} has been deprecated and will be removed in version 3.11. (Contributed by Yury Selivanov and Kyle Stanley in `34790`{.interpreted-text role="issue"}.)

- binhex4 and hexbin4 standards are now deprecated. The `!binhex`{.interpreted-text role="mod"} module and the following `binascii`{.interpreted-text role="mod"} functions are now deprecated:

  - `!b2a_hqx`{.interpreted-text role="func"}, `!a2b_hqx`{.interpreted-text role="func"}
  - `!rlecode_hqx`{.interpreted-text role="func"}, `!rledecode_hqx`{.interpreted-text role="func"}

  (Contributed by Victor Stinner in `39353`{.interpreted-text role="issue"}.)

- `ast`{.interpreted-text role="mod"} classes `slice`, `Index` and `ExtSlice` are considered deprecated and will be removed in future Python versions. `value` itself should be used instead of `Index(value)`. `Tuple(slices, Load())` should be used instead of `ExtSlice(slices)`. (Contributed by Serhiy Storchaka in `34822`{.interpreted-text role="issue"}.)

- `ast`{.interpreted-text role="mod"} classes `Suite`, `Param`, `AugLoad` and `AugStore` are considered deprecated and will be removed in future Python versions. They were not generated by the parser and not accepted by the code generator in Python 3. (Contributed by Batuhan Taskaya in `39639`{.interpreted-text role="issue"} and `39969`{.interpreted-text role="issue"} and Serhiy Storchaka in `39988`{.interpreted-text role="issue"}.)

- The `!PyEval_InitThreads`{.interpreted-text role="c:func"} and `!PyEval_ThreadsInitialized`{.interpreted-text role="c:func"} functions are now deprecated and will be removed in Python 3.11. Calling `!PyEval_InitThreads`{.interpreted-text role="c:func"} now does nothing. The `GIL`{.interpreted-text role="term"} is initialized by `Py_Initialize`{.interpreted-text role="c:func"} since Python 3.7. (Contributed by Victor Stinner in `39877`{.interpreted-text role="issue"}.)

- Passing `None` as the first argument to the `shlex.split`{.interpreted-text role="func"} function has been deprecated. (Contributed by Zackery Spytz in `33262`{.interpreted-text role="issue"}.)

- `!smtpd.MailmanProxy`{.interpreted-text role="func"} is now deprecated as it is unusable without an external module, `mailman`. (Contributed by Samuel Colvin in `35800`{.interpreted-text role="issue"}.)

- The `!lib2to3`{.interpreted-text role="mod"} module now emits a `PendingDeprecationWarning`{.interpreted-text role="exc"}. Python 3.9 switched to a PEG parser (see `617`{.interpreted-text role="pep"}), and Python 3.10 may include new language syntax that is not parsable by lib2to3\'s LL(1) parser. The `!lib2to3`{.interpreted-text role="mod"} module may be removed from the standard library in a future Python version. Consider third-party alternatives such as [LibCST](https://libcst.readthedocs.io/) or [parso](https://parso.readthedocs.io/). (Contributed by Carl Meyer in `40360`{.interpreted-text role="issue"}.)

- The *random* parameter of `random.shuffle`{.interpreted-text role="func"} has been deprecated. (Contributed by Raymond Hettinger in `40465`{.interpreted-text role="issue"})

## Removed {#removed-in-python-39}

- The erroneous version at `!unittest.mock.__version__`{.interpreted-text role="data"} has been removed.
- `!nntplib.NNTP`{.interpreted-text role="class"}: `xpath()` and `xgtitle()` methods have been removed. These methods are deprecated since Python 3.3. Generally, these extensions are not supported or not enabled by NNTP server administrators. For `xgtitle()`, please use `!nntplib.NNTP.descriptions`{.interpreted-text role="meth"} or `!nntplib.NNTP.description`{.interpreted-text role="meth"} instead. (Contributed by Donghee Na in `39366`{.interpreted-text role="issue"}.)
- `array.array`{.interpreted-text role="class"}: `tostring()` and `fromstring()` methods have been removed. They were aliases to `tobytes()` and `frombytes()`, deprecated since Python 3.2. (Contributed by Victor Stinner in `38916`{.interpreted-text role="issue"}.)
- The undocumented `sys.callstats()` function has been removed. Since Python 3.7, it was deprecated and always returned `None`{.interpreted-text role="const"}. It required a special build option `CALL_PROFILE` which was already removed in Python 3.7. (Contributed by Victor Stinner in `37414`{.interpreted-text role="issue"}.)
- The `sys.getcheckinterval()` and `sys.setcheckinterval()` functions have been removed. They were deprecated since Python 3.2. Use `sys.getswitchinterval`{.interpreted-text role="func"} and `sys.setswitchinterval`{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in `37392`{.interpreted-text role="issue"}.)
- The C function `PyImport_Cleanup()` has been removed. It was documented as: \"Empty the module table. For internal use only.\" (Contributed by Victor Stinner in `36710`{.interpreted-text role="issue"}.)
- `_dummy_thread` and `dummy_threading` modules have been removed. These modules were deprecated since Python 3.7 which requires threading support. (Contributed by Victor Stinner in `37312`{.interpreted-text role="issue"}.)
- `aifc.openfp()` alias to `aifc.open()`, `sunau.openfp()` alias to `sunau.open()`, and `wave.openfp()` alias to `wave.open`{.interpreted-text role="func"} have been removed. They were deprecated since Python 3.7. (Contributed by Victor Stinner in `37320`{.interpreted-text role="issue"}.)
- The `!isAlive`{.interpreted-text role="meth"} method of `threading.Thread`{.interpreted-text role="class"} has been removed. It was deprecated since Python 3.8. Use `~threading.Thread.is_alive`{.interpreted-text role="meth"} instead. (Contributed by Donghee Na in `37804`{.interpreted-text role="issue"}.)
- Methods `getchildren()` and `getiterator()` of classes `~xml.etree.ElementTree.ElementTree`{.interpreted-text role="class"} and `~xml.etree.ElementTree.Element`{.interpreted-text role="class"} in the `~xml.etree.ElementTree`{.interpreted-text role="mod"} module have been removed. They were deprecated in Python 3.2. Use `iter(x)` or `list(x)` instead of `x.getchildren()` and `x.iter()` or `list(x.iter())` instead of `x.getiterator()`. (Contributed by Serhiy Storchaka in `36543`{.interpreted-text role="issue"}.)
- The old `plistlib`{.interpreted-text role="mod"} API has been removed, it was deprecated since Python 3.4. Use the `~plistlib.load`{.interpreted-text role="func"}, `~plistlib.loads`{.interpreted-text role="func"}, `~plistlib.dump`{.interpreted-text role="func"}, and `~plistlib.dumps`{.interpreted-text role="func"} functions. Additionally, the *use_builtin_types* parameter was removed, standard `bytes`{.interpreted-text role="class"} objects are always used instead. (Contributed by Jon Janzen in `36409`{.interpreted-text role="issue"}.)
- The C function `PyGen_NeedsFinalizing` has been removed. It was not documented, tested, or used anywhere within CPython after the implementation of `442`{.interpreted-text role="pep"}. Patch by Joannah Nanjekye. (Contributed by Joannah Nanjekye in `15088`{.interpreted-text role="issue"})
- `base64.encodestring()` and `base64.decodestring()`, aliases deprecated since Python 3.1, have been removed: use `base64.encodebytes`{.interpreted-text role="func"} and `base64.decodebytes`{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in `39351`{.interpreted-text role="issue"}.)
- `fractions.gcd()` function has been removed, it was deprecated since Python 3.5 (`22486`{.interpreted-text role="issue"}): use `math.gcd`{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in `39350`{.interpreted-text role="issue"}.)
- The *buffering* parameter of `bz2.BZ2File`{.interpreted-text role="class"} has been removed. Since Python 3.0, it was ignored and using it emitted a `DeprecationWarning`{.interpreted-text role="exc"}. Pass an open file object to control how the file is opened. (Contributed by Victor Stinner in `39357`{.interpreted-text role="issue"}.)
- The *encoding* parameter of `json.loads`{.interpreted-text role="func"} has been removed. As of Python 3.1, it was deprecated and ignored; using it has emitted a `DeprecationWarning`{.interpreted-text role="exc"} since Python 3.8. (Contributed by Inada Naoki in `39377`{.interpreted-text role="issue"})
- `with (await asyncio.lock):` and `with (yield from asyncio.lock):` statements are not longer supported, use `async with lock` instead. The same is correct for `asyncio.Condition` and `asyncio.Semaphore`. (Contributed by Andrew Svetlov in `34793`{.interpreted-text role="issue"}.)
- The `!sys.getcounts`{.interpreted-text role="func"} function, the `-X showalloccount` command line option and the `show_alloc_count` field of the C structure `PyConfig`{.interpreted-text role="c:type"} have been removed. They required a special Python build by defining `COUNT_ALLOCS` macro. (Contributed by Victor Stinner in `39489`{.interpreted-text role="issue"}.)
- The `_field_types` attribute of the `typing.NamedTuple`{.interpreted-text role="class"} class has been removed. It was deprecated since Python 3.8. Use the `__annotations__` attribute instead. (Contributed by Serhiy Storchaka in `40182`{.interpreted-text role="issue"}.)
- The `!symtable.SymbolTable.has_exec`{.interpreted-text role="meth"} method has been removed. It was deprecated since 2006, and only returning `False` when it\'s called. (Contributed by Batuhan Taskaya in `40208`{.interpreted-text role="issue"})
- The `!asyncio.Task.current_task`{.interpreted-text role="meth"} and `!asyncio.Task.all_tasks`{.interpreted-text role="meth"} have been removed. They were deprecated since Python 3.7 and you can use `asyncio.current_task`{.interpreted-text role="func"} and `asyncio.all_tasks`{.interpreted-text role="func"} instead. (Contributed by Rémi Lapeyre in `40967`{.interpreted-text role="issue"})
- The `unescape()` method in the `html.parser.HTMLParser`{.interpreted-text role="class"} class has been removed (it was deprecated since Python 3.4). `html.unescape`{.interpreted-text role="func"} should be used for converting character references to the corresponding unicode characters.

## Porting to Python 3.9

This section lists previously described changes and other bugfixes that may require changes to your code.

### Changes in the Python API

- `__import__`{.interpreted-text role="func"} and `importlib.util.resolve_name`{.interpreted-text role="func"} now raise `ImportError`{.interpreted-text role="exc"} where it previously raised `ValueError`{.interpreted-text role="exc"}. Callers catching the specific exception type and supporting both Python 3.9 and earlier versions will need to catch both using `except (ImportError, ValueError):`.
- The `venv`{.interpreted-text role="mod"} activation scripts no longer special-case when `__VENV_PROMPT__` is set to `""`.
- The `select.epoll.unregister`{.interpreted-text role="meth"} method no longer ignores the `~errno.EBADF`{.interpreted-text role="const"} error. (Contributed by Victor Stinner in `39239`{.interpreted-text role="issue"}.)
- The *compresslevel* parameter of `bz2.BZ2File`{.interpreted-text role="class"} became keyword-only, since the *buffering* parameter has been removed. (Contributed by Victor Stinner in `39357`{.interpreted-text role="issue"}.)
- Simplified AST for subscription. Simple indices will be represented by their value, extended slices will be represented as tuples. `Index(value)` will return a `value` itself, `ExtSlice(slices)` will return `Tuple(slices, Load())`. (Contributed by Serhiy Storchaka in `34822`{.interpreted-text role="issue"}.)
- The `importlib`{.interpreted-text role="mod"} module now ignores the `PYTHONCASEOK`{.interpreted-text role="envvar"} environment variable when the `-E`{.interpreted-text role="option"} or `-I`{.interpreted-text role="option"} command line options are being used.
- The *encoding* parameter has been added to the classes `ftplib.FTP`{.interpreted-text role="class"} and `ftplib.FTP_TLS`{.interpreted-text role="class"} as a keyword-only parameter, and the default encoding is changed from Latin-1 to UTF-8 to follow `2640`{.interpreted-text role="rfc"}.
- `asyncio.loop.shutdown_default_executor`{.interpreted-text role="meth"} has been added to `~asyncio.AbstractEventLoop`{.interpreted-text role="class"}, meaning alternative event loops that inherit from it should have this method defined. (Contributed by Kyle Stanley in `34037`{.interpreted-text role="issue"}.)
- The constant values of future flags in the `__future__`{.interpreted-text role="mod"} module is updated in order to prevent collision with compiler flags. Previously `PyCF_ALLOW_TOP_LEVEL_AWAIT` was clashing with `CO_FUTURE_DIVISION`. (Contributed by Batuhan Taskaya in `39562`{.interpreted-text role="issue"})
- `array('u')` now uses `wchar_t`{.interpreted-text role="c:type"} as C type instead of `Py_UNICODE`. This change doesn\'t affect to its behavior because `Py_UNICODE` is alias of `wchar_t`{.interpreted-text role="c:type"} since Python 3.3. (Contributed by Inada Naoki in `34538`{.interpreted-text role="issue"}.)
- The `logging.getLogger`{.interpreted-text role="func"} API now returns the root logger when passed the name `'root'`, whereas previously it returned a non-root logger named `'root'`. This could affect cases where user code explicitly wants a non-root logger named `'root'`, or instantiates a logger using `logging.getLogger(__name__)` in some top-level module called `'root.py'`. (Contributed by Vinay Sajip in `37742`{.interpreted-text role="issue"}.)
- Division handling of `~pathlib.PurePath`{.interpreted-text role="class"} now returns `NotImplemented`{.interpreted-text role="data"} instead of raising a `TypeError`{.interpreted-text role="exc"} when passed something other than an instance of `str` or `~pathlib.PurePath`{.interpreted-text role="class"}. This allows creating compatible classes that don\'t inherit from those mentioned types. (Contributed by Roger Aiudi in `34775`{.interpreted-text role="issue"}).
- Starting with Python 3.9.5 the `ipaddress`{.interpreted-text role="mod"} module no longer accepts any leading zeros in IPv4 address strings. Leading zeros are ambiguous and interpreted as octal notation by some libraries. For example the legacy function `socket.inet_aton`{.interpreted-text role="func"} treats leading zeros as octal notatation. glibc implementation of modern `~socket.inet_pton`{.interpreted-text role="func"} does not accept any leading zeros. (Contributed by Christian Heimes in `36384`{.interpreted-text role="issue"}).
- `codecs.lookup`{.interpreted-text role="func"} now normalizes the encoding name the same way as `encodings.normalize_encoding`{.interpreted-text role="func"}, except that `codecs.lookup`{.interpreted-text role="func"} also converts the name to lower case. For example, `"latex+latin1"` encoding name is now normalized to `"latex_latin1"`. (Contributed by Jordon Xu in `37751`{.interpreted-text role="issue"}.)

### Changes in the C API

- Instances of `heap-allocated types <heap-types>`{.interpreted-text role="ref"} (such as those created with `PyType_FromSpec`{.interpreted-text role="c:func"} and similar APIs) hold a reference to their type object since Python 3.8. As indicated in the \"Changes in the C API\" of Python 3.8, for the vast majority of cases, there should be no side effect but for types that have a custom `~PyTypeObject.tp_traverse`{.interpreted-text role="c:member"} function, ensure that all custom `tp_traverse` functions of heap-allocated types visit the object\'s type.

  > Example:
  >
  > ``` c
  > int
  > foo_traverse(PyObject *self, visitproc visit, void *arg)
  > {
  > // Rest of the traverse function
  > #if PY_VERSION_HEX >= 0x03090000
  >     // This was not needed before Python 3.9 (Python issue 35810 and 40217)
  >     Py_VISIT(Py_TYPE(self));
  > #endif
  > }
  > ```

  If your traverse function delegates to `tp_traverse` of its base class (or another type), ensure that `Py_TYPE(self)` is visited only once. Note that only `heap type <heap-types>`{.interpreted-text role="ref"} are expected to visit the type in `tp_traverse`.

  > For example, if your `tp_traverse` function includes:
  >
  > ``` c
  > base->tp_traverse(self, visit, arg)
  > ```
  >
  > then add:
  >
  > ``` c
  > #if PY_VERSION_HEX >= 0x03090000
  >     // This was not needed before Python 3.9 (bpo-35810 and bpo-40217)
  >     if (base->tp_flags & Py_TPFLAGS_HEAPTYPE) {
  >         // a heap type's tp_traverse already visited Py_TYPE(self)
  >     } else {
  >         Py_VISIT(Py_TYPE(self));
  >     }
  > #else
  > ```

  (See `35810`{.interpreted-text role="issue"} and `40217`{.interpreted-text role="issue"} for more information.)

- The functions `PyEval_CallObject`, `PyEval_CallFunction`, `PyEval_CallMethod` and `PyEval_CallObjectWithKeywords` are deprecated. Use `PyObject_Call`{.interpreted-text role="c:func"} and its variants instead. (See more details in `29548`{.interpreted-text role="issue"}.)

### CPython bytecode changes

- The `!LOAD_ASSERTION_ERROR`{.interpreted-text role="opcode"} opcode was added for handling the `assert`{.interpreted-text role="keyword"} statement. Previously, the assert statement would not work correctly if the `AssertionError`{.interpreted-text role="exc"} exception was being shadowed. (Contributed by Zackery Spytz in `34880`{.interpreted-text role="issue"}.)

- The `COMPARE_OP`{.interpreted-text role="opcode"} opcode was split into four distinct instructions:

  - `COMPARE_OP` for rich comparisons
  - `IS_OP` for \'is\' and \'is not\' tests
  - `CONTAINS_OP` for \'in\' and \'not in\' tests
  - `JUMP_IF_NOT_EXC_MATCH` for checking exceptions in \'try-except\' statements.

  (Contributed by Mark Shannon in `39156`{.interpreted-text role="issue"}.)

## Build Changes

- Added `--with-platlibdir` option to the `configure` script: name of the platform-specific library directory, stored in the new `sys.platlibdir`{.interpreted-text role="data"} attribute. See `sys.platlibdir`{.interpreted-text role="data"} attribute for more information. (Contributed by Jan Matějek, Matěj Cepl, Charalampos Stratakis and Victor Stinner in `1294959`{.interpreted-text role="issue"}.)
- The `COUNT_ALLOCS` special build macro has been removed. (Contributed by Victor Stinner in `39489`{.interpreted-text role="issue"}.)
- On non-Windows platforms, the `!setenv`{.interpreted-text role="c:func"} and `!unsetenv`{.interpreted-text role="c:func"} functions are now required to build Python. (Contributed by Victor Stinner in `39395`{.interpreted-text role="issue"}.)
- On non-Windows platforms, creating `bdist_wininst` installers is now officially unsupported. (See `10945`{.interpreted-text role="issue"} for more details.)
- When building Python on macOS from source, `_tkinter` now links with non-system Tcl and Tk frameworks if they are installed in `/Library/Frameworks`, as had been the case on older releases of macOS. If a macOS SDK is explicitly configured, by using `--enable-universalsdk`{.interpreted-text role="option"} or `-isysroot`, only the SDK itself is searched. The default behavior can still be overridden with `--with-tcltk-includes` and `--with-tcltk-libs`. (Contributed by Ned Deily in `34956`{.interpreted-text role="issue"}.)
- Python can now be built for Windows 10 ARM64. (Contributed by Steve Dower in `33125`{.interpreted-text role="issue"}.)
- Some individual tests are now skipped when `--pgo` is used. The tests in question increased the PGO task time significantly and likely didn\'t help improve optimization of the final executable. This speeds up the task by a factor of about 15x. Running the full unit test suite is slow. This change may result in a slightly less optimized build since not as many code branches will be executed. If you are willing to wait for the much slower build, the old behavior can be restored using `./configure [..] PROFILE_TASK="-m test --pgo-extended"`. We make no guarantees as to which PGO task set produces a faster build. Users who care should run their own relevant benchmarks as results can depend on the environment, workload, and compiler tool chain. (See `36044`{.interpreted-text role="issue"} and `37707`{.interpreted-text role="issue"} for more details.)

## C API Changes

### New Features

- `573`{.interpreted-text role="pep"}: Added `PyType_FromModuleAndSpec`{.interpreted-text role="c:func"} to associate a module with a class; `PyType_GetModule`{.interpreted-text role="c:func"} and `PyType_GetModuleState`{.interpreted-text role="c:func"} to retrieve the module and its state; and `PyCMethod`{.interpreted-text role="c:type"} and `METH_METHOD`{.interpreted-text role="c:macro"} to allow a method to access the class it was defined in. (Contributed by Marcel Plch and Petr Viktorin in `38787`{.interpreted-text role="issue"}.)

- Added `PyFrame_GetCode`{.interpreted-text role="c:func"} function: get a frame code. Added `PyFrame_GetBack`{.interpreted-text role="c:func"} function: get the frame next outer frame. (Contributed by Victor Stinner in `40421`{.interpreted-text role="issue"}.)

- Added `PyFrame_GetLineNumber`{.interpreted-text role="c:func"} to the limited C API. (Contributed by Victor Stinner in `40421`{.interpreted-text role="issue"}.)

- Added `PyThreadState_GetInterpreter`{.interpreted-text role="c:func"} and `PyInterpreterState_Get`{.interpreted-text role="c:func"} functions to get the interpreter. Added `PyThreadState_GetFrame`{.interpreted-text role="c:func"} function to get the current frame of a Python thread state. Added `PyThreadState_GetID`{.interpreted-text role="c:func"} function: get the unique identifier of a Python thread state. (Contributed by Victor Stinner in `39947`{.interpreted-text role="issue"}.)

- Added a new public `PyObject_CallNoArgs`{.interpreted-text role="c:func"} function to the C API, which calls a callable Python object without any arguments. It is the most efficient way to call a callable Python object without any argument. (Contributed by Victor Stinner in `37194`{.interpreted-text role="issue"}.)

- Changes in the limited C API (if `Py_LIMITED_API` macro is defined):

  - Provide `Py_EnterRecursiveCall`{.interpreted-text role="c:func"} and `Py_LeaveRecursiveCall`{.interpreted-text role="c:func"} as regular functions for the limited API. Previously, there were defined as macros, but these macros didn\'t compile with the limited C API which cannot access `PyThreadState.recursion_depth` field (the structure is opaque in the limited C API).
  - `PyObject_INIT()` and `PyObject_INIT_VAR()` become regular \"opaque\" function to hide implementation details.

  (Contributed by Victor Stinner in `38644`{.interpreted-text role="issue"} and `39542`{.interpreted-text role="issue"}.)

- The `PyModule_AddType`{.interpreted-text role="c:func"} function is added to help adding a type to a module. (Contributed by Donghee Na in `40024`{.interpreted-text role="issue"}.)

- Added the functions `PyObject_GC_IsTracked`{.interpreted-text role="c:func"} and `PyObject_GC_IsFinalized`{.interpreted-text role="c:func"} to the public API to allow to query if Python objects are being currently tracked or have been already finalized by the garbage collector respectively. (Contributed by Pablo Galindo Salgado in `40241`{.interpreted-text role="issue"}.)

- Added `!_PyObject_FunctionStr`{.interpreted-text role="c:func"} to get a user-friendly string representation of a function-like object. (Patch by Jeroen Demeyer in `37645`{.interpreted-text role="issue"}.)

- Added `PyObject_CallOneArg`{.interpreted-text role="c:func"} for calling an object with one positional argument (Patch by Jeroen Demeyer in `37483`{.interpreted-text role="issue"}.)

### Porting to Python 3.9

- `PyInterpreterState.eval_frame` (`523`{.interpreted-text role="pep"}) now requires a new mandatory *tstate* parameter (`PyThreadState*`). (Contributed by Victor Stinner in `38500`{.interpreted-text role="issue"}.)

- Extension modules: `~PyModuleDef.m_traverse`{.interpreted-text role="c:member"}, `~PyModuleDef.m_clear`{.interpreted-text role="c:member"} and `~PyModuleDef.m_free`{.interpreted-text role="c:member"} functions of `PyModuleDef`{.interpreted-text role="c:type"} are no longer called if the module state was requested but is not allocated yet. This is the case immediately after the module is created and before the module is executed (`Py_mod_exec`{.interpreted-text role="c:data"} function). More precisely, these functions are not called if `~PyModuleDef.m_size`{.interpreted-text role="c:member"} is greater than 0 and the module state (as returned by `PyModule_GetState`{.interpreted-text role="c:func"}) is `NULL`.

  Extension modules without module state (`m_size <= 0`) are not affected.

- If `Py_AddPendingCall`{.interpreted-text role="c:func"} is called in a subinterpreter, the function is now scheduled to be called from the subinterpreter, rather than being called from the main interpreter. Each subinterpreter now has its own list of scheduled calls. (Contributed by Victor Stinner in `39984`{.interpreted-text role="issue"}.)

- The Windows registry is no longer used to initialize `sys.path`{.interpreted-text role="data"} when the `-E` option is used (if `PyConfig.use_environment`{.interpreted-text role="c:member"} is set to `0`). This is significant when embedding Python on Windows. (Contributed by Zackery Spytz in `8901`{.interpreted-text role="issue"}.)

- The global variable `PyStructSequence_UnnamedField`{.interpreted-text role="c:data"} is now a constant and refers to a constant string. (Contributed by Serhiy Storchaka in `38650`{.interpreted-text role="issue"}.)

- The `!PyGC_Head`{.interpreted-text role="c:type"} structure is now opaque. It is only defined in the internal C API (`pycore_gc.h`). (Contributed by Victor Stinner in `40241`{.interpreted-text role="issue"}.)

- The `Py_UNICODE_COPY`, `Py_UNICODE_FILL`, `PyUnicode_WSTR_LENGTH`, `!PyUnicode_FromUnicode`{.interpreted-text role="c:func"}, `!PyUnicode_AsUnicode`{.interpreted-text role="c:func"}, `_PyUnicode_AsUnicode`, and `!PyUnicode_AsUnicodeAndSize`{.interpreted-text role="c:func"} are marked as deprecated in C. They have been deprecated by `393`{.interpreted-text role="pep"} since Python 3.3. (Contributed by Inada Naoki in `36346`{.interpreted-text role="issue"}.)

- The `Py_FatalError`{.interpreted-text role="c:func"} function is replaced with a macro which logs automatically the name of the current function, unless the `Py_LIMITED_API` macro is defined. (Contributed by Victor Stinner in `39882`{.interpreted-text role="issue"}.)

- The vectorcall protocol now requires that the caller passes only strings as keyword names. (See `37540`{.interpreted-text role="issue"} for more information.)

- Implementation details of a number of macros and functions are now hidden:

  - `PyObject_IS_GC`{.interpreted-text role="c:func"} macro was converted to a function.
  - The `!PyObject_NEW`{.interpreted-text role="c:func"} macro becomes an alias to the `PyObject_New`{.interpreted-text role="c:macro"} macro, and the `!PyObject_NEW_VAR`{.interpreted-text role="c:func"} macro becomes an alias to the `PyObject_NewVar`{.interpreted-text role="c:macro"} macro. They no longer access directly the `PyTypeObject.tp_basicsize`{.interpreted-text role="c:member"} member.
  - `!PyObject_GET_WEAKREFS_LISTPTR`{.interpreted-text role="c:func"} macro was converted to a function: the macro accessed directly the `PyTypeObject.tp_weaklistoffset`{.interpreted-text role="c:member"} member.
  - `PyObject_CheckBuffer`{.interpreted-text role="c:func"} macro was converted to a function: the macro accessed directly the `PyTypeObject.tp_as_buffer`{.interpreted-text role="c:member"} member.
  - `PyIndex_Check`{.interpreted-text role="c:func"} is now always declared as an opaque function to hide implementation details: removed the `PyIndex_Check()` macro. The macro accessed directly the `PyTypeObject.tp_as_number`{.interpreted-text role="c:member"} member.

  (See `40170`{.interpreted-text role="issue"} for more details.)

### Removed

- Excluded `PyFPE_START_PROTECT()` and `PyFPE_END_PROTECT()` macros of `pyfpe.h` from the limited C API. (Contributed by Victor Stinner in `38835`{.interpreted-text role="issue"}.)

- The `tp_print` slot of `PyTypeObject <type-structs>`{.interpreted-text role="ref"} has been removed. It was used for printing objects to files in Python 2.7 and before. Since Python 3.0, it has been ignored and unused. (Contributed by Jeroen Demeyer in `36974`{.interpreted-text role="issue"}.)

- Changes in the limited C API (if `Py_LIMITED_API` macro is defined):

  - Excluded the following functions from the limited C API:
    - `PyThreadState_DeleteCurrent()` (Contributed by Joannah Nanjekye in `37878`{.interpreted-text role="issue"}.)
    - `_Py_CheckRecursionLimit`
    - `_Py_NewReference()`
    - `_Py_ForgetReference()`
    - `_PyTraceMalloc_NewReference()`
    - `_Py_GetRefTotal()`
    - The trashcan mechanism which never worked in the limited C API.
    - `PyTrash_UNWIND_LEVEL`
    - `Py_TRASHCAN_BEGIN_CONDITION`
    - `Py_TRASHCAN_BEGIN`
    - `Py_TRASHCAN_END`
    - `Py_TRASHCAN_SAFE_BEGIN`
    - `Py_TRASHCAN_SAFE_END`
  - Moved following functions and definitions to the internal C API:
    - `_PyDebug_PrintTotalRefs()`
    - `_Py_PrintReferences()`
    - `_Py_PrintReferenceAddresses()`
    - `_Py_tracemalloc_config`
    - `_Py_AddToAllObjects()` (specific to `Py_TRACE_REFS` build)

  (Contributed by Victor Stinner in `38644`{.interpreted-text role="issue"} and `39542`{.interpreted-text role="issue"}.)

- Removed `_PyRuntime.getframe` hook and removed `_PyThreadState_GetFrame` macro which was an alias to `_PyRuntime.getframe`. They were only exposed by the internal C API. Removed also `PyThreadFrameGetter` type. (Contributed by Victor Stinner in `39946`{.interpreted-text role="issue"}.)

- Removed the following functions from the C API. Call `PyGC_Collect`{.interpreted-text role="c:func"} explicitly to clear all free lists. (Contributed by Inada Naoki and Victor Stinner in `37340`{.interpreted-text role="issue"}, `38896`{.interpreted-text role="issue"} and `40428`{.interpreted-text role="issue"}.)

  - `PyAsyncGen_ClearFreeLists()`
  - `PyContext_ClearFreeList()`
  - `PyDict_ClearFreeList()`
  - `PyFloat_ClearFreeList()`
  - `PyFrame_ClearFreeList()`
  - `PyList_ClearFreeList()`
  - `PyMethod_ClearFreeList()` and `PyCFunction_ClearFreeList()`: the free lists of bound method objects have been removed.
  - `PySet_ClearFreeList()`: the set free list has been removed in Python 3.4.
  - `PyTuple_ClearFreeList()`
  - `PyUnicode_ClearFreeList()`: the Unicode free list has been removed in Python 3.3.

- Removed `_PyUnicode_ClearStaticStrings()` function. (Contributed by Victor Stinner in `39465`{.interpreted-text role="issue"}.)

- Removed `Py_UNICODE_MATCH`. It has been deprecated by `393`{.interpreted-text role="pep"}, and broken since Python 3.3. The `PyUnicode_Tailmatch`{.interpreted-text role="c:func"} function can be used instead. (Contributed by Inada Naoki in `36346`{.interpreted-text role="issue"}.)

- Cleaned header files of interfaces defined but with no implementation. The public API symbols being removed are: `_PyBytes_InsertThousandsGroupingLocale`, `_PyBytes_InsertThousandsGrouping`, `_Py_InitializeFromArgs`, `_Py_InitializeFromWideArgs`, `_PyFloat_Repr`, `_PyFloat_Digits`, `_PyFloat_DigitsInit`, `PyFrame_ExtendStack`, `_PyAIterWrapper_Type`, `PyNullImporter_Type`, `PyCmpWrapper_Type`, `PySortWrapper_Type`, `PyNoArgsFunction`. (Contributed by Pablo Galindo Salgado in `39372`{.interpreted-text role="issue"}.)

## Notable changes in Python 3.9.1

### typing

The behavior of `typing.Literal`{.interpreted-text role="class"} was changed to conform with `586`{.interpreted-text role="pep"} and to match the behavior of static type checkers specified in the PEP.

1.  `Literal` now de-duplicates parameters.

2.  Equality comparisons between `Literal` objects are now order independent.

3.  `Literal` comparisons now respect types. For example, `Literal[0] == Literal[False]` previously evaluated to `True`. It is now `False`. To support this change, the internally used type cache now supports differentiating types.

4.  `Literal` objects will now raise a `TypeError`{.interpreted-text role="exc"} exception during equality comparisons if any of their parameters are not `hashable`{.interpreted-text role="term"}. Note that declaring `Literal` with mutable parameters will not throw an error:

        >>> from typing import Literal
        >>> Literal[{0}]
        >>> Literal[{0}] == Literal[{False}]
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        TypeError: unhashable type: 'set'

(Contributed by Yurii Karabas in `42345`{.interpreted-text role="issue"}.)

### macOS 11.0 (Big Sur) and Apple Silicon Mac support

As of 3.9.1, Python now fully supports building and running on macOS 11.0 (Big Sur) and on Apple Silicon Macs (based on the `ARM64` architecture). A new universal build variant, `universal2`, is now available to natively support both `ARM64` and `Intel 64` in one set of executables. Binaries can also now be built on current versions of macOS to be deployed on a range of older macOS versions (tested to 10.9) while making some newer OS functions and options conditionally available based on the operating system version in use at runtime (\"weaklinking\").

(Contributed by Ronald Oussoren and Lawrence D\'Anna in `41100`{.interpreted-text role="issue"}.)

## Notable changes in Python 3.9.2

### collections.abc

`collections.abc.Callable`{.interpreted-text role="class"} generic now flattens type parameters, similar to what `typing.Callable`{.interpreted-text role="data"} currently does. This means that `collections.abc.Callable[[int, str], str]` will have `__args__` of `(int, str, str)`; previously this was `([int, str], str)`. To allow this change, `types.GenericAlias`{.interpreted-text role="class"} can now be subclassed, and a subclass will be returned when subscripting the `collections.abc.Callable`{.interpreted-text role="class"} type. Code which accesses the arguments via `typing.get_args`{.interpreted-text role="func"} or `__args__` need to account for this change. A `DeprecationWarning`{.interpreted-text role="exc"} may be emitted for invalid forms of parameterizing `collections.abc.Callable`{.interpreted-text role="class"} which may have passed silently in Python 3.9.1. This `DeprecationWarning`{.interpreted-text role="exc"} will become a `TypeError`{.interpreted-text role="exc"} in Python 3.10. (Contributed by Ken Jin in `42195`{.interpreted-text role="issue"}.)

### urllib.parse

Earlier Python versions allowed using both `;` and `&` as query parameter separators in `urllib.parse.parse_qs`{.interpreted-text role="func"} and `urllib.parse.parse_qsl`{.interpreted-text role="func"}. Due to security concerns, and to conform with newer W3C recommendations, this has been changed to allow only a single separator key, with `&` as the default. This change also affects `!cgi.parse`{.interpreted-text role="func"} and `!cgi.parse_multipart`{.interpreted-text role="func"} as they use the affected functions internally. For more details, please see their respective documentation. (Contributed by Adam Goldschmidt, Senthil Kumaran and Ken Jin in `42967`{.interpreted-text role="issue"}.)

## Notable changes in Python 3.9.3

A security fix alters the `ftplib.FTP`{.interpreted-text role="class"} behavior to not trust the IPv4 address sent from the remote server when setting up a passive data channel. We reuse the ftp server IP address instead. For unusual code requiring the old behavior, set a `trust_server_pasv_ipv4_address` attribute on your FTP instance to `True`. (See `87451`{.interpreted-text role="gh"})

## Notable changes in Python 3.9.5

### urllib.parse

The presence of newline or tab characters in parts of a URL allows for some forms of attacks. Following the WHATWG specification that updates `3986`{.interpreted-text role="rfc"}, ASCII newline `\n`, `\r` and tab `\t` characters are stripped from the URL by the parser in `urllib.parse`{.interpreted-text role="mod"} preventing such attacks. The removal characters are controlled by a new module level variable `urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE`. (See `88048`{.interpreted-text role="gh"})

## Notable security feature in 3.9.14

Converting between `int`{.interpreted-text role="class"} and `str`{.interpreted-text role="class"} in bases other than 2 (binary), 4, 8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now raises a `ValueError`{.interpreted-text role="exc"} if the number of digits in string form is above a limit to avoid potential denial of service attacks due to the algorithmic complexity. This is a mitigation for `2020-10735`{.interpreted-text role="cve"}. This limit can be configured or disabled by environment variable, command line flag, or `sys`{.interpreted-text role="mod"} APIs. See the `integer string conversion
length limitation <int_max_str_digits>`{.interpreted-text role="ref"} documentation. The default limit is 4300 digits in string form.

## Notable changes in 3.9.17

### tarfile

- The extraction methods in `tarfile`{.interpreted-text role="mod"}, and `shutil.unpack_archive`{.interpreted-text role="func"}, have a new a *filter* argument that allows limiting tar features than may be surprising or dangerous, such as creating files outside the destination directory. See `tarfile-extraction-filter`{.interpreted-text role="ref"} for details. In Python 3.12, use without the *filter* argument will show a `DeprecationWarning`{.interpreted-text role="exc"}. In Python 3.14, the default will switch to `'data'`. (Contributed by Petr Viktorin in `706`{.interpreted-text role="pep"}.)