****************************
  What's New In Python 3.8
****************************

.. Rules for maintenance:

   * Anyone can add text to this document.  Do not spend very much time
   on the wording of your changes, because your text will probably
   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 I consider too small
   or esoteric to include.  If such a change is added to the text,
   I'll just remove it.  (This is another reason you shouldn't spend
   too much time on writing your addition.)

   * 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 :issue:`12345`.)

   This saves the maintainer the effort of going through the Git log
   when researching a change.

:Editor: Raymond Hettinger

This article explains the new features in Python 3.8, compared to 3.7.
For full details, see the :ref:`changelog <changelog>`.

Python 3.8 was released on October 14th, 2019.

.. testsetup::

   from datetime import date
   from math import cos, radians
   from unicodedata import normalize
   import re
   import math


Summary -- Release highlights
=============================

.. This section singles out the most important changes in Python 3.8.
   Brevity is key.


.. PEP-sized items next.



New Features
============

Assignment expressions
----------------------

There is new syntax ``:=`` that assigns values to variables as part of a larger
expression. It is affectionately known as "the walrus operator" due to
its resemblance to `the eyes and tusks of a walrus
<https://en.wikipedia.org/wiki/Walrus#/media/File:Pacific_Walrus_-_Bull_(8247646168).jpg>`_.

In this example, the assignment expression helps avoid calling
:func:`len` twice::

  if (n := len(a)) > 10:
      print(f"List is too long ({n} elements, expected <= 10)")

A similar benefit arises during regular expression matching where
match objects are needed twice, once to test whether a match
occurred and another to extract a subgroup::

  discount = 0.0
  if (mo := re.search(r'(\d+)% discount', advertisement)):
      discount = float(mo.group(1)) / 100.0

The operator is also useful with while-loops that compute
a value to test loop termination and then need that same
value again in the body of the loop::

  # Loop over fixed length blocks
  while (block := f.read(256)) != '':
      process(block)

Another motivating use case arises in list comprehensions where
a value computed in a filtering condition is also needed in
the expression body::

   [clean_name.title() for name in names
    if (clean_name := normalize('NFC', name)) in allowed_names]

Try to limit use of the walrus operator to clean cases that reduce
complexity and improve readability.

See :pep:`572` for a full description.

(Contributed by Emily Morehouse in :issue:`35224`.)


Positional-only parameters
--------------------------

There is a new function parameter syntax ``/`` to indicate that some
function parameters must be specified positionally and cannot be used as
keyword arguments.  This is the same notation shown by ``help()`` for C
functions annotated with Larry Hastings' `Argument Clinic
<https://docs.python.org/3/howto/clinic.html>`_ tool.

In the following example, parameters *a* and *b* are positional-only,
while *c* or *d* can be positional or keyword, and *e* or *f* are
required to be keywords::

  def f(a, b, /, c, d, *, e, f):
      print(a, b, c, d, e, f)

The following is a valid call::

  f(10, 20, 30, d=40, e=50, f=60)

However, these are invalid calls::

  f(10, b=20, c=30, d=40, e=50, f=60)   # b cannot be a keyword argument
  f(10, 20, 30, 40, 50, f=60)           # e must be a keyword argument

One use case for this notation is that it allows pure Python functions
to fully emulate behaviors of existing C coded functions.  For example,
the built-in :func:`pow` function does not accept keyword arguments::

  def pow(x, y, z=None, /):
      "Emulate the built in pow() function"
      r = x ** y
      return r if z is None else r%z

Another use case is to preclude keyword arguments when the parameter
name is not helpful.  For example, the builtin :func:`len` function has
the signature ``len(obj, /)``.  This precludes awkward calls such as::

  len(obj='hello')  # The "obj" keyword argument impairs readability

A further benefit of marking a parameter as positional-only is that it
allows the parameter name to be changed in the future without risk of
breaking client code.  For example, in the :mod:`statistics` module, the
parameter name *dist* may be changed in the future.  This was made
possible with the following function specification::

  def quantiles(dist, /, *, n=4, method='exclusive')
      ...

Since the parameters to the left of ``/`` are not exposed as possible
keywords, the parameters names remain available for use in ``**kwargs``::

  >>> def f(a, b, /, **kwargs):
  ...     print(a, b, kwargs)
  ...
  >>> f(10, 20, a=1, b=2, c=3)         # a and b are used in two ways
  10 20 {'a': 1, 'b': 2, 'c': 3}

This greatly simplifies the implementation of functions and methods
that need to accept arbitrary keyword arguments.  For example, here
is an excerpt from code in the :mod:`collections` module::

  class Counter(dict):

      def __init__(self, iterable=None, /, **kwds):
          # Note "iterable" is a possible keyword argument

See :pep:`570` for a full description.

(Contributed by Pablo Galindo in :issue:`36540`.)

.. TODO: Pablo will sprint on docs at PyCon US 2019.


Parallel filesystem cache for compiled bytecode files
-----------------------------------------------------

The new :envvar:`PYTHONPYCACHEPREFIX` setting (also available as
:option:`-X` ``pycache_prefix``) configures the implicit bytecode
cache to use a separate parallel filesystem tree, rather than
the default ``__pycache__`` subdirectories within each source
directory.

The location of the cache is reported in :data:`sys.pycache_prefix`
(:const:`None` indicates the default location in ``__pycache__``
subdirectories).

(Contributed by Carl Meyer in :issue:`33499`.)


Debug build uses the same ABI as release build
-----------------------------------------------

Python now uses the same ABI whether it's built in release or debug mode. On
Unix, when Python is built in debug mode, it is now possible to load C
extensions built in release mode and C extensions built using the stable ABI.

Release builds and debug builds are now ABI compatible: defining the
``Py_DEBUG`` macro no longer implies the ``Py_TRACE_REFS`` macro, which
introduces the only ABI incompatibility. The ``Py_TRACE_REFS`` macro, which
adds the :func:`sys.getobjects` function and the :envvar:`PYTHONDUMPREFS`
environment variable, can be set using the new ``./configure --with-trace-refs``
build option.
(Contributed by Victor Stinner in :issue:`36465`.)

On Unix, C extensions are no longer linked to libpython except on Android
and Cygwin.
It is now possible
for a statically linked Python to load a C extension built using a shared
library Python.
(Contributed by Victor Stinner in :issue:`21536`.)

On Unix, when Python is built in debug mode, import now also looks for C
extensions compiled in release mode and for C extensions compiled with the
stable ABI.
(Contributed by Victor Stinner in :issue:`36722`.)

To embed Python into an application, a new ``--embed`` option must be passed to
``python3-config --libs --embed`` to get ``-lpython3.8`` (link the application
to libpython). To support both 3.8 and older, try ``python3-config --libs
--embed`` first and fallback to ``python3-config --libs`` (without ``--embed``)
if the previous command fails.

Add a pkg-config ``python-3.8-embed`` module to embed Python into an
application: ``pkg-config python-3.8-embed --libs`` includes ``-lpython3.8``.
To support both 3.8 and older, try ``pkg-config python-X.Y-embed --libs`` first
and fallback to ``pkg-config python-X.Y --libs`` (without ``--embed``) if the
previous command fails (replace ``X.Y`` with the Python version).

On the other hand, ``pkg-config python3.8 --libs`` no longer contains
``-lpython3.8``. C extensions must not be linked to libpython (except on
Android and Cygwin, whose cases are handled by the script);
this change is backward incompatible on purpose.
(Contributed by Victor Stinner in :issue:`36721`.)


f-strings support ``=`` for self-documenting expressions and debugging
----------------------------------------------------------------------

Added an ``=`` specifier to :term:`f-string`\s. An f-string such as
``f'{expr=}'`` will expand to the text of the expression, an equal sign,
then the representation of the evaluated expression.  For example:

  >>> user = 'eric_idle'
  >>> member_since = date(1975, 7, 31)
  >>> f'{user=} {member_since=}'
  "user='eric_idle' member_since=datetime.date(1975, 7, 31)"

The usual :ref:`f-string format specifiers <f-strings>` allow more
control over how the result of the expression is displayed::

  >>> delta = date.today() - member_since
  >>> f'{user=!s}  {delta.days=:,d}'
  'user=eric_idle  delta.days=16,075'

The ``=`` specifier will display the whole expression so that
calculations can be shown::

  >>> print(f'{theta=}  {cos(radians(theta))=:.3f}')
  theta=30  cos(radians(theta))=0.866

(Contributed by Eric V. Smith and Larry Hastings in :issue:`36817`.)


PEP 578: Python Runtime Audit Hooks
-----------------------------------

The PEP adds an Audit Hook and Verified Open Hook. Both are available from
Python and native code, allowing applications and frameworks written in pure
Python code to take advantage of extra notifications, while also allowing
embedders or system administrators to deploy builds of Python where auditing is
always enabled.

See :pep:`578` for full details.


PEP 587: Python Initialization Configuration
--------------------------------------------

The :pep:`587` adds a new C API to configure the Python Initialization
providing finer control on the whole configuration and better error reporting.

New structures:

* :c:type:`PyConfig`
* :c:type:`PyPreConfig`
* :c:type:`PyStatus`
* :c:type:`PyWideStringList`

New functions:

* :c:func:`PyConfig_Clear`
* :c:func:`PyConfig_InitIsolatedConfig`
* :c:func:`PyConfig_InitPythonConfig`
* :c:func:`PyConfig_Read`
* :c:func:`PyConfig_SetArgv`
* :c:func:`PyConfig_SetBytesArgv`
* :c:func:`PyConfig_SetBytesString`
* :c:func:`PyConfig_SetString`
* :c:func:`PyPreConfig_InitIsolatedConfig`
* :c:func:`PyPreConfig_InitPythonConfig`
* :c:func:`PyStatus_Error`
* :c:func:`PyStatus_Exception`
* :c:func:`PyStatus_Exit`
* :c:func:`PyStatus_IsError`
* :c:func:`PyStatus_IsExit`
* :c:func:`PyStatus_NoMemory`
* :c:func:`PyStatus_Ok`
* :c:func:`PyWideStringList_Append`
* :c:func:`PyWideStringList_Insert`
* :c:func:`Py_BytesMain`
* :c:func:`Py_ExitStatusException`
* :c:func:`Py_InitializeFromConfig`
* :c:func:`Py_PreInitialize`
* :c:func:`Py_PreInitializeFromArgs`
* :c:func:`Py_PreInitializeFromBytesArgs`
* :c:func:`Py_RunMain`

This PEP also adds ``_PyRuntimeState.preconfig`` (:c:type:`PyPreConfig` type)
and ``PyInterpreterState.config`` (:c:type:`PyConfig` type) fields to these
internal structures. ``PyInterpreterState.config`` becomes the new
reference configuration, replacing global configuration variables and
other private variables.

