Skip to content

3.8.rst

Latest commit

 

History

History
2364 lines (1759 loc) · 92.7 KB

3.8.rst

File metadata and controls

2364 lines (1759 loc) · 92.7 KB

What's New In Python 3.8

Editor:Raymond Hettinger

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

.. testsetup::

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

Summary -- Release highlights

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.

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 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:`divmod` function does not accept keyword arguments:

def divmod(a, b, /):
    "Emulate the built in divmod() function"
    return (a // b, a % b)

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`.)

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

The ABI of Python :ref:`debug builds <debug-build>` is now compatible with Python release builds. 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. The inverse is not true, as debug builds expose additional symbols not available in release builds.

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 :option:`./configure --with-trace-refs <--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:

>>> import datetime as dt
>>> user = 'eric_idle'
>>> member_since = dt.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 = dt.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:

New functions:

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`.)

PEP 590: Vectorcall: a fast calling protocol for CPython

:ref:`vectorcall` is added to the Python/C API. It is meant to formalize existing optimizations which were already done for various classes. Any :ref:`static type <static-types>` 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, Mark Shannon and Petr Viktorin 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 :samp:`\\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 maggie')
('SIMPSONS', 'homer', 'marge', 'bart', 'lisa', 'maggie')

    (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 of 38 modulo 137, write:

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

    Modular inverses arise in the solution of linear Diophantine equations. 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:`~object.__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:

$ 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` and no longer inherits from :class:`concurrent.futures.CancelledError`. (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 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 Selik 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:`~datetime.date` and :class:`~datetime.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`.)

New in 3.8.1:

Add option to toggle cursor blink off. (Contributed by Zackery Spytz in :issue:`4603`.)

Escape key now closes IDLE completion windows. (Contributed by Johnny Najera in :issue:`38944`.)

The changes above have been backported to 3.7 maintenance releases.

Add keywords to module name completion list. (Contributed by Terry J. Reedy in :issue:`37765`.)

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 :ref:`debug build <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 Donghee 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:`os.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:`os.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`) Note that link_to was deprecated in 3.10 and removed in 3.12 in favor of a hardlink_to method added in 3.10 which matches the semantics of the existing symlink_to method.

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:`!selection_from`, :meth:`!selection_present`, :meth:`!selection_range` and :meth:`!selection_to` in the :class:`!tkinter.Spinbox` class. (Contributed by Juliette Monsel in :issue:`34829`.)

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

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

time

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

typing

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

unicodedata

The :mod:`unicodedata` module has been upgraded to use the Unicode 12.1.0 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 :c:type:`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

Deprecated

API and Feature Removals

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

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

Changes in the Python API

  • 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.
  • The parameter digestmod for :func:`hmac.new` no longer uses the MD5 digest by default.

Changes in the C API

CPython bytecode changes

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:

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

The benchmarks were measured on an Intel® Core™ i7-4960HQ processor running the macOS 64-bit builds found at python.org. The benchmark script displays timings in nanoseconds.

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`.)

Notable changes in Python 3.8.2

Fixed a regression with the ignore callback of :func:`shutil.copytree`. The argument types are now str and List[str] again. (Contributed by Manuel Barkhau and Giampaolo Rodola in :gh:`83571`.)

Notable changes in Python 3.8.3

The constant values of future flags in the :mod:`__future__` module are 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 :gh:`83743`)

Notable changes in Python 3.8.8

Earlier Python versions allowed using both ; and & as query parameter separators in :func:`urllib.parse.parse_qs` and :func:`urllib.parse.parse_qsl`. 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 :func:`!cgi.parse` and :func:`!cgi.parse_multipart` 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 :issue:`42967`.)

Notable changes in Python 3.8.9

A security fix alters the :class:`ftplib.FTP` 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 :gh:`87451`)

Notable changes in Python 3.8.10

macOS 11.0 (Big Sur) and Apple Silicon Mac support

As of 3.8.10, Python now supports building and running on macOS 11 (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. Note that support for "weaklinking", building binaries targeted for newer versions of macOS that will also run correctly on older versions by testing at runtime for missing features, is not included in this backport from Python 3.9; to support a range of macOS versions, continue to target for and build on the oldest version in the range.

(Originally contributed by Ronald Oussoren and Lawrence D'Anna in :gh:`85272`, with fixes by FX Coudert and Eli Rykoff, and backported to 3.8 by Maxime Bélanger and Ned Deily)

Notable changes in Python 3.8.10

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 RFC 3986, ASCII newline \n, \r and tab \t characters are stripped from the URL by the parser in :mod:`urllib.parse` preventing such attacks. The removal characters are controlled by a new module level variable urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE. (See :issue:`43882`)

Notable changes in Python 3.8.12

Changes in the Python API

Starting with Python 3.8.12 the :mod:`ipaddress` 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 :func:`socket.inet_aton` treats leading zeros as octal notation. glibc implementation of modern :func:`~socket.inet_pton` does not accept any leading zeros.

(Originally contributed by Christian Heimes in :issue:`36384`, and backported to 3.8 by Achraf Merzouki.)

Notable security feature in 3.8.14

Converting between :class:`int` and :class:`str` in bases other than 2 (binary), 4, 8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now raises a :exc:`ValueError` 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 :cve:`2020-10735`. This limit can be configured or disabled by environment variable, command line flag, or :mod:`sys` APIs. See the :ref:`integer string conversion length limitation <int_max_str_digits>` documentation. The default limit is 4300 digits in string form.

Notable changes in 3.8.17

tarfile