Skip to content

Latest commit

 

History

History
1710 lines (1260 loc) · 67 KB

3.8.rst

File metadata and controls

1710 lines (1260 loc) · 67 KB
Raw

What's New In Python 3.8

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

Prerelease users should be aware that this document is currently in draft form. It will be updated as Python 3.8 moves towards release, so it's worth checking back even after reading earlier versions. Some notable items not yet covered are:

  • PEP 578 - Runtime audit hooks for potentially sensitive operations
  • python -m asyncio runs a natively async REPL
.. testsetup::

   from datetime import date
   from math import cos, radians
   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 "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:`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 except 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

Python now uses the same ABI whether it 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 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`.)

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

New Modules

  • None yet.

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

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 async and await as non-reserved words.)

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

asyncio

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

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

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

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

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

gettext

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

idlelib and IDLE

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

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

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)

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

gc

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

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

idlelib and IDLE

Add optional line numbers for IDLE editor windows. Windows open without line numbers unless set otherwise in the General tab of the configuration dialog. (Contributed by Tal Einat and Saimadhav Heblikar in :issue:`17535`.)

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

The changes above have been backported to 3.7 maintenance releases.

json.tool

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

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]
>>> (link: http://math.prod) math.prod(likelihoods, start=prior)
0.126

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

Added new function :func:`math.isqrt` for computing integer square roots. (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 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`.

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

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.

ncurses

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

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

Reduction methods can now include a 6th item in the tuple they return. This item should specify a custom state-setting method that's called instead of the regular __setstate__ method. (Contributed by Pierre Glaser and Olivier Grisel in :issue:`35900`)

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

py_compile

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

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

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

ssl

Added :attr:`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

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:

unicodedata

unittest

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

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 Rodola' 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 Rodola' 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.

  • 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:

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

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 KB2533625 has been installed (this is also verified by the installer). (See :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). A 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 gets a new cf_feature_version field. It should be initialized to PY_MINOR_VERSION. The field is ignored by default, it is used if and only if PyCF_ONLY_AST flag is set in cf_flags.

  • 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:

      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:

      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:

    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:

    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.

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