See :ref:`Python Initialization Configuration <init-config>` for the
documentation.

See :pep:`587` for a full description.

(Contributed by Victor Stinner in :issue:`36763`.)


Vectorcall: a fast calling protocol for CPython
-----------------------------------------------

The "vectorcall" protocol is added to the Python/C API.
It is meant to formalize existing optimizations which were already done
for various classes.
Any extension type implementing a callable can use this protocol.

This is currently provisional.
The aim is to make it fully public in Python 3.9.

See :pep:`590` for a full description.

(Contributed by Jeroen Demeyer and Mark Shannon in :issue:`36974`.)


Pickle protocol 5 with out-of-band data buffers
-----------------------------------------------

When :mod:`pickle` is used to transfer large data between Python processes
in order to take advantage of multi-core or multi-machine processing,
it is important to optimize the transfer by reducing memory copies, and
possibly by applying custom techniques such as data-dependent compression.

The :mod:`pickle` protocol 5 introduces support for out-of-band buffers
where :pep:`3118`-compatible data can be transmitted separately from the
main pickle stream, at the discretion of the communication layer.

See :pep:`574` for a full description.

(Contributed by Antoine Pitrou in :issue:`36785`.)


Other Language Changes
======================

* A :keyword:`continue` statement was illegal in the :keyword:`finally` clause
  due to a problem with the implementation.  In Python 3.8 this restriction
  was lifted.
  (Contributed by Serhiy Storchaka in :issue:`32489`.)

* The :class:`bool`, :class:`int`, and :class:`fractions.Fraction` types
  now have an :meth:`~int.as_integer_ratio` method like that found in
  :class:`float` and :class:`decimal.Decimal`.  This minor API extension
  makes it possible to write ``numerator, denominator =
  x.as_integer_ratio()`` and have it work across multiple numeric types.
  (Contributed by Lisa Roach in :issue:`33073` and Raymond Hettinger in
  :issue:`37819`.)

* Constructors of :class:`int`, :class:`float` and :class:`complex` will now
  use the :meth:`~object.__index__` special method, if available and the
  corresponding method :meth:`~object.__int__`, :meth:`~object.__float__`
  or :meth:`~object.__complex__` is not available.
  (Contributed by Serhiy Storchaka in :issue:`20092`.)

* Added support of ``\N{name}`` escapes in :mod:`regular expressions <re>`::

    >>> notice = 'Copyright © 2019'
    >>> copyright_year_pattern = re.compile(r'\N{copyright sign}\s*(\d{4})')
    >>> int(copyright_year_pattern.search(notice).group(1))
    2019

  (Contributed by Jonathan Eunice and Serhiy Storchaka in :issue:`30688`.)

* Dict and dictviews are now iterable in reversed insertion order using
  :func:`reversed`. (Contributed by Rémi Lapeyre in :issue:`33462`.)

* The syntax allowed for keyword names in function calls was further
  restricted. In particular, ``f((keyword)=arg)`` is no longer allowed. It was
  never intended to permit more than a bare name on the left-hand side of a
  keyword argument assignment term.
  (Contributed by Benjamin Peterson in :issue:`34641`.)

* Generalized iterable unpacking in :keyword:`yield` and
  :keyword:`return` statements no longer requires enclosing parentheses.
  This brings the *yield* and *return* syntax into better agreement with
  normal assignment syntax::

    >>> def parse(family):
            lastname, *members = family.split()
            return lastname.upper(), *members

    >>> parse('simpsons homer marge bart lisa sally')
    ('SIMPSONS', 'homer', 'marge', 'bart', 'lisa', 'sally')

  (Contributed by David Cuthbert and Jordan Chapman in :issue:`32117`.)

* When a comma is missed in code such as ``[(10, 20) (30, 40)]``, the
  compiler displays a :exc:`SyntaxWarning` with a helpful suggestion.
  This improves on just having a :exc:`TypeError` indicating that the
  first tuple was not callable.  (Contributed by Serhiy Storchaka in
  :issue:`15248`.)

* Arithmetic operations between subclasses of :class:`datetime.date` or
  :class:`datetime.datetime` and :class:`datetime.timedelta` objects now return
  an instance of the subclass, rather than the base class. This also affects
  the return type of operations whose implementation (directly or indirectly)
  uses :class:`datetime.timedelta` arithmetic, such as
  :meth:`~datetime.datetime.astimezone`.
  (Contributed by Paul Ganssle in :issue:`32417`.)

* When the Python interpreter is interrupted by Ctrl-C (SIGINT) and the
  resulting :exc:`KeyboardInterrupt` exception is not caught, the Python process
  now exits via a SIGINT signal or with the correct exit code such that the
  calling process can detect that it died due to a Ctrl-C.  Shells on POSIX
  and Windows use this to properly terminate scripts in interactive sessions.
  (Contributed by Google via Gregory P. Smith in :issue:`1054041`.)

* Some advanced styles of programming require updating the
  :class:`types.CodeType` object for an existing function.  Since code
  objects are immutable, a new code object needs to be created, one
  that is modeled on the existing code object.  With 19 parameters,
  this was somewhat tedious.  Now, the new ``replace()`` method makes
  it possible to create a clone with a few altered parameters.

  Here's an example that alters the :func:`statistics.mean` function to
  prevent the *data* parameter from being used as a keyword argument::

    >>> from statistics import mean
    >>> mean(data=[10, 20, 90])
    40
    >>> mean.__code__ = mean.__code__.replace(co_posonlyargcount=1)
    >>> mean(data=[10, 20, 90])
    Traceback (most recent call last):
      ...
    TypeError: mean() got some positional-only arguments passed as keyword arguments: 'data'

  (Contributed by Victor Stinner in :issue:`37032`.)

* For integers, the three-argument form of the :func:`pow` function now
  permits the exponent to be negative in the case where the base is
  relatively prime to the modulus. It then computes a modular inverse to
  the base when the exponent is ``-1``, and a suitable power of that
  inverse for other negative exponents.  For example, to compute the
  `modular multiplicative inverse
  <https://en.wikipedia.org/wiki/Modular_multiplicative_inverse>`_ of 38
  modulo 137, write::

    >>> pow(38, -1, 137)
    119
    >>> 119 * 38 % 137
    1

  Modular inverses arise in the solution of `linear Diophantine
  equations <https://en.wikipedia.org/wiki/Diophantine_equation>`_.
  For example, to find integer solutions for ``4258𝑥 + 147𝑦 = 369``,
  first rewrite as ``4258𝑥 ≡ 369 (mod 147)`` then solve:

    >>> x = 369 * pow(4258, -1, 147) % 147
    >>> y = (4258 * x - 369) // -147
    >>> 4258 * x + 147 * y
    369

  (Contributed by Mark Dickinson in :issue:`36027`.)

* Dict comprehensions have been synced-up with dict literals so that the
  key is computed first and the value second::

    >>> # Dict comprehension
    >>> cast = {input('role? '): input('actor? ') for i in range(2)}
    role? King Arthur
    actor? Chapman
    role? Black Knight
    actor? Cleese

    >>> # Dict literal
    >>> cast = {input('role? '): input('actor? ')}
    role? Sir Robin
    actor? Eric Idle

  The guaranteed execution order is helpful with assignment expressions
  because variables assigned in the key expression will be available in
  the value expression::

    >>> names = ['Martin von Löwis', 'Łukasz Langa', 'Walter Dörwald']
    >>> {(n := normalize('NFC', name)).casefold() : n for name in names}
    {'martin von löwis': 'Martin von Löwis',
     'łukasz langa': 'Łukasz Langa',
     'walter dörwald': 'Walter Dörwald'}

  (Contributed by Jörn Heissler in :issue:`35224`.)

* The :meth:`object.__reduce__` method can now return a tuple from two to
  six elements long. Formerly, five was the limit.  The new, optional sixth
  element is a callable with a ``(obj, state)`` signature.  This allows the
  direct control over the state-updating behavior of a specific object.  If
  not *None*, this callable will have priority over the object's
  :meth:`~__setstate__` method.
  (Contributed by Pierre Glaser and Olivier Grisel in :issue:`35900`.)

New Modules
===========

* The new :mod:`importlib.metadata` module provides (provisional) support for
  reading metadata from third-party packages.  For example, it can extract an
  installed package's version number, list of entry points, and more::

    >>> # Note following example requires that the popular "requests"
    >>> # package has been installed.
    >>>
    >>> from importlib.metadata import version, requires, files
    >>> version('requests')
    '2.22.0'
    >>> list(requires('requests'))
    ['chardet (<3.1.0,>=3.0.2)']
    >>> list(files('requests'))[:5]
    [PackagePath('requests-2.22.0.dist-info/INSTALLER'),
     PackagePath('requests-2.22.0.dist-info/LICENSE'),
     PackagePath('requests-2.22.0.dist-info/METADATA'),
     PackagePath('requests-2.22.0.dist-info/RECORD'),
     PackagePath('requests-2.22.0.dist-info/WHEEL')]

  (Contributed by Barry Warsaw and Jason R. Coombs in :issue:`34632`.)


Improved Modules
================

ast
---

AST nodes now have ``end_lineno`` and ``end_col_offset`` attributes,
which give the precise location of the end of the node.  (This only
applies to nodes that have ``lineno`` and ``col_offset`` attributes.)

New function :func:`ast.get_source_segment` returns the source code
for a specific AST node.

(Contributed by Ivan Levkivskyi in :issue:`33416`.)

The :func:`ast.parse` function has some new flags:

* ``type_comments=True`` causes it to return the text of :pep:`484` and
  :pep:`526` type comments associated with certain AST nodes;

* ``mode='func_type'`` can be used to parse :pep:`484` "signature type
  comments" (returned for function definition AST nodes);

* ``feature_version=(3, N)`` allows specifying an earlier Python 3
  version.  For example, ``feature_version=(3, 4)`` will treat
  :keyword:`async` and :keyword:`await` as non-reserved words.

(Contributed by Guido van Rossum in :issue:`35766`.)


asyncio
-------

:func:`asyncio.run` has graduated from the provisional to stable API. This
function can be used to execute a :term:`coroutine` and return the result while
automatically managing the event loop. For example::

    import asyncio

    async def main():
        await asyncio.sleep(0)
        return 42

    asyncio.run(main())

This is *roughly* equivalent to::

    import asyncio

    async def main():
        await asyncio.sleep(0)
        return 42

    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    try:
        loop.run_until_complete(main())
    finally:
        asyncio.set_event_loop(None)
        loop.close()


The actual implementation is significantly more complex. Thus,
:func:`asyncio.run` should be the preferred way of running asyncio programs.

(Contributed by Yury Selivanov in :issue:`32314`.)

Running ``python -m asyncio`` launches a natively async REPL.  This allows rapid
experimentation with code that has a top-level :keyword:`await`.  There is no
longer a need to directly call ``asyncio.run()`` which would spawn a new event
loop on every invocation:

.. code-block:: none

    $ python -m asyncio
    asyncio REPL 3.8.0
    Use "await" directly instead of "asyncio.run()".
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import asyncio
    >>> await asyncio.sleep(10, result='hello')
    hello

(Contributed by Yury Selivanov in :issue:`37028`.)

The exception :class:`asyncio.CancelledError` now inherits from
:class:`BaseException` rather than :class:`Exception`.
(Contributed by Yury Selivanov in :issue:`32528`.)

On Windows, the default event loop is now :class:`~asyncio.ProactorEventLoop`.
(Contributed by Victor Stinner in :issue:`34687`.)

:class:`~asyncio.ProactorEventLoop` now also supports UDP.
(Contributed by Adam Meily and Andrew Svetlov in :issue:`29883`.)

:class:`~asyncio.ProactorEventLoop` can now be interrupted by
:exc:`KeyboardInterrupt` ("CTRL+C").
(Contributed by Vladimir Matveev in :issue:`23057`.)

Added :meth:`asyncio.Task.get_coro` for getting the wrapped coroutine
within an :class:`asyncio.Task`.
(Contributed by Alex Grönholm in :issue:`36999`.)

Asyncio tasks can now be named, either by passing the ``name`` keyword
argument to :func:`asyncio.create_task` or
the :meth:`~asyncio.loop.create_task` event loop method, or by
calling the :meth:`~asyncio.Task.set_name` method on the task object. The
task name is visible in the ``repr()`` output of :class:`asyncio.Task` and
can also be retrieved using the :meth:`~asyncio.Task.get_name` method.
(Contributed by Alex Grönholm in :issue:`34270`.)

Added support for
`Happy Eyeballs <https://en.wikipedia.org/wiki/Happy_Eyeballs>`_ to
:func:`asyncio.loop.create_connection`. To specify the behavior, two new
parameters have been added: *happy_eyeballs_delay* and *interleave*. The Happy
Eyeballs algorithm improves responsiveness in applications that support IPv4
and IPv6 by attempting to simultaneously connect using both.
(Contributed by twisteroid ambassador in :issue:`33530`.)


builtins
--------

The :func:`compile` built-in has been improved to accept the
``ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`` flag. With this new flag passed,
:func:`compile` will allow top-level ``await``, ``async for`` and ``async with``
constructs that are usually considered invalid syntax. Asynchronous code object
marked with the ``CO_COROUTINE`` flag may then be returned.
(Contributed by Matthias Bussonnier in :issue:`34616`)


collections
-----------

The :meth:`~collections.somenamedtuple._asdict` method for
:func:`collections.namedtuple` now returns a :class:`dict` instead of a
:class:`collections.OrderedDict`. This works because regular dicts have
guaranteed ordering since Python 3.7. If the extra features of
:class:`OrderedDict` are required, the suggested remediation is to cast the
result to the desired type: ``OrderedDict(nt._asdict())``.
(Contributed by Raymond Hettinger in :issue:`35864`.)


cProfile
--------

The :class:`cProfile.Profile <profile.Profile>` class can now be used as a context manager.
Profile a block of code by running::

      import cProfile

      with cProfile.Profile() as profiler:
            # code to be profiled
            ...

(Contributed by Scott Sanderson in :issue:`29235`.)


csv
---

The :class:`csv.DictReader` now returns instances of :class:`dict` instead of
a :class:`collections.OrderedDict`.  The tool is now faster and uses less
memory while still preserving the field order.
(Contributed by Michael Seek in :issue:`34003`.)


curses
-------

Added a new variable holding structured version information for the
underlying ncurses library: :data:`~curses.ncurses_version`.
(Contributed by Serhiy Storchaka in :issue:`31680`.)


ctypes
------

On Windows, :class:`~ctypes.CDLL` and subclasses now accept a *winmode* parameter
to specify flags for the underlying ``LoadLibraryEx`` call. The default flags are
set to only load DLL dependencies from trusted locations, including the path
where the DLL is stored (if a full or partial path is used to load the initial
DLL) and paths added by :func:`~os.add_dll_directory`.
(Contributed by Steve Dower in :issue:`36085`.)


datetime
--------

Added new alternate constructors :meth:`datetime.date.fromisocalendar` and
:meth:`datetime.datetime.fromisocalendar`, which construct :class:`date` and
:class:`datetime` objects respectively from ISO year, week number, and weekday;
these are the inverse of each class's ``isocalendar`` method.
(Contributed by Paul Ganssle in :issue:`36004`.)


functools
---------

:func:`functools.lru_cache` can now be used as a straight decorator rather
than as a function returning a decorator.  So both of these are now supported::

    @lru_cache
    def f(x):
        ...

    @lru_cache(maxsize=256)
    def f(x):
        ...

(Contributed by Raymond Hettinger in :issue:`36772`.)

Added a new :func:`functools.cached_property` decorator, for computed properties
cached for the life of the instance. ::

   import functools
   import statistics

   class Dataset:
      def __init__(self, sequence_of_numbers):
         self.data = sequence_of_numbers

      @functools.cached_property
      def variance(self):
         return statistics.variance(self.data)

(Contributed by Carl Meyer in :issue:`21145`)


Added a new :func:`functools.singledispatchmethod` decorator that converts
methods into :term:`generic functions <generic function>` using
:term:`single dispatch`::

    from functools import singledispatchmethod
    from contextlib import suppress

    class TaskManager:

        def __init__(self, tasks):
            self.tasks = list(tasks)

        @singledispatchmethod
        def discard(self, value):
            with suppress(ValueError):
                self.tasks.remove(value)

        @discard.register(list)
        def _(self, tasks):
            targets = set(tasks)
            self.tasks = [x for x in self.tasks if x not in targets]

(Contributed by Ethan Smith in :issue:`32380`)

gc
--

:func:`~gc.get_objects` can now receive an optional *generation* parameter
indicating a generation to get objects from.
(Contributed by Pablo Galindo in :issue:`36016`.)


gettext
-------

Added :func:`~gettext.pgettext` and its variants.
(Contributed by Franz Glasner, Éric Araujo, and Cheryl Sabella in :issue:`2504`.)


gzip
----

Added the *mtime* parameter to :func:`gzip.compress` for reproducible output.
(Contributed by Guo Ci Teo in :issue:`34898`.)

A :exc:`~gzip.BadGzipFile` exception is now raised instead of :exc:`OSError`
for certain types of invalid or corrupt gzip files.
(Contributed by Filip Gruszczyński, Michele Orrù, and Zackery Spytz in
:issue:`6584`.)


IDLE and idlelib
----------------

Output over N lines (50 by default) is squeezed down to a button.
N can be changed in the PyShell section of the General page of the
Settings dialog.  Fewer, but possibly extra long, lines can be squeezed by
right clicking on the output.  Squeezed output can be expanded in place
by double-clicking the button or into the clipboard or a separate window
by right-clicking the button.  (Contributed by Tal Einat in :issue:`1529353`.)

Add "Run Customized" to the Run menu to run a module with customized
settings. Any command line arguments entered are added to sys.argv.
They also re-appear in the box for the next customized run.  One can also
suppress the normal Shell main module restart.  (Contributed by Cheryl
Sabella, Terry Jan Reedy, and others in :issue:`5680` and :issue:`37627`.)

Added optional line numbers for IDLE editor windows. Windows
open without line numbers unless set otherwise in the General
tab of the configuration dialog.  Line numbers for an existing
window are shown and hidden in the Options menu.
(Contributed by Tal Einat and Saimadhav Heblikar in :issue:`17535`.)

OS native encoding is now used for converting between Python strings and Tcl
objects. This allows IDLE to work with emoji and other non-BMP characters.
These characters can be displayed or copied and pasted to or from the
clipboard.  Converting strings from Tcl to Python and back now never fails.
(Many people worked on this for eight years but the problem was finally
solved by Serhiy Storchaka in :issue:`13153`.)

The changes above have been backported to 3.7 maintenance releases.


inspect
-------

The :func:`inspect.getdoc` function can now find docstrings for ``__slots__``
if that attribute is a :class:`dict` where the values are docstrings.
This provides documentation options similar to what we already have
for :func:`property`, :func:`classmethod`, and :func:`staticmethod`::

  class AudioClip:
      __slots__ = {'bit_rate': 'expressed in kilohertz to one decimal place',
                   'duration': 'in seconds, rounded up to an integer'}
      def __init__(self, bit_rate, duration):
          self.bit_rate = round(bit_rate / 1000.0, 1)
          self.duration = ceil(duration)

(Contributed by Raymond Hettinger in :issue:`36326`.)


io
--

In development mode (:option:`-X` ``env``) and in debug build, the
:class:`io.IOBase` finalizer now logs the exception if the ``close()`` method
fails. The exception is ignored silently by default in release build.
(Contributed by Victor Stinner in :issue:`18748`.)


itertools
---------

The :func:`itertools.accumulate` function added an option *initial* keyword
argument to specify an initial value::

    >>> from itertools import accumulate
    >>> list(accumulate([10, 5, 30, 15], initial=1000))
    [1000, 1010, 1015, 1045, 1060]

(Contributed by Lisa Roach in :issue:`34659`.)


json.tool
---------

Add option ``--json-lines`` to parse every input line as a separate JSON object.
(Contributed by Weipeng Hong in :issue:`31553`.)


logging
-------

Added a *force* keyword argument to :func:`logging.basicConfig()`
When set to true, any existing handlers attached
to the root logger are removed and closed before carrying out the
configuration specified by the other arguments.

This solves a long-standing problem.  Once a logger or *basicConfig()* had
been called, subsequent calls to *basicConfig()* were silently ignored.
This made it difficult to update, experiment with, or teach the various
logging configuration options using the interactive prompt or a Jupyter
notebook.

(Suggested by Raymond Hettinger, implemented by Dong-hee Na, and
reviewed by Vinay Sajip in :issue:`33897`.)


math
----

Added new function :func:`math.dist` for computing Euclidean distance
between two points.  (Contributed by Raymond Hettinger in :issue:`33089`.)

Expanded the :func:`math.hypot` function to handle multiple dimensions.
Formerly, it only supported the 2-D case.
(Contributed by Raymond Hettinger in :issue:`33089`.)

Added new function, :func:`math.prod`, as analogous function to :func:`sum`
that returns the product of a 'start' value (default: 1) times an iterable of
numbers::

    >>> prior = 0.8
    >>> likelihoods = [0.625, 0.84, 0.30]
    >>> math.prod(likelihoods, start=prior)
    0.126

(Contributed by Pablo Galindo in :issue:`35606`.)

Added two new combinatoric functions :func:`math.perm` and :func:`math.comb`::

    >>> math.perm(10, 3)    # Permutations of 10 things taken 3 at a time
    720
    >>> math.comb(10, 3)    # Combinations of 10 things taken 3 at a time
    120

(Contributed by Yash Aggarwal, Keller Fuchs, Serhiy Storchaka, and Raymond
Hettinger in :issue:`37128`, :issue:`37178`, and :issue:`35431`.)

Added a new function :func:`math.isqrt` for computing accurate integer square
roots without conversion to floating point.  The new function supports
arbitrarily large integers.  It is faster than ``floor(sqrt(n))`` but slower
than :func:`math.sqrt`::

    >>> r = 650320427
    >>> s = r ** 2
    >>> isqrt(s - 1)         # correct
    650320426
    >>> floor(sqrt(s - 1))   # incorrect
    650320427

(Contributed by Mark Dickinson in :issue:`36887`.)

The function :func:`math.factorial` no longer accepts arguments that are not
int-like. (Contributed by Pablo Galindo in :issue:`33083`.)


mmap
----

The :class:`mmap.mmap` class now has an :meth:`~mmap.mmap.madvise` method to
access the ``madvise()`` system call.
(Contributed by Zackery Spytz in :issue:`32941`.)


multiprocessing
---------------

Added new :mod:`multiprocessing.shared_memory` module.
(Contributed by Davin Potts in :issue:`35813`.)

On macOS, the *spawn* start method is now used by default.
(Contributed by Victor Stinner in :issue:`33725`.)


os
--

Added new function :func:`~os.add_dll_directory` on Windows for providing
additional search paths for native dependencies when importing extension
modules or loading DLLs using :mod:`ctypes`.
(Contributed by Steve Dower in :issue:`36085`.)

A new :func:`os.memfd_create` function was added to wrap the
``memfd_create()`` syscall.
(Contributed by Zackery Spytz and Christian Heimes in :issue:`26836`.)

On Windows, much of the manual logic for handling reparse points (including
symlinks and directory junctions) has been delegated to the operating system.
Specifically, :func:`os.stat` will now traverse anything supported by the
operating system, while :func:`os.lstat` will only open reparse points that
identify as "name surrogates" while others are opened as for :func:`os.stat`.
In all cases, :attr:`stat_result.st_mode` will only have ``S_IFLNK`` set for
symbolic links and not other kinds of reparse points. To identify other kinds
of reparse point, check the new :attr:`stat_result.st_reparse_tag` attribute.

On Windows, :func:`os.readlink` is now able to read directory junctions. Note
that :func:`~os.path.islink` will return ``False`` for directory junctions,
and so code that checks ``islink`` first will continue to treat junctions as
directories, while code that handles errors from :func:`os.readlink` may now
treat junctions as links.

(Contributed by Steve Dower in :issue:`37834`.)


os.path
-------

:mod:`os.path` functions that return a boolean result like
:func:`~os.path.exists`, :func:`~os.path.lexists`, :func:`~os.path.isdir`,
:func:`~os.path.isfile`, :func:`~os.path.islink`, and :func:`~os.path.ismount`
now return ``False`` instead of raising :exc:`ValueError` or its subclasses
:exc:`UnicodeEncodeError` and :exc:`UnicodeDecodeError` for paths that contain
characters or bytes unrepresentable at the OS level.
(Contributed by Serhiy Storchaka in :issue:`33721`.)

:func:`~os.path.expanduser` on Windows now prefers the :envvar:`USERPROFILE`
environment variable and does not use :envvar:`HOME`, which is not normally set
for regular user accounts.
(Contributed by Anthony Sottile in :issue:`36264`.)

:func:`~os.path.isdir` on Windows no longer returns ``True`` for a link to a
non-existent directory.

:func:`~os.path.realpath` on Windows now resolves reparse points, including
symlinks and directory junctions.

(Contributed by Steve Dower in :issue:`37834`.)


pathlib
-------

:mod:`pathlib.Path` methods that return a boolean result like
:meth:`~pathlib.Path.exists()`, :meth:`~pathlib.Path.is_dir()`,
:meth:`~pathlib.Path.is_file()`, :meth:`~pathlib.Path.is_mount()`,
:meth:`~pathlib.Path.is_symlink()`, :meth:`~pathlib.Path.is_block_device()`,
:meth:`~pathlib.Path.is_char_device()`, :meth:`~pathlib.Path.is_fifo()`,
:meth:`~pathlib.Path.is_socket()` now return ``False`` instead of raising
:exc:`ValueError` or its subclass :exc:`UnicodeEncodeError` for paths that
contain characters unrepresentable at the OS level.
(Contributed by Serhiy Storchaka in :issue:`33721`.)

Added :meth:`pathlib.Path.link_to()` which creates a hard link pointing
to a path.
(Contributed by Joannah Nanjekye in :issue:`26978`)


pickle
------

:mod:`pickle` extensions subclassing the C-optimized :class:`~pickle.Pickler`
can now override the pickling logic of functions and classes by defining the
special :meth:`~pickle.Pickler.reducer_override` method.
(Contributed by Pierre Glaser and Olivier Grisel in :issue:`35900`.)


plistlib
--------

Added new :class:`plistlib.UID` and enabled support for reading and writing
NSKeyedArchiver-encoded binary plists.
(Contributed by Jon Janzen in :issue:`26707`.)


pprint
------

The :mod:`pprint` module added a *sort_dicts* parameter to several functions.
By default, those functions continue to sort dictionaries before rendering or
printing.  However, if *sort_dicts* is set to false, the dictionaries retain
the order that keys were inserted.  This can be useful for comparison to JSON
inputs during debugging.

In addition, there is a convenience new function, :func:`pprint.pp` that is
like :func:`pprint.pprint` but with *sort_dicts* defaulting to ``False``::

    >>> from pprint import pprint, pp
    >>> d = dict(source='input.txt', operation='filter', destination='output.txt')
    >>> pp(d, width=40)                  # Original order
    {'source': 'input.txt',
     'operation': 'filter',
     'destination': 'output.txt'}
    >>> pprint(d, width=40)              # Keys sorted alphabetically
    {'destination': 'output.txt',
     'operation': 'filter',
     'source': 'input.txt'}

(Contributed by Rémi Lapeyre in :issue:`30670`.)


py_compile
----------

:func:`py_compile.compile` now supports silent mode.
(Contributed by Joannah Nanjekye in :issue:`22640`.)


shlex
-----

The new :func:`shlex.join` function acts as the inverse of :func:`shlex.split`.
(Contributed by Bo Bayles in :issue:`32102`.)


shutil
------

:func:`shutil.copytree` now accepts a new ``dirs_exist_ok`` keyword argument.
(Contributed by Josh Bronson in :issue:`20849`.)

:func:`shutil.make_archive` now defaults to the modern pax (POSIX.1-2001)
format for new archives to improve portability and standards conformance,
inherited from the corresponding change to the :mod:`tarfile` module.
(Contributed by C.A.M. Gerlach in :issue:`30661`.)

:func:`shutil.rmtree` on Windows now removes directory junctions without
recursively removing their contents first.
(Contributed by Steve Dower in :issue:`37834`.)


socket
------

Added :meth:`~socket.create_server()` and :meth:`~socket.has_dualstack_ipv6()`
convenience functions to automate the necessary tasks usually involved when
creating a server socket, including accepting both IPv4 and IPv6 connections
on the same socket.  (Contributed by Giampaolo Rodolà in :issue:`17561`.)

The :func:`socket.if_nameindex()`, :func:`socket.if_nametoindex()`, and
:func:`socket.if_indextoname()` functions have been implemented on Windows.
(Contributed by Zackery Spytz in :issue:`37007`.)


ssl
---

Added :attr:`~ssl.SSLContext.post_handshake_auth` to enable and
:meth:`~ssl.SSLSocket.verify_client_post_handshake` to initiate TLS 1.3
post-handshake authentication.
(Contributed by Christian Heimes in :issue:`34670`.)


statistics
----------

Added :func:`statistics.fmean` as a faster, floating point variant of
:func:`statistics.mean()`.  (Contributed by Raymond Hettinger and
Steven D'Aprano in :issue:`35904`.)

Added :func:`statistics.geometric_mean()`
(Contributed by Raymond Hettinger in :issue:`27181`.)

Added :func:`statistics.multimode` that returns a list of the most
common values. (Contributed by Raymond Hettinger in :issue:`35892`.)

Added :func:`statistics.quantiles` that divides data or a distribution
in to equiprobable intervals (e.g. quartiles, deciles, or percentiles).
(Contributed by Raymond Hettinger in :issue:`36546`.)

Added :class:`statistics.NormalDist`, a tool for creating
and manipulating normal distributions of a random variable.
(Contributed by Raymond Hettinger in :issue:`36018`.)

::

    >>> temperature_feb = NormalDist.from_samples([4, 12, -3, 2, 7, 14])
    >>> temperature_feb.mean
    6.0
    >>> temperature_feb.stdev
    6.356099432828281

    >>> temperature_feb.cdf(3)            # Chance of being under 3 degrees
    0.3184678262814532
    >>> # Relative chance of being 7 degrees versus 10 degrees
    >>> temperature_feb.pdf(7) / temperature_feb.pdf(10)
    1.2039930378537762

    >>> el_niño = NormalDist(4, 2.5)
    >>> temperature_feb += el_niño        # Add in a climate effect
    >>> temperature_feb
    NormalDist(mu=10.0, sigma=6.830080526611674)

    >>> temperature_feb * (9/5) + 32      # Convert to Fahrenheit
    NormalDist(mu=50.0, sigma=12.294144947901014)
    >>> temperature_feb.samples(3)        # Generate random samples
    [7.672102882379219, 12.000027119750287, 4.647488369766392]


sys
---

Add new :func:`sys.unraisablehook` function which can be overridden to control
how "unraisable exceptions" are handled. It is called when an exception has
occurred but there is no way for Python to handle it. For example, when a
destructor raises an exception or during garbage collection
(:func:`gc.collect`).
(Contributed by Victor Stinner in :issue:`36829`.)


tarfile
-------

The :mod:`tarfile` module now defaults to the modern pax (POSIX.1-2001)
format for new archives, instead of the previous GNU-specific one.
This improves cross-platform portability with a consistent encoding (UTF-8)
in a standardized and extensible format, and offers several other benefits.
(Contributed by C.A.M. Gerlach in :issue:`36268`.)


threading
---------

Add a new :func:`threading.excepthook` function which handles uncaught
:meth:`threading.Thread.run` exception. It can be overridden to control how
uncaught :meth:`threading.Thread.run` exceptions are handled.
(Contributed by Victor Stinner in :issue:`1230540`.)

Add a new :func:`threading.get_native_id` function and
a :data:`~threading.Thread.native_id`
attribute to the :class:`threading.Thread` class. These return the native
integral Thread ID of the current thread assigned by the kernel.
This feature is only available on certain platforms, see
:func:`get_native_id <threading.get_native_id>` for more information.
(Contributed by Jake Tesler in :issue:`36084`.)


tokenize
--------

The :mod:`tokenize` module now implicitly emits a ``NEWLINE`` token when
provided with input that does not have a trailing new line.  This behavior
now matches what the C tokenizer does internally.
(Contributed by Ammar Askar in :issue:`33899`.)


tkinter
-------

Added methods :meth:`~tkinter.Spinbox.selection_from`,
:meth:`~tkinter.Spinbox.selection_present`,
:meth:`~tkinter.Spinbox.selection_range` and
:meth:`~tkinter.Spinbox.selection_to`
in the :class:`tkinter.Spinbox` class.
(Contributed by Juliette Monsel in :issue:`34829`.)

Added method :meth:`~tkinter.Canvas.moveto`
in the :class:`tkinter.Canvas` class.
(Contributed by Juliette Monsel in :issue:`23831`.)

The :class:`tkinter.PhotoImage` class now has
:meth:`~tkinter.PhotoImage.transparency_get` and
:meth:`~tkinter.PhotoImage.transparency_set` methods.  (Contributed by
Zackery Spytz in :issue:`25451`.)


time
----

Added new clock :data:`~time.CLOCK_UPTIME_RAW` for macOS 10.12.
(Contributed by Joannah Nanjekye in :issue:`35702`.)


typing
------

The :mod:`typing` module incorporates several new features:

* A dictionary type with per-key types.  See :pep:`589` and
  :class:`typing.TypedDict`.
  TypedDict uses only string keys.  By default, every key is required
  to be present. Specify "total=False" to allow keys to be optional::

      class Location(TypedDict, total=False):
          lat_long: tuple
          grid_square: str
          xy_coordinate: tuple

* Literal types.  See :pep:`586` and :class:`typing.Literal`.
  Literal types indicate that a parameter or return value
  is constrained to one or more specific literal values::

      def get_status(port: int) -> Literal['connected', 'disconnected']:
          ...

* "Final" variables, functions, methods and classes.  See :pep:`591`,
  :class:`typing.Final` and :func:`typing.final`.
  The final qualifier instructs a static type checker to restrict
  subclassing, overriding, or reassignment::

      pi: Final[float] = 3.1415926536

* Protocol definitions.  See :pep:`544`, :class:`typing.Protocol` and
  :func:`typing.runtime_checkable`.  Simple ABCs like
  :class:`typing.SupportsInt` are now ``Protocol`` subclasses.

* New protocol class :class:`typing.SupportsIndex`.

* New functions :func:`typing.get_origin` and :func:`typing.get_args`.


unicodedata
-----------

The :mod:`unicodedata` module has been upgraded to use the `Unicode 12.1.0
<http://blog.unicode.org/2019/05/unicode-12-1-en.html>`_ release.

New function :func:`~unicodedata.is_normalized` can be used to verify a string
is in a specific normal form, often much faster than by actually normalizing
the string.  (Contributed by Max Belanger, David Euresti, and Greg Price in
:issue:`32285` and :issue:`37966`).


unittest
--------

Added :class:`~unittest.mock.AsyncMock` to support an asynchronous version of
:class:`~unittest.mock.Mock`.  Appropriate new assert functions for testing
have been added as well.
(Contributed by Lisa Roach in :issue:`26467`).

Added :func:`~unittest.addModuleCleanup()` and
:meth:`~unittest.TestCase.addClassCleanup()` to unittest to support
cleanups for :func:`~unittest.setUpModule()` and
:meth:`~unittest.TestCase.setUpClass()`.
(Contributed by Lisa Roach in :issue:`24412`.)

Several mock assert functions now also print a list of actual calls upon
failure. (Contributed by Petter Strandmark in :issue:`35047`.)

:mod:`unittest` module gained support for coroutines to be used as test cases
with :class:`unittest.IsolatedAsyncioTestCase`.
(Contributed by Andrew Svetlov in :issue:`32972`.)

Example::

   import unittest


   class TestRequest(unittest.IsolatedAsyncioTestCase):

       async def asyncSetUp(self):
           self.connection = await AsyncConnection()

       async def test_get(self):
           response = await self.connection.get("https://example.com")
           self.assertEqual(response.status_code, 200)

       async def asyncTearDown(self):
           await self.connection.close()


   if __name__ == "__main__":
       unittest.main()


venv
----

:mod:`venv` now includes an ``Activate.ps1`` script on all platforms for
activating virtual environments under PowerShell Core 6.1.
(Contributed by Brett Cannon in :issue:`32718`.)


weakref
-------

The proxy objects returned by :func:`weakref.proxy` now support the matrix
multiplication operators ``@`` and ``@=`` in addition to the other
numeric operators. (Contributed by Mark Dickinson in :issue:`36669`.)


xml
---

As mitigation against DTD and external entity retrieval, the
:mod:`xml.dom.minidom` and :mod:`xml.sax` modules no longer process
external entities by default.
(Contributed by Christian Heimes in :issue:`17239`.)

The ``.find*()`` methods in the :mod:`xml.etree.ElementTree` module
support wildcard searches like ``{*}tag`` which ignores the namespace
and ``{namespace}*`` which returns all tags in the given namespace.
(Contributed by Stefan Behnel in :issue:`28238`.)

The :mod:`xml.etree.ElementTree` module provides a new function
:func:`–xml.etree.ElementTree.canonicalize()` that implements C14N 2.0.
(Contributed by Stefan Behnel in :issue:`13611`.)

The target object of :class:`xml.etree.ElementTree.XMLParser` can
receive namespace declaration events through the new callback methods
``start_ns()`` and ``end_ns()``.  Additionally, the
:class:`xml.etree.ElementTree.TreeBuilder` target can be configured
to process events about comments and processing instructions to include
them in the generated tree.
(Contributed by Stefan Behnel in :issue:`36676` and :issue:`36673`.)


xmlrpc
------

:class:`xmlrpc.client.ServerProxy` now supports an optional *headers* keyword
argument for a sequence of HTTP headers to be sent with each request.  Among
other things, this makes it possible to upgrade from default basic
authentication to faster session authentication.
(Contributed by Cédric Krier in :issue:`35153`.)


Optimizations
=============

* The :mod:`subprocess` module can now use the :func:`os.posix_spawn` function
  in some cases for better performance. Currently, it is only used on macOS
  and Linux (using glibc 2.24 or newer) if all these conditions are met:

  * *close_fds* is false;
  * *preexec_fn*, *pass_fds*, *cwd* and *start_new_session* parameters
    are not set;
  * the *executable* path contains a directory.

  (Contributed by Joannah Nanjekye and Victor Stinner in :issue:`35537`.)

* :func:`shutil.copyfile`, :func:`shutil.copy`, :func:`shutil.copy2`,
  :func:`shutil.copytree` and :func:`shutil.move` use platform-specific
  "fast-copy" syscalls on Linux and macOS in order to copy the file
  more efficiently.
  "fast-copy" means that the copying operation occurs within the kernel,
  avoiding the use of userspace buffers in Python as in
  "``outfd.write(infd.read())``".
  On Windows :func:`shutil.copyfile` uses a bigger default buffer size (1 MiB
  instead of 16 KiB) and a :func:`memoryview`-based variant of
  :func:`shutil.copyfileobj` is used.
  The speedup for copying a 512 MiB file within the same partition is about
  +26% on Linux, +50% on macOS and +40% on Windows. Also, much less CPU cycles
  are consumed.
  See :ref:`shutil-platform-dependent-efficient-copy-operations` section.
  (Contributed by Giampaolo Rodolà in :issue:`33671`.)

* :func:`shutil.copytree` uses :func:`os.scandir` function and all copy
  functions depending from it use cached :func:`os.stat` values. The speedup
  for copying a directory with 8000 files is around +9% on Linux, +20% on
  Windows and +30% on a Windows SMB share. Also the number of :func:`os.stat`
  syscalls is reduced by 38% making :func:`shutil.copytree` especially faster
  on network filesystems. (Contributed by Giampaolo Rodolà in :issue:`33695`.)

* The default protocol in the :mod:`pickle` module is now Protocol 4,
  first introduced in Python 3.4.  It offers better performance and smaller
  size compared to Protocol 3 available since Python 3.0.

* Removed one ``Py_ssize_t`` member from ``PyGC_Head``.  All GC tracked
  objects (e.g. tuple, list, dict) size is reduced 4 or 8 bytes.
  (Contributed by Inada Naoki in :issue:`33597`.)

* :class:`uuid.UUID` now uses ``__slots__`` to reduce its memory footprint.
  (Contributed by Wouter Bolsterlee and Tal Einat in :issue:`30977`)

* Improved performance of :func:`operator.itemgetter` by 33%.  Optimized
  argument handling and added a fast path for the common case of a single
  non-negative integer index into a tuple (which is the typical use case in
  the standard library).  (Contributed by Raymond Hettinger in
  :issue:`35664`.)

* Sped-up field lookups in :func:`collections.namedtuple`.  They are now more
  than two times faster, making them the fastest form of instance variable
  lookup in Python. (Contributed by Raymond Hettinger, Pablo Galindo, and
  Joe Jevnik, Serhiy Storchaka in :issue:`32492`.)

* The :class:`list` constructor does not overallocate the internal item buffer
  if the input iterable has a known length (the input implements ``__len__``).
  This makes the created list 12% smaller on average. (Contributed by
  Raymond Hettinger and Pablo Galindo in :issue:`33234`.)

* Doubled the speed of class variable writes.  When a non-dunder attribute
  was updated, there was an unnecessary call to update slots.
  (Contributed by Stefan Behnel, Pablo Galindo Salgado, Raymond Hettinger,
  Neil Schemenauer, and Serhiy Storchaka in :issue:`36012`.)

* Reduced an overhead of converting arguments passed to many builtin functions
  and methods.  This sped up calling some simple builtin functions and
  methods up to 20--50%.  (Contributed by Serhiy Storchaka in :issue:`23867`,
  :issue:`35582` and :issue:`36127`.)

* ``LOAD_GLOBAL`` instruction now uses new "per opcode cache" mechanism.
  It is about 40% faster now.  (Contributed by Yury Selivanov and Inada Naoki in
  :issue:`26219`.)


Build and C API Changes
=======================

* Default :data:`sys.abiflags` became an empty string: the ``m`` flag for
  pymalloc became useless (builds with and without pymalloc are ABI compatible)
  and so has been removed. (Contributed by Victor Stinner in :issue:`36707`.)

  Example of changes:

  * Only ``python3.8`` program is installed, ``python3.8m`` program is gone.
  * Only ``python3.8-config`` script is installed, ``python3.8m-config`` script
    is gone.
  * The ``m`` flag has been removed from the suffix of dynamic library
    filenames: extension modules in the standard library as well as those
    produced and installed by third-party packages, like those downloaded from
    PyPI. On Linux, for example, the Python 3.7 suffix
    ``.cpython-37m-x86_64-linux-gnu.so`` became
    ``.cpython-38-x86_64-linux-gnu.so`` in Python 3.8.

* The header files have been reorganized to better separate the different kinds
  of APIs:

  * ``Include/*.h`` should be the portable public stable C API.
  * ``Include/cpython/*.h`` should be the unstable C API specific to CPython;
    public API, with some private API prefixed by ``_Py`` or ``_PY``.
  * ``Include/internal/*.h`` is the private internal C API very specific to
    CPython. This API comes with no backward compatibility warranty and should
    not be used outside CPython. It is only exposed for very specific needs
    like debuggers and profiles which has to access to CPython internals
    without calling functions. This API is now installed by ``make install``.

  (Contributed by Victor Stinner in :issue:`35134` and :issue:`35081`,
  work initiated by Eric Snow in Python 3.7.)

* Some macros have been converted to static inline functions: parameter types
  and return type are well defined, they don't have issues specific to macros,
  variables have a local scopes. Examples:

  * :c:func:`Py_INCREF`, :c:func:`Py_DECREF`
  * :c:func:`Py_XINCREF`, :c:func:`Py_XDECREF`
  * :c:func:`PyObject_INIT`, :c:func:`PyObject_INIT_VAR`
  * Private functions: :c:func:`_PyObject_GC_TRACK`,
    :c:func:`_PyObject_GC_UNTRACK`, :c:func:`_Py_Dealloc`

  (Contributed by Victor Stinner in :issue:`35059`.)

* The :c:func:`PyByteArray_Init` and :c:func:`PyByteArray_Fini` functions have
  been removed. They did nothing since Python 2.7.4 and Python 3.2.0, were
  excluded from the limited API (stable ABI), and were not documented.
  (Contributed by Victor Stinner in :issue:`35713`.)

* The result of :c:func:`PyExceptionClass_Name` is now of type
  ``const char *`` rather of ``char *``.
  (Contributed by Serhiy Storchaka in :issue:`33818`.)

* The duality of ``Modules/Setup.dist`` and ``Modules/Setup`` has been
  removed.  Previously, when updating the CPython source tree, one had
  to manually copy ``Modules/Setup.dist`` (inside the source tree) to
  ``Modules/Setup`` (inside the build tree) in order to reflect any changes
  upstream.  This was of a small benefit to packagers at the expense of
  a frequent annoyance to developers following CPython development, as
  forgetting to copy the file could produce build failures.

  Now the build system always reads from ``Modules/Setup`` inside the source
  tree.  People who want to customize that file are encouraged to maintain
  their changes in a git fork of CPython or as patch files, as they would do
  for any other change to the source tree.

  (Contributed by Antoine Pitrou in :issue:`32430`.)

* Functions that convert Python number to C integer like
  :c:func:`PyLong_AsLong` and argument parsing functions like
  :c:func:`PyArg_ParseTuple` with integer converting format units like ``'i'``
  will now use the :meth:`~object.__index__` special method instead of
  :meth:`~object.__int__`, if available.  The deprecation warning will be
  emitted for objects with the ``__int__()`` method but without the
  ``__index__()`` method (like :class:`~decimal.Decimal` and
  :class:`~fractions.Fraction`).  :c:func:`PyNumber_Check` will now return
  ``1`` for objects implementing ``__index__()``.
  :c:func:`PyNumber_Long`, :c:func:`PyNumber_Float` and
  :c:func:`PyFloat_AsDouble` also now use the ``__index__()`` method if
  available.
  (Contributed by Serhiy Storchaka in :issue:`36048` and :issue:`20092`.)

* Heap-allocated type objects will now increase their reference count
  in :c:func:`PyObject_Init` (and its parallel macro ``PyObject_INIT``)
  instead of in :c:func:`PyType_GenericAlloc`. Types that modify instance
  allocation or deallocation may need to be adjusted.
  (Contributed by Eddie Elizondo in :issue:`35810`.)

* The new function :c:func:`PyCode_NewWithPosOnlyArgs` allows to create
  code objects like :c:func:`PyCode_New`, but with an extra *posonlyargcount*
  parameter for indicating the number of positional-only arguments.
  (Contributed by Pablo Galindo in :issue:`37221`.)

* :c:func:`Py_SetPath` now sets :data:`sys.executable` to the program full
  path (:c:func:`Py_GetProgramFullPath`) rather than to the program name
  (:c:func:`Py_GetProgramName`).
  (Contributed by Victor Stinner in :issue:`38234`.)


Deprecated
==========

* The distutils ``bdist_wininst`` command is now deprecated, use
  ``bdist_wheel`` (wheel packages) instead.
  (Contributed by Victor Stinner in :issue:`37481`.)

* Deprecated methods ``getchildren()`` and ``getiterator()`` in
  the :mod:`~xml.etree.ElementTree` module now emit a
  :exc:`DeprecationWarning` instead of :exc:`PendingDeprecationWarning`.
  They will be removed in Python 3.9.
  (Contributed by Serhiy Storchaka in :issue:`29209`.)

* Passing an object that is not an instance of
  :class:`concurrent.futures.ThreadPoolExecutor` to
  :meth:`loop.set_default_executor() <asyncio.loop.set_default_executor>` is
  deprecated and will be prohibited in Python 3.9.
  (Contributed by Elvis Pranskevichus in :issue:`34075`.)

* The :meth:`__getitem__` methods of :class:`xml.dom.pulldom.DOMEventStream`,
  :class:`wsgiref.util.FileWrapper` and :class:`fileinput.FileInput` have been
  deprecated.

  Implementations of these methods have been ignoring their *index* parameter,
  and returning the next item instead.
  (Contributed by Berker Peksag in :issue:`9372`.)

* The :class:`typing.NamedTuple` class has deprecated the ``_field_types``
  attribute in favor of the ``__annotations__`` attribute which has the same
  information. (Contributed by Raymond Hettinger in :issue:`36320`.)

* :mod:`ast` classes ``Num``, ``Str``, ``Bytes``, ``NameConstant`` and
  ``Ellipsis`` are considered deprecated and will be removed in future Python
  versions. :class:`~ast.Constant` should be used instead.
  (Contributed by Serhiy Storchaka in :issue:`32892`.)

* :class:`ast.NodeVisitor` methods ``visit_Num()``, ``visit_Str()``,
  ``visit_Bytes()``, ``visit_NameConstant()`` and ``visit_Ellipsis()`` are
  deprecated now and will not be called in future Python versions.
  Add the :meth:`~ast.NodeVisitor.visit_Constant` method to handle all
  constant nodes.
  (Contributed by Serhiy Storchaka in :issue:`36917`.)

* The :func:`asyncio.coroutine` :term:`decorator` is deprecated and will be
  removed in version 3.10.  Instead of ``@asyncio.coroutine``, use
  :keyword:`async def` instead.
  (Contributed by Andrew Svetlov in :issue:`36921`.)

* In :mod:`asyncio`, the explicit passing of a *loop* argument has been
  deprecated and will be removed in version 3.10 for the following:
  :func:`asyncio.sleep`, :func:`asyncio.gather`, :func:`asyncio.shield`,
  :func:`asyncio.wait_for`, :func:`asyncio.wait`, :func:`asyncio.as_completed`,
  :class:`asyncio.Task`, :class:`asyncio.Lock`, :class:`asyncio.Event`,
  :class:`asyncio.Condition`, :class:`asyncio.Semaphore`,
  :class:`asyncio.BoundedSemaphore`, :class:`asyncio.Queue`,
  :func:`asyncio.create_subprocess_exec`, and
  :func:`asyncio.create_subprocess_shell`.

* The explicit passing of coroutine objects to :func:`asyncio.wait` has been
  deprecated and will be removed in version 3.11.
  (Contributed by Yury Selivanov in :issue:`34790`.)

* The following functions and methods are deprecated in the :mod:`gettext`
  module: :func:`~gettext.lgettext`, :func:`~gettext.ldgettext`,
  :func:`~gettext.lngettext` and :func:`~gettext.ldngettext`.
  They return encoded bytes, and it's possible that you will get unexpected
  Unicode-related exceptions if there are encoding problems with the
  translated strings. It's much better to use alternatives which return
  Unicode strings in Python 3. These functions have been broken for a long time.

  Function :func:`~gettext.bind_textdomain_codeset`, methods
  :meth:`~gettext.NullTranslations.output_charset` and
  :meth:`~gettext.NullTranslations.set_output_charset`, and the *codeset*
  parameter of functions :func:`~gettext.translation` and
  :func:`~gettext.install` are also deprecated, since they are only used for
  for the ``l*gettext()`` functions.
  (Contributed by Serhiy Storchaka in :issue:`33710`.)

* The :meth:`~threading.Thread.isAlive()` method of :class:`threading.Thread`
  has been deprecated.
  (Contributed by Dong-hee Na in :issue:`35283`.)

* Many builtin and extension functions that take integer arguments will
  now emit a deprecation warning for :class:`~decimal.Decimal`\ s,
  :class:`~fractions.Fraction`\ s and any other objects that can be converted
  to integers only with a loss (e.g. that have the :meth:`~object.__int__`
  method but do not have the :meth:`~object.__index__` method).  In future
  version they will be errors.
  (Contributed by Serhiy Storchaka in :issue:`36048`.)

* Deprecated passing the following arguments as keyword arguments:

  - *func* in :func:`functools.partialmethod`, :func:`weakref.finalize`,
    :meth:`profile.Profile.runcall`, :meth:`cProfile.Profile.runcall`,
    :meth:`bdb.Bdb.runcall`, :meth:`trace.Trace.runfunc` and
    :func:`curses.wrapper`.
  - *function* in :meth:`unittest.TestCase.addCleanup`.
  - *fn* in the :meth:`~concurrent.futures.Executor.submit` method of
    :class:`concurrent.futures.ThreadPoolExecutor` and
    :class:`concurrent.futures.ProcessPoolExecutor`.
  - *callback* in :meth:`contextlib.ExitStack.callback`,
    :meth:`contextlib.AsyncExitStack.callback` and
    :meth:`contextlib.AsyncExitStack.push_async_callback`.
  - *c* and *typeid* in the :meth:`~multiprocessing.managers.Server.create`
    method of :class:`multiprocessing.managers.Server` and
    :class:`multiprocessing.managers.SharedMemoryServer`.
  - *obj* in :func:`weakref.finalize`.

  In future releases of Python, they will be :ref:`positional-only
  <positional-only_parameter>`.
  (Contributed by Serhiy Storchaka in :issue:`36492`.)


API and Feature Removals
========================

The following features and APIs have been removed from Python 3.8:

*  Starting with Python 3.3, importing ABCs from :mod:`collections` was
   deprecated, and importing should be done from :mod:`collections.abc`. Being
   able to import from collections was marked for removal in 3.8, but has been
   delayed to 3.9. (See :issue:`36952`.)

* The :mod:`macpath` module, deprecated in Python 3.7, has been removed.
  (Contributed by Victor Stinner in :issue:`35471`.)

* The function :func:`platform.popen` has been removed, after having been
  deprecated since Python 3.3: use :func:`os.popen` instead.
  (Contributed by Victor Stinner in :issue:`35345`.)

* The function :func:`time.clock` has been removed, after having been
  deprecated since Python 3.3: use :func:`time.perf_counter` or
  :func:`time.process_time` instead, depending
  on your requirements, to have well-defined behavior.
  (Contributed by Matthias Bussonnier in :issue:`36895`.)

* The ``pyvenv`` script has been removed in favor of ``python3.8 -m venv``
  to help eliminate confusion as to what Python interpreter the ``pyvenv``
  script is tied to. (Contributed by Brett Cannon in :issue:`25427`.)

* ``parse_qs``, ``parse_qsl``, and ``escape`` are removed from the :mod:`cgi`
  module.  They are deprecated in Python 3.2 or older. They should be imported
  from the ``urllib.parse`` and ``html`` modules instead.

* ``filemode`` function is removed from the :mod:`tarfile` module.
  It is not documented and deprecated since Python 3.3.

* The :class:`~xml.etree.ElementTree.XMLParser` constructor no longer accepts
  the *html* argument.  It never had an effect and was deprecated in Python 3.4.
  All other parameters are now :ref:`keyword-only <keyword-only_parameter>`.
  (Contributed by Serhiy Storchaka in :issue:`29209`.)

* Removed the ``doctype()`` method of :class:`~xml.etree.ElementTree.XMLParser`.
  (Contributed by Serhiy Storchaka in :issue:`29209`.)

* "unicode_internal" codec is removed.
  (Contributed by Inada Naoki in :issue:`36297`.)

* The ``Cache`` and ``Statement`` objects of the :mod:`sqlite3` module are not
  exposed to the user.
  (Contributed by Aviv Palivoda in :issue:`30262`.)

* The ``bufsize`` keyword argument of :func:`fileinput.input` and
  :func:`fileinput.FileInput` which was ignored and deprecated since Python 3.6
  has been removed. :issue:`36952` (Contributed by Matthias Bussonnier.)

* The functions :func:`sys.set_coroutine_wrapper` and
  :func:`sys.get_coroutine_wrapper` deprecated in Python 3.7 have been removed;
  :issue:`36933` (Contributed by Matthias Bussonnier.)


Porting to Python 3.8
=====================

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


Changes in Python behavior
--------------------------

* Yield expressions (both ``yield`` and ``yield from`` clauses) are now disallowed
  in comprehensions and generator expressions (aside from the iterable expression
  in the leftmost :keyword:`!for` clause).
  (Contributed by Serhiy Storchaka in :issue:`10544`.)

* The compiler now produces a :exc:`SyntaxWarning` when identity checks
  (``is`` and ``is not``) are used with certain types of literals
  (e.g. strings, numbers).  These can often work by accident in CPython,
  but are not guaranteed by the language spec.  The warning advises users
  to use equality tests (``==`` and ``!=``) instead.
  (Contributed by Serhiy Storchaka in :issue:`34850`.)

* The CPython interpreter can swallow exceptions in some circumstances.
  In Python 3.8 this happens in fewer cases.  In particular, exceptions
  raised when getting the attribute from the type dictionary are no longer
  ignored. (Contributed by Serhiy Storchaka in :issue:`35459`.)

* Removed ``__str__`` implementations from builtin types :class:`bool`,
  :class:`int`, :class:`float`, :class:`complex` and few classes from
  the standard library.  They now inherit ``__str__()`` from :class:`object`.
  As result, defining the ``__repr__()`` method in the subclass of these
  classes will affect their string representation.
  (Contributed by Serhiy Storchaka in :issue:`36793`.)

* On AIX, :attr:`sys.platform` doesn't contain the major version anymore.
  It is always ``'aix'``, instead of ``'aix3'`` .. ``'aix7'``.  Since
  older Python versions include the version number, so it is recommended to
  always use ``sys.platform.startswith('aix')``.
  (Contributed by M. Felt in :issue:`36588`.)

* :c:func:`PyEval_AcquireLock` and :c:func:`PyEval_AcquireThread` now
  terminate the current thread if called while the interpreter is
  finalizing, making them consistent with :c:func:`PyEval_RestoreThread`,
  :c:func:`Py_END_ALLOW_THREADS`, and :c:func:`PyGILState_Ensure`. If this
  behavior is not desired, guard the call by checking :c:func:`_Py_IsFinalizing`
  or :c:func:`sys.is_finalizing`.
  (Contributed by Joannah Nanjekye in :issue:`36475`.)


Changes in the Python API
-------------------------

* The :func:`os.getcwdb` function now uses the UTF-8 encoding on Windows,
  rather than the ANSI code page: see :pep:`529` for the rationale. The
  function is no longer deprecated on Windows.
  (Contributed by Victor Stinner in :issue:`37412`.)

* :class:`subprocess.Popen` can now use :func:`os.posix_spawn` in some cases
  for better performance. On Windows Subsystem for Linux and QEMU User
  Emulation, the :class:`Popen` constructor using :func:`os.posix_spawn` no longer raises an
  exception on errors like "missing program".  Instead the child process fails with a
  non-zero :attr:`~Popen.returncode`.
  (Contributed by Joannah Nanjekye and Victor Stinner in :issue:`35537`.)

* The *preexec_fn* argument of * :class:`subprocess.Popen` is no longer
  compatible with subinterpreters. The use of the parameter in a
  subinterpreter now raises :exc:`RuntimeError`.
  (Contributed by Eric Snow in :issue:`34651`, modified by Christian Heimes
  in :issue:`37951`.)

* The :meth:`imap.IMAP4.logout` method no longer silently ignores arbitrary
  exceptions.
  (Contributed by Victor Stinner in :issue:`36348`.)

* The function :func:`platform.popen` has been removed, after having been deprecated since
  Python 3.3: use :func:`os.popen` instead.
  (Contributed by Victor Stinner in :issue:`35345`.)

* The :func:`statistics.mode` function no longer raises an exception
  when given multimodal data.  Instead, it returns the first mode
  encountered in the input data.  (Contributed by Raymond Hettinger
  in :issue:`35892`.)

* The :meth:`~tkinter.ttk.Treeview.selection` method of the
  :class:`tkinter.ttk.Treeview` class no longer takes arguments.  Using it with
  arguments for changing the selection was deprecated in Python 3.6.  Use
  specialized methods like :meth:`~tkinter.ttk.Treeview.selection_set` for
  changing the selection.  (Contributed by Serhiy Storchaka in :issue:`31508`.)

* The :meth:`writexml`, :meth:`toxml` and :meth:`toprettyxml` methods of
  :mod:`xml.dom.minidom`, and the :meth:`write` method of :mod:`xml.etree`,
  now preserve the attribute order specified by the user.
  (Contributed by Diego Rojas and Raymond Hettinger in :issue:`34160`.)

* A :mod:`dbm.dumb` database opened with flags ``'r'`` is now read-only.
  :func:`dbm.dumb.open` with flags ``'r'`` and ``'w'`` no longer creates
  a database if it does not exist.
  (Contributed by Serhiy Storchaka in :issue:`32749`.)

* The ``doctype()`` method defined in a subclass of
  :class:`~xml.etree.ElementTree.XMLParser` will no longer be called and will
  emit a :exc:`RuntimeWarning` instead of a :exc:`DeprecationWarning`.
  Define the :meth:`doctype() <xml.etree.ElementTree.TreeBuilder.doctype>`
  method on a target for handling an XML doctype declaration.
  (Contributed by Serhiy Storchaka in :issue:`29209`.)

* A :exc:`RuntimeError` is now raised when the custom metaclass doesn't
  provide the ``__classcell__`` entry in the namespace passed to
  ``type.__new__``.  A :exc:`DeprecationWarning` was emitted in Python
  3.6--3.7.  (Contributed by Serhiy Storchaka in :issue:`23722`.)

* The :class:`cProfile.Profile` class can now be used as a context
  manager. (Contributed by Scott Sanderson in :issue:`29235`.)

* :func:`shutil.copyfile`, :func:`shutil.copy`, :func:`shutil.copy2`,
  :func:`shutil.copytree` and :func:`shutil.move` use platform-specific
  "fast-copy" syscalls (see
  :ref:`shutil-platform-dependent-efficient-copy-operations` section).

* :func:`shutil.copyfile` default buffer size on Windows was changed from
  16 KiB to 1 MiB.

* The ``PyGC_Head`` struct has changed completely.  All code that touched the
  struct member should be rewritten.  (See :issue:`33597`.)

* The :c:type:`PyInterpreterState` struct has been moved into the "internal"
  header files (specifically Include/internal/pycore_pystate.h).  An
  opaque ``PyInterpreterState`` is still available as part of the public
  API (and stable ABI).  The docs indicate that none of the struct's
  fields are public, so we hope no one has been using them.  However,
  if you do rely on one or more of those private fields and have no
  alternative then please open a BPO issue.  We'll work on helping
  you adjust (possibly including adding accessor functions to the
  public API).  (See :issue:`35886`.)

* The :meth:`mmap.flush() <mmap.mmap.flush>` method now returns ``None`` on
  success and raises an exception on error under all platforms.  Previously,
  its behavior was platform-dependent: a nonzero value was returned on success;
  zero was returned on error under Windows.  A zero value was returned on
  success; an exception was raised on error under Unix.
  (Contributed by Berker Peksag in :issue:`2122`.)

* :mod:`xml.dom.minidom` and :mod:`xml.sax` modules no longer process
  external entities by default.
  (Contributed by Christian Heimes in :issue:`17239`.)

* Deleting a key from a read-only :mod:`dbm` database (:mod:`dbm.dumb`,
  :mod:`dbm.gnu` or :mod:`dbm.ndbm`) raises :attr:`error` (:exc:`dbm.dumb.error`,
  :exc:`dbm.gnu.error` or :exc:`dbm.ndbm.error`) instead of :exc:`KeyError`.
  (Contributed by Xiang Zhang in :issue:`33106`.)

* :func:`~os.path.expanduser` on Windows now prefers the :envvar:`USERPROFILE`
  environment variable and does not use :envvar:`HOME`, which is not normally
  set for regular user accounts.
  (Contributed by Anthony Sottile in :issue:`36264`.)

* The exception :class:`asyncio.CancelledError` now inherits from
  :class:`BaseException` rather than :class:`Exception`.
  (Contributed by Yury Selivanov in :issue:`32528`.)

* The function :func:`asyncio.wait_for` now correctly waits for cancellation
  when using an instance of :class:`asyncio.Task`. Previously, upon reaching
  *timeout*, it was cancelled and immediately returned.
  (Contributed by Elvis Pranskevichus in :issue:`32751`.)

* The function :func:`asyncio.BaseTransport.get_extra_info` now returns a safe
  to use socket object when 'socket' is passed to the *name* parameter.
  (Contributed by Yury Selivanov in :issue:`37027`.)

* :class:`asyncio.BufferedProtocol` has graduated to the stable API.

.. _bpo-36085-whatsnew:

* DLL dependencies for extension modules and DLLs loaded with :mod:`ctypes` on
  Windows are now resolved more securely. Only the system paths, the directory
  containing the DLL or PYD file, and directories added with
  :func:`~os.add_dll_directory` are searched for load-time dependencies.
  Specifically, :envvar:`PATH` and the current working directory are no longer
  used, and modifications to these will no longer have any effect on normal DLL
  resolution. If your application relies on these mechanisms, you should check
  for :func:`~os.add_dll_directory` and if it exists, use it to add your DLLs
  directory while loading your library. Note that Windows 7 users will need to
  ensure that Windows Update KB2533623 has been installed (this is also verified
  by the installer).
  (Contributed by Steve Dower in :issue:`36085`.)

* The header files and functions related to pgen have been removed after its
  replacement by a pure Python implementation. (Contributed by Pablo Galindo
  in :issue:`36623`.)

* :class:`types.CodeType` has a new parameter in the second position of the
  constructor (*posonlyargcount*) to support positional-only arguments defined
  in :pep:`570`. The first argument (*argcount*) now represents the total
  number of positional arguments (including positional-only arguments). The new
  ``replace()`` method of :class:`types.CodeType` can be used to make the code
  future-proof.


Changes in the C API
--------------------

* The :c:type:`PyCompilerFlags` structure got a new *cf_feature_version*
  field. It should be initialized to ``PY_MINOR_VERSION``. The field is ignored
  by default, and is used if and only if ``PyCF_ONLY_AST`` flag is set in
  *cf_flags*.
  (Contributed by Guido van Rossum in :issue:`35766`.)

* The :c:func:`PyEval_ReInitThreads` function has been removed from the C API.
  It should not be called explicitly: use :c:func:`PyOS_AfterFork_Child`
  instead.
  (Contributed by Victor Stinner in :issue:`36728`.)

* On Unix, C extensions are no longer linked to libpython except on Android
  and Cygwin. When Python is embedded, ``libpython`` must not be loaded with
  ``RTLD_LOCAL``, but ``RTLD_GLOBAL`` instead. Previously, using
  ``RTLD_LOCAL``, it was already not possible to load C extensions which
  were not linked to ``libpython``, like C extensions of the standard
  library built by the ``*shared*`` section of ``Modules/Setup``.
  (Contributed by Victor Stinner in :issue:`21536`.)

* Use of ``#`` variants of formats in parsing or building value (e.g.
  :c:func:`PyArg_ParseTuple`, :c:func:`Py_BuildValue`, :c:func:`PyObject_CallFunction`,
  etc.) without ``PY_SSIZE_T_CLEAN`` defined raises ``DeprecationWarning`` now.
  It will be removed in 3.10 or 4.0.  Read :ref:`arg-parsing` for detail.
  (Contributed by Inada Naoki in :issue:`36381`.)

* Instances of heap-allocated types (such as those created with
  :c:func:`PyType_FromSpec`) hold a reference to their type object.
  Increasing the reference count of these type objects has been moved from
  :c:func:`PyType_GenericAlloc` to the more low-level functions,
  :c:func:`PyObject_Init` and :c:func:`PyObject_INIT`.
  This makes types created through :c:func:`PyType_FromSpec` behave like
  other classes in managed code.

  Statically allocated types are not affected.

  For the vast majority of cases, there should be no side effect.
  However, types that manually increase the reference count after allocating
  an instance (perhaps to work around the bug) may now become immortal.
  To avoid this, these classes need to call Py_DECREF on the type object
  during instance deallocation.

  To correctly port these types into 3.8, please apply the following
  changes:

  * Remove :c:macro:`Py_INCREF` on the type object after allocating an
    instance - if any.
    This may happen after calling :c:func:`PyObject_New`,
    :c:func:`PyObject_NewVar`, :c:func:`PyObject_GC_New`,
    :c:func:`PyObject_GC_NewVar`, or any other custom allocator that uses
    :c:func:`PyObject_Init` or :c:func:`PyObject_INIT`.

    Example:

    .. code-block:: c

        static foo_struct *
        foo_new(PyObject *type) {
            foo_struct *foo = PyObject_GC_New(foo_struct, (PyTypeObject *) type);
            if (foo == NULL)
                return NULL;
        #if PY_VERSION_HEX < 0x03080000
            // Workaround for Python issue 35810; no longer necessary in Python 3.8
            PY_INCREF(type)
        #endif
            return foo;
        }

  * Ensure that all custom ``tp_dealloc`` functions of heap-allocated types
    decrease the type's reference count.

    Example:

    .. code-block:: c

        static void
        foo_dealloc(foo_struct *instance) {
            PyObject *type = Py_TYPE(instance);
            PyObject_GC_Del(instance);
        #if PY_VERSION_HEX >= 0x03080000
            // This was not needed before Python 3.8 (Python issue 35810)
            Py_DECREF(type);
        #endif
        }

  (Contributed by Eddie Elizondo in :issue:`35810`.)

* The :c:macro:`Py_DEPRECATED()` macro has been implemented for MSVC.
  The macro now must be placed before the symbol name.

  Example:

  .. code-block:: c

      Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);

  (Contributed by Zackery Spytz in :issue:`33407`.)

* The interpreter does not pretend to support binary compatibility of
  extension types across feature releases, anymore.  A :c:type:`PyTypeObject`
  exported by a third-party extension module is supposed to have all the
  slots expected in the current Python version, including
  :c:member:`~PyTypeObject.tp_finalize` (:const:`Py_TPFLAGS_HAVE_FINALIZE`
  is not checked anymore before reading :c:member:`~PyTypeObject.tp_finalize`).

  (Contributed by Antoine Pitrou in :issue:`32388`.)

* The :c:func:`PyCode_New` has a new parameter in the second position (*posonlyargcount*)
  to support :pep:`570`, indicating the number of positional-only arguments.

* The functions :c:func:`PyNode_AddChild` and :c:func:`PyParser_AddToken` now accept
  two additional ``int`` arguments *end_lineno* and *end_col_offset*.

* The :file:`libpython38.a` file to allow MinGW tools to link directly against
  :file:`python38.dll` is no longer included in the regular Windows distribution.
  If you require this file, it may be generated with the ``gendef`` and
  ``dlltool`` tools, which are part of the MinGW binutils package:

  .. code-block:: shell

      gendef python38.dll > tmp.def
      dlltool --dllname python38.dll --def tmp.def --output-lib libpython38.a

  The location of an installed :file:`pythonXY.dll` will depend on the
  installation options and the version and language of Windows. See
  :ref:`using-on-windows` for more information. The resulting library should be
  placed in the same directory as :file:`pythonXY.lib`, which is generally the
  :file:`libs` directory under your Python installation.

  (Contributed by Steve Dower in :issue:`37351`.)


CPython bytecode changes
------------------------

* The interpreter loop  has been simplified by moving the logic of unrolling
  the stack of blocks into the compiler.  The compiler emits now explicit
  instructions for adjusting the stack of values and calling the
  cleaning-up code for :keyword:`break`, :keyword:`continue` and
  :keyword:`return`.

  Removed opcodes :opcode:`BREAK_LOOP`, :opcode:`CONTINUE_LOOP`,
  :opcode:`SETUP_LOOP` and :opcode:`SETUP_EXCEPT`.  Added new opcodes
  :opcode:`ROT_FOUR`, :opcode:`BEGIN_FINALLY`, :opcode:`CALL_FINALLY` and
  :opcode:`POP_FINALLY`.  Changed the behavior of :opcode:`END_FINALLY`
  and :opcode:`WITH_CLEANUP_START`.

  (Contributed by Mark Shannon, Antoine Pitrou and Serhiy Storchaka in
  :issue:`17611`.)

* Added new opcode :opcode:`END_ASYNC_FOR` for handling exceptions raised
  when awaiting a next item in an :keyword:`async for` loop.
  (Contributed by Serhiy Storchaka in :issue:`33041`.)

* The :opcode:`MAP_ADD` now expects the value as the first element in the
  stack and the key as the second element. This change was made so the key
  is always evaluated before the value in dictionary comprehensions, as
  proposed by :pep:`572`. (Contributed by Jörn Heissler in :issue:`35224`.)


Demos and Tools
---------------

Added a benchmark script for timing various ways to access variables:
``Tools/scripts/var_access_benchmark.py``.
(Contributed by Raymond Hettinger in :issue:`35884`.)

Here's a summary of performance improvements since Python 3.3:

.. code-block:: none

    Python version                       3.3     3.4     3.5     3.6     3.7     3.8
    --------------                       ---     ---     ---     ---     ---     ---

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

    Variable and attribute write access:
        write_local                      4.6     8.7     9.3     5.5     5.3     4.3
        write_nonlocal                   7.3    10.5    11.1     5.6     5.5     4.7
        write_global                    15.9    19.7    21.2    18.0    18.0    15.8
        write_classvar                  81.9    92.9    96.0   104.6   102.1    39.2
        write_instancevar               36.4    44.6    45.8    40.0    38.9    35.5
        write_instancevar_slots         28.7    35.6    36.1    27.3    26.6    25.7

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

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

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

    Timing loop:
        loop_overhead                    0.3     0.5     0.6     0.4     0.3     0.3

    (Measured from the macOS 64-bit builds found at python.org)

Notable changes in Python 3.8.1
===============================

Due to significant security concerns, the *reuse_address* parameter of
:meth:`asyncio.loop.create_datagram_endpoint` 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
:issue:`37228`.)
