python_doc_md/Beginner/whatsnew/3.12.md

What's New In Python 3.12

Editor : Adam Turner

* Anyone can add text to this document. Do not spend very much time on the wording of your changes, because your text will probably get rewritten to some degree.

* The maintainer will go through Misc/NEWS periodically and add changes; it's therefore more important to add your changes to Misc/NEWS than to this file.

* This is not a complete list of every single change; completeness is the purpose of Misc/NEWS. Some changes I consider too small or esoteric to include. If such a change is added to the text, I'll just remove it. (This is another reason you shouldn't spend too much time on writing your addition.)

* If you want to draw your new text to the attention of the maintainer, add 'XXX' to the beginning of the paragraph or section.

* It's OK to just add a fragmentary note about a change. For example: "XXX Describe the transmogrify() function added to the socket module." The maintainer will research the change and write the necessary text.

* You can comment out your additions if you like, but it's not necessary (especially when a final release is some months away).

* Credit the author of a patch or bugfix. Just the name is sufficient; the e-mail address isn't necessary.

• It's helpful to add the issue number as a comment:

XXX Describe the transmogrify() function added to the socket module. (Contributed by P.Y. Developer in 12345{.interpreted-text role="gh"}.)

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

This article explains the new features in Python 3.12, compared to 3.11. Python 3.12 was released on October 2, 2023. For full details, see the changelog <changelog>{.interpreted-text role="ref"}.

::: seealso 693{.interpreted-text role="pep"} -- Python 3.12 Release Schedule :::

Summary -- Release highlights

Python 3.12 is a stable release of the Python programming language, with a mix of changes to the language and the standard library. The library changes focus on cleaning up deprecated APIs, usability, and correctness. Of note, the !distutils{.interpreted-text role="mod"} package has been removed from the standard library. Filesystem support in os{.interpreted-text role="mod"} and pathlib{.interpreted-text role="mod"} has seen a number of improvements, and several modules have better performance.

The language changes focus on usability, as f-strings <f-string>{.interpreted-text role="term"} have had many limitations removed and 'Did you mean ...' suggestions continue to improve. The new type parameter syntax <whatsnew312-pep695>{.interpreted-text role="ref"} and type{.interpreted-text role="keyword"} statement improve ergonomics for using generic types <generic type>{.interpreted-text role="term"} and type aliases <type alias>{.interpreted-text role="term"} with static type checkers.

This article doesn't attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details, you should refer to the documentation, such as the Library Reference <library-index>{.interpreted-text role="ref"} and Language Reference <reference-index>{.interpreted-text role="ref"}. If you want to understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature; but note that PEPs usually are not kept up-to-date once a feature has been fully implemented.

---

New syntax features:

• PEP 695 <whatsnew312-pep695>{.interpreted-text role="ref"}, type parameter syntax and the type{.interpreted-text role="keyword"} statement

New grammar features:

• PEP 701 <whatsnew312-pep701>{.interpreted-text role="ref"}, f-strings <f-string>{.interpreted-text role="term"} in the grammar

Interpreter improvements:

• PEP 684 <whatsnew312-pep684>{.interpreted-text role="ref"}, a unique per-interpreter GIL <global interpreter lock>{.interpreted-text role="term"}
• PEP 669 <whatsnew312-pep669>{.interpreted-text role="ref"}, low impact monitoring
• Improved 'Did you mean ...' suggestions for NameError{.interpreted-text role="exc"}, ImportError{.interpreted-text role="exc"}, and SyntaxError{.interpreted-text role="exc"} exceptions

Python data model improvements:

• PEP 688 <whatsnew312-pep688>{.interpreted-text role="ref"}, using the buffer protocol <bufferobjects>{.interpreted-text role="ref"} from Python

Significant improvements in the standard library:

• The pathlib.Path{.interpreted-text role="class"} class now supports subclassing
• The os{.interpreted-text role="mod"} module received several improvements for Windows support
• A command-line interface <sqlite3-cli>{.interpreted-text role="ref"} has been added to the sqlite3{.interpreted-text role="mod"} module
• isinstance{.interpreted-text role="func"} checks against runtime-checkable protocols <typing.runtime_checkable>{.interpreted-text role="func"} enjoy a speed up of between two and 20 times
• The asyncio{.interpreted-text role="mod"} package has had a number of performance improvements, with some benchmarks showing a 75% speed up.
• A command-line interface <uuid-cli>{.interpreted-text role="ref"} has been added to the uuid{.interpreted-text role="mod"} module
• Due to the changes in PEP 701 <whatsnew312-pep701>{.interpreted-text role="ref"}, producing tokens via the tokenize{.interpreted-text role="mod"} module is up to 64% faster.

Security improvements:

• Replace the builtin hashlib{.interpreted-text role="mod"} implementations of SHA1, SHA3, SHA2-384, SHA2-512, and MD5 with formally verified code from the HACL* project. These builtin implementations remain as fallbacks that are only used when OpenSSL does not provide them.

C API improvements:

• PEP 697 <whatsnew312-pep697>{.interpreted-text role="ref"}, unstable C API tier
• PEP 683 <whatsnew312-pep683>{.interpreted-text role="ref"}, immortal objects

CPython implementation improvements:

• PEP 709 <whatsnew312-pep709>{.interpreted-text role="ref"}, comprehension inlining
• CPython support <perf_profiling>{.interpreted-text role="ref"} for the Linux perf profiler
• Implement stack overflow protection on supported platforms

New typing features:

• PEP 692 <whatsnew312-pep692>{.interpreted-text role="ref"}, using ~typing.TypedDict{.interpreted-text role="class"} to annotate **kwargs <argument>{.interpreted-text role="term"}
• PEP 698 <whatsnew312-pep698>{.interpreted-text role="ref"}, typing.override{.interpreted-text role="func"} decorator

Important deprecations, removals or restrictions:

• 623{.interpreted-text role="pep"}: Remove wstr from Unicode objects in Python's C API, reducing the size of every str{.interpreted-text role="class"} object by at least 8 bytes.
• 632{.interpreted-text role="pep"}: Remove the !distutils{.interpreted-text role="mod"} package. See the migration guide <0632#migration-advice>{.interpreted-text role="pep"} for advice replacing the APIs it provided. The third-party Setuptools package continues to provide !distutils{.interpreted-text role="mod"}, if you still require it in Python 3.12 and beyond.
• 95299{.interpreted-text role="gh"}: Do not pre-install setuptools in virtual environments created with venv{.interpreted-text role="mod"}. This means that distutils, setuptools, pkg_resources, and easy_install will no longer available by default; to access these run pip install setuptools in the activated <venv-explanation>{.interpreted-text role="ref"} virtual environment.
• The !asynchat{.interpreted-text role="mod"}, !asyncore{.interpreted-text role="mod"}, and !imp{.interpreted-text role="mod"} modules have been removed, along with several unittest.TestCase{.interpreted-text role="class"} method aliases.

New Features

PEP 695: Type Parameter Syntax {#whatsnew312-pep695}

Generic classes and functions under 484{.interpreted-text role="pep"} were declared using a verbose syntax that left the scope of type parameters unclear and required explicit declarations of variance.

695{.interpreted-text role="pep"} introduces a new, more compact and explicit way to create generic classes <generic-classes>{.interpreted-text role="ref"} and functions <generic-functions>{.interpreted-text role="ref"}:

def max[T](args: Iterable[T]) -> T:
    ...

class list[T]:
    def __getitem__(self, index: int, /) -> T:
        ...

    def append(self, element: T) -> None:
        ...

In addition, the PEP introduces a new way to declare type aliases <type-aliases>{.interpreted-text role="ref"} using the type{.interpreted-text role="keyword"} statement, which creates an instance of ~typing.TypeAliasType{.interpreted-text role="class"}:

type Point = tuple[float, float]

Type aliases can also be generic <generic-type-aliases>{.interpreted-text role="ref"}:

type Point[T] = tuple[T, T]

The new syntax allows declaring ~typing.TypeVarTuple{.interpreted-text role="class"} and ~typing.ParamSpec{.interpreted-text role="class"} parameters, as well as ~typing.TypeVar{.interpreted-text role="class"} parameters with bounds or constraints:

type IntFunc[**P] = Callable[P, int]  # ParamSpec
type LabeledTuple[*Ts] = tuple[str, *Ts]  # TypeVarTuple
type HashableSequence[T: Hashable] = Sequence[T]  # TypeVar with bound
type IntOrStrSequence[T: (int, str)] = Sequence[T]  # TypeVar with constraints

The value of type aliases and the bound and constraints of type variables created through this syntax are evaluated only on demand (see lazy evaluation <lazy-evaluation>{.interpreted-text role="ref"}). This means type aliases are able to refer to other types defined later in the file.

Type parameters declared through a type parameter list are visible within the scope of the declaration and any nested scopes, but not in the outer scope. For example, they can be used in the type annotations for the methods of a generic class or in the class body. However, they cannot be used in the module scope after the class is defined. See type-params{.interpreted-text role="ref"} for a detailed description of the runtime semantics of type parameters.

In order to support these scoping semantics, a new kind of scope is introduced, the annotation scope <annotation-scopes>{.interpreted-text role="ref"}. Annotation scopes behave for the most part like function scopes, but interact differently with enclosing class scopes. In Python 3.13, annotations <annotation>{.interpreted-text role="term"} will also be evaluated in annotation scopes.

See 695{.interpreted-text role="pep"} for more details.

(PEP written by Eric Traut. Implementation by Jelle Zijlstra, Eric Traut, and others in 103764{.interpreted-text role="gh"}.)

PEP 701: Syntactic formalization of f-strings {#whatsnew312-pep701}

701{.interpreted-text role="pep"} lifts some restrictions on the usage of f-strings <f-string>{.interpreted-text role="term"}. Expression components inside f-strings can now be any valid Python expression, including strings reusing the same quote as the containing f-string, multi-line expressions, comments, backslashes, and unicode escape sequences. Let's cover these in detail:

• Quote reuse: in Python 3.11, reusing the same quotes as the enclosing f-string raises a SyntaxError{.interpreted-text role="exc"}, forcing the user to either use other available quotes (like using double quotes or triple quotes if the f-string uses single quotes). In Python 3.12, you can now do things like this:

  >>> songs = ['Take me back to Eden', 'Alkaline', 'Ascensionism'] >>> f"This is the playlist: {", ".join(songs)}" 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'

  Note that before this change there was no explicit limit in how f-strings can be nested, but the fact that string quotes cannot be reused inside the expression component of f-strings made it impossible to nest f-strings arbitrarily. In fact, this is the most nested f-string that could be written:

  >>> f"""{f'''{f'{f"{1+1}"}'}'''}""" '2'

  As now f-strings can contain any valid Python expression inside expression components, it is now possible to nest f-strings arbitrarily:

  >>> f"{f"{f"{f"{f"{f"{1+1}"}"}"}"}"}" '2'

• Multi-line expressions and comments: In Python 3.11, f-string expressions must be defined in a single line, even if the expression within the f-string could normally span multiple lines (like literal lists being defined over multiple lines), making them harder to read. In Python 3.12 you can now define f-strings spanning multiple lines, and add inline comments:

  >>> f"This is the playlist: {", ".join([ ... 'Take me back to Eden', # My, my, those eyes like fire ... 'Alkaline', # Not acid nor alkaline ... 'Ascensionism' # Take to the broken skies at last ... ])}" 'This is the playlist: Take me back to Eden, Alkaline, Ascensionism'

• Backslashes and unicode characters: before Python 3.12 f-string expressions couldn't contain any \ character. This also affected unicode escape sequences <escape-sequences>{.interpreted-text role="ref"} (such as \N{snowman}) as these contain the \N part that previously could not be part of expression components of f-strings. Now, you can define expressions like this:

  >>> print(f"This is the playlist: {"n".join(songs)}") This is the playlist: Take me back to Eden Alkaline Ascensionism >>> print(f"This is the playlist: {"N{BLACK HEART SUIT}".join(songs)}") This is the playlist: Take me back to Eden♥Alkaline♥Ascensionism

See 701{.interpreted-text role="pep"} for more details.

As a positive side-effect of how this feature has been implemented (by parsing f-strings with the PEG parser <617>{.interpreted-text role="pep"}), now error messages for f-strings are more precise and include the exact location of the error. For example, in Python 3.11, the following f-string raises a SyntaxError{.interpreted-text role="exc"}:

>>> my_string = f"{x z y}" + f"{1 + 1}"
  File "<stdin>", line 1
    (x z y)
     ^^^
SyntaxError: f-string: invalid syntax. Perhaps you forgot a comma?

but the error message doesn't include the exact location of the error within the line and also has the expression artificially surrounded by parentheses. In Python 3.12, as f-strings are parsed with the PEG parser, error messages can be more precise and show the entire line:

>>> my_string = f"{x z y}" + f"{1 + 1}"
  File "<stdin>", line 1
    my_string = f"{x z y}" + f"{1 + 1}"
                   ^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?

(Contributed by Pablo Galindo, Batuhan Taskaya, Lysandros Nikolaou, Cristián Maureira-Fredes and Marta Gómez in 102856{.interpreted-text role="gh"}. PEP written by Pablo Galindo, Batuhan Taskaya, Lysandros Nikolaou and Marta Gómez).

PEP 684: A Per-Interpreter GIL {#whatsnew312-pep684}

684{.interpreted-text role="pep"} introduces a per-interpreter GIL <global interpreter lock>{.interpreted-text role="term"}, so that sub-interpreters may now be created with a unique GIL per interpreter. This allows Python programs to take full advantage of multiple CPU cores. This is currently only available through the C-API, though a Python API is anticipated for 3.13 <554>{.interpreted-text role="pep"}.

Use the new Py_NewInterpreterFromConfig{.interpreted-text role="c:func"} function to create an interpreter with its own GIL:

PyInterpreterConfig config = {
    .check_multi_interp_extensions = 1,
    .gil = PyInterpreterConfig_OWN_GIL,
};
PyThreadState *tstate = NULL;
PyStatus status = Py_NewInterpreterFromConfig(&tstate, &config);
if (PyStatus_Exception(status)) {
    return -1;
}
/* The new interpreter is now active in the current thread. */

For further examples how to use the C-API for sub-interpreters with a per-interpreter GIL, see Modules/_xxsubinterpretersmodule.c.

(Contributed by Eric Snow in 104210{.interpreted-text role="gh"}, etc.)

PEP 669: Low impact monitoring for CPython {#whatsnew312-pep669}

669{.interpreted-text role="pep"} defines a new API <sys.monitoring>{.interpreted-text role="mod"} for profilers, debuggers, and other tools to monitor events in CPython. It covers a wide range of events, including calls, returns, lines, exceptions, jumps, and more. This means that you only pay for what you use, providing support for near-zero overhead debuggers and coverage tools. See sys.monitoring{.interpreted-text role="mod"} for details.

(Contributed by Mark Shannon in 103082{.interpreted-text role="gh"}.)

PEP 688: Making the buffer protocol accessible in Python {#whatsnew312-pep688}

688{.interpreted-text role="pep"} introduces a way to use the buffer protocol <bufferobjects>{.interpreted-text role="ref"} from Python code. Classes that implement the ~object.__buffer__{.interpreted-text role="meth"} method are now usable as buffer types.

The new collections.abc.Buffer{.interpreted-text role="class"} ABC provides a standard way to represent buffer objects, for example in type annotations. The new inspect.BufferFlags{.interpreted-text role="class"} enum represents the flags that can be used to customize buffer creation. (Contributed by Jelle Zijlstra in 102500{.interpreted-text role="gh"}.)

PEP 709: Comprehension inlining {#whatsnew312-pep709}

Dictionary, list, and set comprehensions are now inlined, rather than creating a new single-use function object for each execution of the comprehension. This speeds up execution of a comprehension by up to two times. See 709{.interpreted-text role="pep"} for further details.

Comprehension iteration variables remain isolated and don't overwrite a variable of the same name in the outer scope, nor are they visible after the comprehension. Inlining does result in a few visible behavior changes:

• There is no longer a separate frame for the comprehension in tracebacks, and tracing/profiling no longer shows the comprehension as a function call.
• The symtable{.interpreted-text role="mod"} module will no longer produce child symbol tables for each comprehension; instead, the comprehension's locals will be included in the parent function's symbol table.
• Calling locals{.interpreted-text role="func"} inside a comprehension now includes variables from outside the comprehension, and no longer includes the synthetic .0 variable for the comprehension "argument".
• A comprehension iterating directly over locals() (e.g. [k for k in locals()]) may see "RuntimeError: dictionary changed size during iteration" when run under tracing (e.g. code coverage measurement). This is the same behavior already seen in e.g. for k in locals():. To avoid the error, first create a list of keys to iterate over: keys = list(locals()); [k for k in keys].

(Contributed by Carl Meyer and Vladimir Matveev in 709{.interpreted-text role="pep"}.)

Improved Error Messages

• Modules from the standard library are now potentially suggested as part of the error messages displayed by the interpreter when a NameError{.interpreted-text role="exc"} is raised to the top level. (Contributed by Pablo Galindo in 98254{.interpreted-text role="gh"}.)

  >>> sys.version_info Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'sys' is not defined. Did you forget to import 'sys'?

• Improve the error suggestion for NameError{.interpreted-text role="exc"} exceptions for instances. Now if a NameError{.interpreted-text role="exc"} is raised in a method and the instance has an attribute that's exactly equal to the name in the exception, the suggestion will include self.<NAME> instead of the closest match in the method scope. (Contributed by Pablo Galindo in 99139{.interpreted-text role="gh"}.)

  >>> class A: ... def __init__(self): ... self.blech = 1 ... ... def foo(self): ... somethin = blech ... >>> A().foo() Traceback (most recent call last): File "<stdin>", line 1 somethin = blech ^^^^^ NameError: name 'blech' is not defined. Did you mean: 'self.blech'?

• Improve the SyntaxError{.interpreted-text role="exc"} error message when the user types import x from y instead of from y import x. (Contributed by Pablo Galindo in 98931{.interpreted-text role="gh"}.)

  >>> import a.y.z from b.y.z Traceback (most recent call last): File "<stdin>", line 1 import a.y.z from b.y.z ^^^^^^^^^^^^^^^^^^^^^^^ SyntaxError: Did you mean to use 'from ... import ...' instead?

• ImportError{.interpreted-text role="exc"} exceptions raised from failed from <module> import <name> statements now include suggestions for the value of <name> based on the available names in <module>. (Contributed by Pablo Galindo in 91058{.interpreted-text role="gh"}.)

  >>> from collections import chainmap Traceback (most recent call last): File "<stdin>", line 1, in <module> ImportError: cannot import name 'chainmap' from 'collections'. Did you mean: 'ChainMap'?

New Features Related to Type Hints

This section covers major changes affecting type hints <484>{.interpreted-text role="pep"} and the typing{.interpreted-text role="mod"} module.

PEP 692: Using TypedDict for more precise **kwargs typing {#whatsnew312-pep692}

Typing **kwargs in a function signature as introduced by 484{.interpreted-text role="pep"} allowed for valid annotations only in cases where all of the **kwargs were of the same type.

692{.interpreted-text role="pep"} specifies a more precise way of typing **kwargs by relying on typed dictionaries:

from typing import TypedDict, Unpack

class Movie(TypedDict):
  name: str
  year: int

def foo(**kwargs: Unpack[Movie]): ...

See 692{.interpreted-text role="pep"} for more details.

(Contributed by Franek Magiera in 103629{.interpreted-text role="gh"}.)

PEP 698: Override Decorator for Static Typing {#whatsnew312-pep698}

A new decorator typing.override{.interpreted-text role="func"} has been added to the typing{.interpreted-text role="mod"} module. It indicates to type checkers that the method is intended to override a method in a superclass. This allows type checkers to catch mistakes where a method that is intended to override something in a base class does not in fact do so.

Example:

from typing import override

class Base:
  def get_color(self) -> str:
    return "blue"

class GoodChild(Base):
  @override  # ok: overrides Base.get_color
  def get_color(self) -> str:
    return "yellow"

class BadChild(Base):
  @override  # type checker error: does not override Base.get_color
  def get_colour(self) -> str:
    return "red"

See 698{.interpreted-text role="pep"} for more details.

(Contributed by Steven Troxler in 101561{.interpreted-text role="gh"}.)

Other Language Changes

• The parser now raises SyntaxError{.interpreted-text role="exc"} when parsing source code containing null bytes. (Contributed by Pablo Galindo in 96670{.interpreted-text role="gh"}.)
• A backslash-character pair that is not a valid escape sequence now generates a SyntaxWarning{.interpreted-text role="exc"}, instead of DeprecationWarning{.interpreted-text role="exc"}. For example, re.compile("\d+\.\d+") now emits a SyntaxWarning{.interpreted-text role="exc"} ("\d" is an invalid escape sequence, use raw strings for regular expression: re.compile(r"\d+\.\d+")). In a future Python version, SyntaxError{.interpreted-text role="exc"} will eventually be raised, instead of SyntaxWarning{.interpreted-text role="exc"}. (Contributed by Victor Stinner in 98401{.interpreted-text role="gh"}.)
• Octal escapes with value larger than 0o377 (ex: "\477"), deprecated in Python 3.11, now produce a SyntaxWarning{.interpreted-text role="exc"}, instead of DeprecationWarning{.interpreted-text role="exc"}. In a future Python version they will be eventually a SyntaxError{.interpreted-text role="exc"}. (Contributed by Victor Stinner in 98401{.interpreted-text role="gh"}.)
• Variables used in the target part of comprehensions that are not stored to can now be used in assignment expressions (:=). For example, in [(b := 1) for a, b.prop in some_iter], the assignment to b is now allowed. Note that assigning to variables stored to in the target part of comprehensions (like a) is still disallowed, as per 572{.interpreted-text role="pep"}. (Contributed by Nikita Sobolev in 100581{.interpreted-text role="gh"}.)
• Exceptions raised in a class or type's __set_name__ method are no longer wrapped by a RuntimeError{.interpreted-text role="exc"}. Context information is added to the exception as a 678{.interpreted-text role="pep"} note. (Contributed by Irit Katriel in 77757{.interpreted-text role="gh"}.)
• When a try-except* construct handles the entire ExceptionGroup{.interpreted-text role="exc"} and raises one other exception, that exception is no longer wrapped in an ExceptionGroup{.interpreted-text role="exc"}. Also changed in version 3.11.4. (Contributed by Irit Katriel in 103590{.interpreted-text role="gh"}.)
• The Garbage Collector now runs only on the eval breaker mechanism of the Python bytecode evaluation loop instead of object allocations. The GC can also run when PyErr_CheckSignals{.interpreted-text role="c:func"} is called so C extensions that need to run for a long time without executing any Python code also have a chance to execute the GC periodically. (Contributed by Pablo Galindo in 97922{.interpreted-text role="gh"}.)
• All builtin and extension callables expecting boolean parameters now accept arguments of any type instead of just bool{.interpreted-text role="class"} and int{.interpreted-text role="class"}. (Contributed by Serhiy Storchaka in 60203{.interpreted-text role="gh"}.)
• memoryview{.interpreted-text role="class"} now supports the half-float type (the "e" format code). (Contributed by Donghee Na and Antoine Pitrou in 90751{.interpreted-text role="gh"}.)
• slice{.interpreted-text role="class"} objects are now hashable, allowing them to be used as dict keys and set items. (Contributed by Will Bradshaw, Furkan Onder, and Raymond Hettinger in 101264{.interpreted-text role="gh"}.)
• sum{.interpreted-text role="func"} now uses Neumaier summation to improve accuracy and commutativity when summing floats or mixed ints and floats. (Contributed by Raymond Hettinger in 100425{.interpreted-text role="gh"}.)
• ast.parse{.interpreted-text role="func"} now raises SyntaxError{.interpreted-text role="exc"} instead of ValueError{.interpreted-text role="exc"} when parsing source code containing null bytes. (Contributed by Pablo Galindo in 96670{.interpreted-text role="gh"}.)
• The extraction methods in tarfile{.interpreted-text role="mod"}, and shutil.unpack_archive{.interpreted-text role="func"}, have a new a filter argument that allows limiting tar features than may be surprising or dangerous, such as creating files outside the destination directory. See tarfile extraction filters <tarfile-extraction-filter>{.interpreted-text role="ref"} for details. In Python 3.14, the default will switch to 'data'. (Contributed by Petr Viktorin in 706{.interpreted-text role="pep"}.)
• types.MappingProxyType{.interpreted-text role="class"} instances are now hashable if the underlying mapping is hashable. (Contributed by Serhiy Storchaka in 87995{.interpreted-text role="gh"}.)
• Add support for the perf profiler <perf_profiling>{.interpreted-text role="ref"} through the new environment variable PYTHONPERFSUPPORT{.interpreted-text role="envvar"} and command-line option -X perf <-X>{.interpreted-text role="option"}, as well as the new sys.activate_stack_trampoline{.interpreted-text role="func"}, sys.deactivate_stack_trampoline{.interpreted-text role="func"}, and sys.is_stack_trampoline_active{.interpreted-text role="func"} functions. (Design by Pablo Galindo. Contributed by Pablo Galindo and Christian Heimes with contributions from Gregory P. Smith [Google] and Mark Shannon in 96123{.interpreted-text role="gh"}.)

New Modules

• None.

Improved Modules

array

• The array.array{.interpreted-text role="class"} class now supports subscripting, making it a generic type{.interpreted-text role="term"}. (Contributed by Jelle Zijlstra in 98658{.interpreted-text role="gh"}.)

asyncio

• The performance of writing to sockets in asyncio{.interpreted-text role="mod"} has been significantly improved. asyncio now avoids unnecessary copying when writing to sockets and uses ~socket.socket.sendmsg{.interpreted-text role="meth"} if the platform supports it. (Contributed by Kumar Aditya in 91166{.interpreted-text role="gh"}.)
• Add asyncio.eager_task_factory{.interpreted-text role="func"} and asyncio.create_eager_task_factory{.interpreted-text role="func"} functions to allow opting an event loop in to eager task execution, making some use-cases 2x to 5x faster. (Contributed by Jacob Bower & Itamar Oren in 102853{.interpreted-text role="gh"}, 104140{.interpreted-text role="gh"}, and 104138{.interpreted-text role="gh"})
• On Linux, asyncio{.interpreted-text role="mod"} uses !asyncio.PidfdChildWatcher{.interpreted-text role="class"} by default if os.pidfd_open{.interpreted-text role="func"} is available and functional instead of !asyncio.ThreadedChildWatcher{.interpreted-text role="class"}. (Contributed by Kumar Aditya in 98024{.interpreted-text role="gh"}.)
• The event loop now uses the best available child watcher for each platform (!asyncio.PidfdChildWatcher{.interpreted-text role="class"} if supported and !asyncio.ThreadedChildWatcher{.interpreted-text role="class"} otherwise), so manually configuring a child watcher is not recommended. (Contributed by Kumar Aditya in 94597{.interpreted-text role="gh"}.)
• Add loop_factory parameter to asyncio.run{.interpreted-text role="func"} to allow specifying a custom event loop factory. (Contributed by Kumar Aditya in 99388{.interpreted-text role="gh"}.)
• Add C implementation of asyncio.current_task{.interpreted-text role="func"} for 4x-6x speedup. (Contributed by Itamar Oren and Pranav Thulasiram Bhat in 100344{.interpreted-text role="gh"}.)
• asyncio.iscoroutine{.interpreted-text role="func"} now returns False for generators as asyncio{.interpreted-text role="mod"} does not support legacy generator-based coroutines. (Contributed by Kumar Aditya in 102748{.interpreted-text role="gh"}.)
• asyncio.wait{.interpreted-text role="func"} and asyncio.as_completed{.interpreted-text role="func"} now accepts generators yielding tasks. (Contributed by Kumar Aditya in 78530{.interpreted-text role="gh"}.)

calendar

• Add enums calendar.Month{.interpreted-text role="data"} and calendar.Day{.interpreted-text role="data"} defining months of the year and days of the week. (Contributed by Prince Roshan in 103636{.interpreted-text role="gh"}.)

csv

• Add csv.QUOTE_NOTNULL{.interpreted-text role="const"} and csv.QUOTE_STRINGS{.interpreted-text role="const"} flags to provide finer grained control of None and empty strings by ~csv.reader{.interpreted-text role="class"} and ~csv.writer{.interpreted-text role="class"} objects.

dis

• Pseudo instruction opcodes (which are used by the compiler but do not appear in executable bytecode) are now exposed in the dis{.interpreted-text role="mod"} module. HAVE_ARGUMENT{.interpreted-text role="opcode"} is still relevant to real opcodes, but it is not useful for pseudo instructions. Use the new dis.hasarg{.interpreted-text role="data"} collection instead. (Contributed by Irit Katriel in 94216{.interpreted-text role="gh"}.)
• Add the dis.hasexc{.interpreted-text role="data"} collection to signify instructions that set an exception handler. (Contributed by Irit Katriel in 94216{.interpreted-text role="gh"}.)

fractions

• Objects of type fractions.Fraction{.interpreted-text role="class"} now support float-style formatting. (Contributed by Mark Dickinson in 100161{.interpreted-text role="gh"}.)

importlib.resources

• importlib.resources.as_file{.interpreted-text role="func"} now supports resource directories. (Contributed by Jason R. Coombs in 97930{.interpreted-text role="gh"}.)
• Rename first parameter of importlib.resources.files{.interpreted-text role="func"} to anchor. (Contributed by Jason R. Coombs in 100598{.interpreted-text role="gh"}.)

inspect

• Add inspect.markcoroutinefunction{.interpreted-text role="func"} to mark sync functions that return a coroutine{.interpreted-text role="term"} for use with inspect.iscoroutinefunction{.interpreted-text role="func"}. (Contributed by Carlton Gibson in 99247{.interpreted-text role="gh"}.)
• Add inspect.getasyncgenstate{.interpreted-text role="func"} and inspect.getasyncgenlocals{.interpreted-text role="func"} for determining the current state of asynchronous generators. (Contributed by Thomas Krennwallner in 79940{.interpreted-text role="gh"}.)
• The performance of inspect.getattr_static{.interpreted-text role="func"} has been considerably improved. Most calls to the function should be at least 2x faster than they were in Python 3.11. (Contributed by Alex Waygood in 103193{.interpreted-text role="gh"}.)

itertools

• Add itertools.batched{.interpreted-text role="func"} for collecting into even-sized tuples where the last batch may be shorter than the rest. (Contributed by Raymond Hettinger in 98363{.interpreted-text role="gh"}.)

math

• Add math.sumprod{.interpreted-text role="func"} for computing a sum of products. (Contributed by Raymond Hettinger in 100485{.interpreted-text role="gh"}.)
• Extend math.nextafter{.interpreted-text role="func"} to include a steps argument for moving up or down multiple steps at a time. (Contributed by Matthias Goergens, Mark Dickinson, and Raymond Hettinger in 94906{.interpreted-text role="gh"}.)

os

• Add os.PIDFD_NONBLOCK{.interpreted-text role="const"} to open a file descriptor for a process with os.pidfd_open{.interpreted-text role="func"} in non-blocking mode. (Contributed by Kumar Aditya in 93312{.interpreted-text role="gh"}.)
• os.DirEntry{.interpreted-text role="class"} now includes an os.DirEntry.is_junction{.interpreted-text role="meth"} method to check if the entry is a junction. (Contributed by Charles Machalow in 99547{.interpreted-text role="gh"}.)
• Add os.listdrives{.interpreted-text role="func"}, os.listvolumes{.interpreted-text role="func"} and os.listmounts{.interpreted-text role="func"} functions on Windows for enumerating drives, volumes and mount points. (Contributed by Steve Dower in 102519{.interpreted-text role="gh"}.)
• os.stat{.interpreted-text role="func"} and os.lstat{.interpreted-text role="func"} are now more accurate on Windows. The st_birthtime field will now be filled with the creation time of the file, and st_ctime is deprecated but still contains the creation time (but in the future will return the last metadata change, for consistency with other platforms). st_dev may be up to 64 bits and st_ino up to 128 bits depending on your file system, and st_rdev is always set to zero rather than incorrect values. Both functions may be significantly faster on newer releases of Windows. (Contributed by Steve Dower in 99726{.interpreted-text role="gh"}.)

os.path

• Add os.path.isjunction{.interpreted-text role="func"} to check if a given path is a junction. (Contributed by Charles Machalow in 99547{.interpreted-text role="gh"}.)
• Add os.path.splitroot{.interpreted-text role="func"} to split a path into a triad (drive, root, tail). (Contributed by Barney Gale in 101000{.interpreted-text role="gh"}.)

pathlib

• Add support for subclassing pathlib.PurePath{.interpreted-text role="class"} and pathlib.Path{.interpreted-text role="class"}, plus their Posix- and Windows-specific variants. Subclasses may override the pathlib.PurePath.with_segments{.interpreted-text role="meth"} method to pass information between path instances.
• Add pathlib.Path.walk{.interpreted-text role="meth"} for walking the directory trees and generating all file or directory names within them, similar to os.walk{.interpreted-text role="func"}. (Contributed by Stanislav Zmiev in 90385{.interpreted-text role="gh"}.)
• Add walk_up optional parameter to pathlib.PurePath.relative_to{.interpreted-text role="meth"} to allow the insertion of .. entries in the result; this behavior is more consistent with os.path.relpath{.interpreted-text role="func"}. (Contributed by Domenico Ragusa in 84538{.interpreted-text role="gh"}.)
• Add pathlib.Path.is_junction{.interpreted-text role="meth"} as a proxy to os.path.isjunction{.interpreted-text role="func"}. (Contributed by Charles Machalow in 99547{.interpreted-text role="gh"}.)
• Add case_sensitive optional parameter to pathlib.Path.glob{.interpreted-text role="meth"}, pathlib.Path.rglob{.interpreted-text role="meth"} and pathlib.PurePath.match{.interpreted-text role="meth"} for matching the path's case sensitivity, allowing for more precise control over the matching process.

platform

• Add support for detecting Windows 11 and Windows Server releases past 2012. Previously, lookups on Windows Server platforms newer than Windows Server 2012 and on Windows 11 would return Windows-10. (Contributed by Steve Dower in 89545{.interpreted-text role="gh"}.)

pdb

• Add convenience variables to hold values temporarily for debug session and provide quick access to values like the current frame or the return value. (Contributed by Tian Gao in 103693{.interpreted-text role="gh"}.)

random

• Add random.binomialvariate{.interpreted-text role="func"}. (Contributed by Raymond Hettinger in 81620{.interpreted-text role="gh"}.)
• Add a default of lambd=1.0 to random.expovariate{.interpreted-text role="func"}. (Contributed by Raymond Hettinger in 100234{.interpreted-text role="gh"}.)

shutil

• shutil.make_archive{.interpreted-text role="func"} now passes the root_dir argument to custom archivers which support it. In this case it no longer temporarily changes the current working directory of the process to root_dir to perform archiving. (Contributed by Serhiy Storchaka in 74696{.interpreted-text role="gh"}.)

• shutil.rmtree{.interpreted-text role="func"} now accepts a new argument onexc which is an error handler like onerror but which expects an exception instance rather than a (typ, val, tb) triplet. onerror is deprecated. (Contributed by Irit Katriel in 102828{.interpreted-text role="gh"}.)

• shutil.which{.interpreted-text role="func"} now consults the PATHEXT environment variable to find matches within PATH on Windows even when the given cmd includes a directory component. (Contributed by Charles Machalow in 103179{.interpreted-text role="gh"}.)

  shutil.which{.interpreted-text role="func"} will call NeedCurrentDirectoryForExePathW when querying for executables on Windows to determine if the current working directory should be prepended to the search path. (Contributed by Charles Machalow in 103179{.interpreted-text role="gh"}.)

  shutil.which{.interpreted-text role="func"} will return a path matching the cmd with a component from PATHEXT prior to a direct match elsewhere in the search path on Windows. (Contributed by Charles Machalow in 103179{.interpreted-text role="gh"}.)

sqlite3

• Add a command-line interface <sqlite3-cli>{.interpreted-text role="ref"}. (Contributed by Erlend E. Aasland in 77617{.interpreted-text role="gh"}.)
• Add the sqlite3.Connection.autocommit{.interpreted-text role="attr"} attribute to sqlite3.Connection{.interpreted-text role="class"} and the autocommit parameter to sqlite3.connect{.interpreted-text role="func"} to control 249{.interpreted-text role="pep"}-compliant transaction handling <sqlite3-transaction-control-autocommit>{.interpreted-text role="ref"}. (Contributed by Erlend E. Aasland in 83638{.interpreted-text role="gh"}.)
• Add entrypoint keyword-only parameter to sqlite3.Connection.load_extension{.interpreted-text role="meth"}, for overriding the SQLite extension entry point. (Contributed by Erlend E. Aasland in 103015{.interpreted-text role="gh"}.)
• Add sqlite3.Connection.getconfig{.interpreted-text role="meth"} and sqlite3.Connection.setconfig{.interpreted-text role="meth"} to sqlite3.Connection{.interpreted-text role="class"} to make configuration changes to a database connection. (Contributed by Erlend E. Aasland in 103489{.interpreted-text role="gh"}.)

statistics

• Extend statistics.correlation{.interpreted-text role="func"} to include as a ranked method for computing the Spearman correlation of ranked data. (Contributed by Raymond Hettinger in 95861{.interpreted-text role="gh"}.)

sys

• Add the sys.monitoring{.interpreted-text role="mod"} namespace to expose the new PEP 669 <whatsnew312-pep669>{.interpreted-text role="ref"} monitoring API. (Contributed by Mark Shannon in 103082{.interpreted-text role="gh"}.)
• Add sys.activate_stack_trampoline{.interpreted-text role="func"} and sys.deactivate_stack_trampoline{.interpreted-text role="func"} for activating and deactivating stack profiler trampolines, and sys.is_stack_trampoline_active{.interpreted-text role="func"} for querying if stack profiler trampolines are active. (Contributed by Pablo Galindo and Christian Heimes with contributions from Gregory P. Smith [Google] and Mark Shannon in 96123{.interpreted-text role="gh"}.)
• Add sys.last_exc{.interpreted-text role="data"} which holds the last unhandled exception that was raised (for post-mortem debugging use cases). Deprecate the three fields that have the same information in its legacy form: sys.last_type{.interpreted-text role="data"}, sys.last_value{.interpreted-text role="data"} and sys.last_traceback{.interpreted-text role="data"}. (Contributed by Irit Katriel in 102778{.interpreted-text role="gh"}.)
• sys._current_exceptions{.interpreted-text role="func"} now returns a mapping from thread-id to an exception instance, rather than to a (typ, exc, tb) tuple. (Contributed by Irit Katriel in 103176{.interpreted-text role="gh"}.)
• sys.setrecursionlimit{.interpreted-text role="func"} and sys.getrecursionlimit{.interpreted-text role="func"}. The recursion limit now applies only to Python code. Builtin functions do not use the recursion limit, but are protected by a different mechanism that prevents recursion from causing a virtual machine crash.

tempfile

• The tempfile.NamedTemporaryFile{.interpreted-text role="class"} function has a new optional parameter delete_on_close (Contributed by Evgeny Zorin in 58451{.interpreted-text role="gh"}.)
• tempfile.mkdtemp{.interpreted-text role="func"} now always returns an absolute path, even if the argument provided to the dir parameter is a relative path.

threading

• Add threading.settrace_all_threads{.interpreted-text role="func"} and threading.setprofile_all_threads{.interpreted-text role="func"} that allow to set tracing and profiling functions in all running threads in addition to the calling one. (Contributed by Pablo Galindo in 93503{.interpreted-text role="gh"}.)

tkinter

• tkinter.Canvas.coords() now flattens its arguments. It now accepts not only coordinates as separate arguments (x1, y1, x2, y2, ...) and a sequence of coordinates ([x1, y1, x2, y2, ...]), but also coordinates grouped in pairs ((x1, y1), (x2, y2), ... and [(x1, y1), (x2, y2), ...]), like create_*() methods. (Contributed by Serhiy Storchaka in 94473{.interpreted-text role="gh"}.)

tokenize

• The tokenize{.interpreted-text role="mod"} module includes the changes introduced in 701{.interpreted-text role="pep"}. (Contributed by Marta Gómez Macías and Pablo Galindo in 102856{.interpreted-text role="gh"}.) See whatsnew312-porting-to-python312{.interpreted-text role="ref"} for more information on the changes to the tokenize{.interpreted-text role="mod"} module.

types

• Add types.get_original_bases{.interpreted-text role="func"} to allow for further introspection of user-defined-generics{.interpreted-text role="ref"} when subclassed. (Contributed by James Hilton-Balfe and Alex Waygood in 101827{.interpreted-text role="gh"}.)

typing {#whatsnew-typing-py312}

• isinstance{.interpreted-text role="func"} checks against runtime-checkable protocols <typing.runtime_checkable>{.interpreted-text role="func"} now use inspect.getattr_static{.interpreted-text role="func"} rather than hasattr{.interpreted-text role="func"} to lookup whether attributes exist. This means that descriptors and ~object.__getattr__{.interpreted-text role="meth"} methods are no longer unexpectedly evaluated during isinstance() checks against runtime-checkable protocols. However, it may also mean that some objects which used to be considered instances of a runtime-checkable protocol may no longer be considered instances of that protocol on Python 3.12+, and vice versa. Most users are unlikely to be affected by this change. (Contributed by Alex Waygood in 102433{.interpreted-text role="gh"}.)

• The members of a runtime-checkable protocol are now considered "frozen" at runtime as soon as the class has been created. Monkey-patching attributes onto a runtime-checkable protocol will still work, but will have no impact on isinstance{.interpreted-text role="func"} checks comparing objects to the protocol. For example:

  >>> from typing import Protocol, runtime_checkable
  >>> @runtime_checkable
  ... class HasX(Protocol):
  ...     x = 1
  ...
  >>> class Foo: ...
  ...
  >>> f = Foo()
  >>> isinstance(f, HasX)
  False
  >>> f.x = 1
  >>> isinstance(f, HasX)
  True
  >>> HasX.y = 2
  >>> isinstance(f, HasX)  # unchanged, even though HasX now also has a "y" attribute
  True
  

  This change was made in order to speed up isinstance() checks against runtime-checkable protocols.

• The performance profile of isinstance{.interpreted-text role="func"} checks against runtime-checkable protocols <typing.runtime_checkable>{.interpreted-text role="func"} has changed significantly. Most isinstance() checks against protocols with only a few members should be at least 2x faster than in 3.11, and some may be 20x faster or more. However, isinstance() checks against protocols with many members may be slower than in Python 3.11. (Contributed by Alex Waygood in 74690{.interpreted-text role="gh"} and 103193{.interpreted-text role="gh"}.)

• All typing.TypedDict{.interpreted-text role="data"} and typing.NamedTuple{.interpreted-text role="data"} classes now have the __orig_bases__ attribute. (Contributed by Adrian Garcia Badaracco in 103699{.interpreted-text role="gh"}.)

• Add frozen_default parameter to typing.dataclass_transform{.interpreted-text role="func"}. (Contributed by Erik De Bonte in 99957{.interpreted-text role="gh"}.)

unicodedata

• The Unicode database has been updated to version 15.0.0. (Contributed by Benjamin Peterson in 96734{.interpreted-text role="gh"}).

unittest

Add a --durations command line option, showing the N slowest test cases:

python3 -m unittest --durations=3 lib.tests.test_threading
.....
Slowest test durations
----------------------------------------------------------------------
1.210s     test_timeout (Lib.test.test_threading.BarrierTests)
1.003s     test_default_timeout (Lib.test.test_threading.BarrierTests)
0.518s     test_timeout (Lib.test.test_threading.EventTests)

(0.000 durations hidden.  Use -v to show these durations.)
----------------------------------------------------------------------
Ran 158 tests in 9.869s

OK (skipped=3)

(Contributed by Giampaolo Rodola in 48330{.interpreted-text role="gh"})

uuid

• Add a command-line interface <uuid-cli>{.interpreted-text role="ref"}. (Contributed by Adam Chhina in 88597{.interpreted-text role="gh"}.)

Optimizations

• Remove wstr and wstr_length members from Unicode objects. It reduces object size by 8 or 16 bytes on 64bit platform. (623{.interpreted-text role="pep"}) (Contributed by Inada Naoki in 92536{.interpreted-text role="gh"}.)
• Add experimental support for using the BOLT binary optimizer in the build process, which improves performance by 1-5%. (Contributed by Kevin Modzelewski in 90536{.interpreted-text role="gh"} and tuned by Donghee Na in 101525{.interpreted-text role="gh"})
• Speed up the regular expression substitution (functions re.sub{.interpreted-text role="func"} and re.subn{.interpreted-text role="func"} and corresponding !re.Pattern{.interpreted-text role="class"} methods) for replacement strings containing group references by 2--3 times. (Contributed by Serhiy Storchaka in 91524{.interpreted-text role="gh"}.)
• Speed up asyncio.Task{.interpreted-text role="class"} creation by deferring expensive string formatting. (Contributed by Itamar Oren in 103793{.interpreted-text role="gh"}.)
• The tokenize.tokenize{.interpreted-text role="func"} and tokenize.generate_tokens{.interpreted-text role="func"} functions are up to 64% faster as a side effect of the changes required to cover 701{.interpreted-text role="pep"} in the tokenize{.interpreted-text role="mod"} module. (Contributed by Marta Gómez Macías and Pablo Galindo in 102856{.interpreted-text role="gh"}.)
• Speed up super{.interpreted-text role="func"} method calls and attribute loads via the new LOAD_SUPER_ATTR{.interpreted-text role="opcode"} instruction. (Contributed by Carl Meyer and Vladimir Matveev in 103497{.interpreted-text role="gh"}.)

CPython bytecode changes

• Remove the !LOAD_METHOD{.interpreted-text role="opcode"} instruction. It has been merged into LOAD_ATTR{.interpreted-text role="opcode"}. LOAD_ATTR{.interpreted-text role="opcode"} will now behave like the old !LOAD_METHOD{.interpreted-text role="opcode"} instruction if the low bit of its oparg is set. (Contributed by Ken Jin in 93429{.interpreted-text role="gh"}.)
• Remove the !JUMP_IF_FALSE_OR_POP{.interpreted-text role="opcode"} and !JUMP_IF_TRUE_OR_POP{.interpreted-text role="opcode"} instructions. (Contributed by Irit Katriel in 102859{.interpreted-text role="gh"}.)
• Remove the !PRECALL{.interpreted-text role="opcode"} instruction. (Contributed by Mark Shannon in 92925{.interpreted-text role="gh"}.)
• Add the BINARY_SLICE{.interpreted-text role="opcode"} and STORE_SLICE{.interpreted-text role="opcode"} instructions. (Contributed by Mark Shannon in 94163{.interpreted-text role="gh"}.)
• Add the CALL_INTRINSIC_1{.interpreted-text role="opcode"} instructions. (Contributed by Mark Shannon in 99005{.interpreted-text role="gh"}.)
• Add the CALL_INTRINSIC_2{.interpreted-text role="opcode"} instruction. (Contributed by Irit Katriel in 101799{.interpreted-text role="gh"}.)
• Add the CLEANUP_THROW{.interpreted-text role="opcode"} instruction. (Contributed by Brandt Bucher in 90997{.interpreted-text role="gh"}.)
• Add the !END_SEND{.interpreted-text role="opcode"} instruction. (Contributed by Mark Shannon in 103082{.interpreted-text role="gh"}.)
• Add the LOAD_FAST_AND_CLEAR{.interpreted-text role="opcode"} instruction as part of the implementation of 709{.interpreted-text role="pep"}. (Contributed by Carl Meyer in 101441{.interpreted-text role="gh"}.)
• Add the LOAD_FAST_CHECK{.interpreted-text role="opcode"} instruction. (Contributed by Dennis Sweeney in 93143{.interpreted-text role="gh"}.)
• Add the LOAD_FROM_DICT_OR_DEREF{.interpreted-text role="opcode"}, LOAD_FROM_DICT_OR_GLOBALS{.interpreted-text role="opcode"}, and LOAD_LOCALS{.interpreted-text role="opcode"} opcodes as part of the implementation of 695{.interpreted-text role="pep"}. Remove the !LOAD_CLASSDEREF{.interpreted-text role="opcode"} opcode, which can be replaced with LOAD_LOCALS{.interpreted-text role="opcode"} plus LOAD_FROM_DICT_OR_DEREF{.interpreted-text role="opcode"}. (Contributed by Jelle Zijlstra in 103764{.interpreted-text role="gh"}.)
• Add the LOAD_SUPER_ATTR{.interpreted-text role="opcode"} instruction. (Contributed by Carl Meyer and Vladimir Matveev in 103497{.interpreted-text role="gh"}.)
• Add the RETURN_CONST instruction. (Contributed by Wenyang Wang in 101632{.interpreted-text role="gh"}.)

Demos and Tools

• Remove the Tools/demo/ directory which contained old demo scripts. A copy can be found in the old-demos project. (Contributed by Victor Stinner in 97681{.interpreted-text role="gh"}.)
• Remove outdated example scripts of the Tools/scripts/ directory. A copy can be found in the old-demos project. (Contributed by Victor Stinner in 97669{.interpreted-text role="gh"}.)

Deprecated

• argparse{.interpreted-text role="mod"}: The type, choices, and metavar parameters of !argparse.BooleanOptionalAction{.interpreted-text role="class"} are deprecated and will be removed in 3.14. (Contributed by Nikita Sobolev in 92248{.interpreted-text role="gh"}.)

• ast{.interpreted-text role="mod"}: The following ast{.interpreted-text role="mod"} features have been deprecated in documentation since Python 3.8, now cause a DeprecationWarning{.interpreted-text role="exc"} to be emitted at runtime when they are accessed or used, and will be removed in Python 3.14:

  • !ast.Num{.interpreted-text role="class"}
  • !ast.Str{.interpreted-text role="class"}
  • !ast.Bytes{.interpreted-text role="class"}
  • !ast.NameConstant{.interpreted-text role="class"}
  • !ast.Ellipsis{.interpreted-text role="class"}

  Use ast.Constant{.interpreted-text role="class"} instead. (Contributed by Serhiy Storchaka in 90953{.interpreted-text role="gh"}.)

• asyncio{.interpreted-text role="mod"}:

  • The child watcher classes !asyncio.MultiLoopChildWatcher{.interpreted-text role="class"}, !asyncio.FastChildWatcher{.interpreted-text role="class"}, !asyncio.AbstractChildWatcher{.interpreted-text role="class"} and !asyncio.SafeChildWatcher{.interpreted-text role="class"} are deprecated and will be removed in Python 3.14. (Contributed by Kumar Aditya in 94597{.interpreted-text role="gh"}.)
  • !asyncio.set_child_watcher{.interpreted-text role="func"}, !asyncio.get_child_watcher{.interpreted-text role="func"}, !asyncio.AbstractEventLoopPolicy.set_child_watcher{.interpreted-text role="meth"} and !asyncio.AbstractEventLoopPolicy.get_child_watcher{.interpreted-text role="meth"} are deprecated and will be removed in Python 3.14. (Contributed by Kumar Aditya in 94597{.interpreted-text role="gh"}.)
  • The ~asyncio.get_event_loop{.interpreted-text role="meth"} method of the default event loop policy now emits a DeprecationWarning{.interpreted-text role="exc"} if there is no current event loop set and it decides to create one. (Contributed by Serhiy Storchaka and Guido van Rossum in 100160{.interpreted-text role="gh"}.)

• calendar{.interpreted-text role="mod"}: calendar.January and calendar.February constants are deprecated and replaced by calendar.JANUARY{.interpreted-text role="data"} and calendar.FEBRUARY{.interpreted-text role="data"}. (Contributed by Prince Roshan in 103636{.interpreted-text role="gh"}.)

• collections.abc{.interpreted-text role="mod"}: Deprecated collections.abc.ByteString{.interpreted-text role="class"}.

  Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol <bufferobjects>{.interpreted-text role="ref"} at runtime. For use in type annotations, either use ~collections.abc.Buffer{.interpreted-text role="class"} or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

  !ByteString{.interpreted-text role="class"} was originally intended to be an abstract class that would serve as a supertype of both bytes{.interpreted-text role="class"} and bytearray{.interpreted-text role="class"}. However, since the ABC never had any methods, knowing that an object was an instance of !ByteString{.interpreted-text role="class"} never actually told you anything useful about the object. Other common buffer types such as memoryview{.interpreted-text role="class"} were also never understood as subtypes of !ByteString{.interpreted-text role="class"} (either at runtime or by static type checkers).

  See PEP 688 <688#current-options>{.interpreted-text role="pep"} for more details. (Contributed by Shantanu Jain in 91896{.interpreted-text role="gh"}.)

• datetime{.interpreted-text role="mod"}: datetime.datetime{.interpreted-text role="class"}'s ~datetime.datetime.utcnow{.interpreted-text role="meth"} and ~datetime.datetime.utcfromtimestamp{.interpreted-text role="meth"} are deprecated and will be removed in a future version. Instead, use timezone-aware objects to represent datetimes in UTC: respectively, call ~datetime.datetime.now{.interpreted-text role="meth"} and ~datetime.datetime.fromtimestamp{.interpreted-text role="meth"} with the tz parameter set to datetime.UTC{.interpreted-text role="const"}. (Contributed by Paul Ganssle in 103857{.interpreted-text role="gh"}.)

• email{.interpreted-text role="mod"}: Deprecate the isdst parameter in email.utils.localtime{.interpreted-text role="func"}. (Contributed by Alan Williams in 72346{.interpreted-text role="gh"}.)

• importlib.abc{.interpreted-text role="mod"}: Deprecated the following classes, scheduled for removal in Python 3.14:

  • !importlib.abc.ResourceReader{.interpreted-text role="class"}
  • !importlib.abc.Traversable{.interpreted-text role="class"}
  • !importlib.abc.TraversableResources{.interpreted-text role="class"}

  Use importlib.resources.abc{.interpreted-text role="mod"} classes instead:

  • importlib.resources.abc.Traversable{.interpreted-text role="class"}
  • importlib.resources.abc.TraversableResources{.interpreted-text role="class"}

  (Contributed by Jason R. Coombs and Hugo van Kemenade in 93963{.interpreted-text role="gh"}.)

• itertools{.interpreted-text role="mod"}: Deprecate the support for copy, deepcopy, and pickle operations, which is undocumented, inefficient, historically buggy, and inconsistent. This will be removed in 3.14 for a significant reduction in code volume and maintenance burden. (Contributed by Raymond Hettinger in 101588{.interpreted-text role="gh"}.)

• multiprocessing{.interpreted-text role="mod"}: In Python 3.14, the default multiprocessing{.interpreted-text role="mod"} start method will change to a safer one on Linux, BSDs, and other non-macOS POSIX platforms where 'fork' is currently the default (84559{.interpreted-text role="gh"}). Adding a runtime warning about this was deemed too disruptive as the majority of code is not expected to care. Use the ~multiprocessing.get_context{.interpreted-text role="func"} or ~multiprocessing.set_start_method{.interpreted-text role="func"} APIs to explicitly specify when your code requires 'fork'. See contexts and start methods <multiprocessing-start-methods>{.interpreted-text role="ref"}.

• pkgutil{.interpreted-text role="mod"}: !pkgutil.find_loader{.interpreted-text role="func"} and !pkgutil.get_loader{.interpreted-text role="func"} are deprecated and will be removed in Python 3.14; use importlib.util.find_spec{.interpreted-text role="func"} instead. (Contributed by Nikita Sobolev in 97850{.interpreted-text role="gh"}.)

• pty{.interpreted-text role="mod"}: The module has two undocumented master_open() and slave_open() functions that have been deprecated since Python 2 but only gained a proper DeprecationWarning{.interpreted-text role="exc"} in 3.12. Remove them in 3.14. (Contributed by Soumendra Ganguly and Gregory P. Smith in 85984{.interpreted-text role="gh"}.)

• os{.interpreted-text role="mod"}:

  • The st_ctime fields return by os.stat{.interpreted-text role="func"} and os.lstat{.interpreted-text role="func"} on Windows are deprecated. In a future release, they will contain the last metadata change time, consistent with other platforms. For now, they still contain the creation time, which is also available in the new st_birthtime field. (Contributed by Steve Dower in 99726{.interpreted-text role="gh"}.)
  • On POSIX platforms, os.fork{.interpreted-text role="func"} can now raise a DeprecationWarning{.interpreted-text role="exc"} when it can detect being called from a multithreaded process. There has always been a fundamental incompatibility with the POSIX platform when doing so. Even if such code appeared to work. We added the warning to raise awareness as issues encountered by code doing this are becoming more frequent. See the os.fork{.interpreted-text role="func"} documentation for more details along with this discussion on fork being incompatible with threads for why we're now surfacing this longstanding platform compatibility problem to developers.

  When this warning appears due to usage of multiprocessing{.interpreted-text role="mod"} or concurrent.futures{.interpreted-text role="mod"} the fix is to use a different multiprocessing{.interpreted-text role="mod"} start method such as "spawn" or "forkserver".

• shutil{.interpreted-text role="mod"}: The onerror argument of shutil.rmtree{.interpreted-text role="func"} is deprecated; use onexc instead. (Contributed by Irit Katriel in 102828{.interpreted-text role="gh"}.)

• sqlite3{.interpreted-text role="mod"}:

  • default adapters and converters <sqlite3-default-converters>{.interpreted-text role="ref"} are now deprecated. Instead, use the sqlite3-adapter-converter-recipes{.interpreted-text role="ref"} and tailor them to your needs. (Contributed by Erlend E. Aasland in 90016{.interpreted-text role="gh"}.)
  • In ~sqlite3.Cursor.execute{.interpreted-text role="meth"}, DeprecationWarning{.interpreted-text role="exc"} is now emitted when named placeholders <sqlite3-placeholders>{.interpreted-text role="ref"} are used together with parameters supplied as a sequence{.interpreted-text role="term"} instead of as a dict{.interpreted-text role="class"}. Starting from Python 3.14, using named placeholders with parameters supplied as a sequence will raise a ~sqlite3.ProgrammingError{.interpreted-text role="exc"}. (Contributed by Erlend E. Aasland in 101698{.interpreted-text role="gh"}.)

• sys{.interpreted-text role="mod"}: The sys.last_type{.interpreted-text role="data"}, sys.last_value{.interpreted-text role="data"} and sys.last_traceback{.interpreted-text role="data"} fields are deprecated. Use sys.last_exc{.interpreted-text role="data"} instead. (Contributed by Irit Katriel in 102778{.interpreted-text role="gh"}.)

• tarfile{.interpreted-text role="mod"}: Extracting tar archives without specifying filter is deprecated until Python 3.14, when 'data' filter will become the default. See tarfile-extraction-filter{.interpreted-text role="ref"} for details.

• typing{.interpreted-text role="mod"}:

  • typing.Hashable{.interpreted-text role="class"} and typing.Sized{.interpreted-text role="class"}, aliases for collections.abc.Hashable{.interpreted-text role="class"} and collections.abc.Sized{.interpreted-text role="class"} respectively, are deprecated. (94309{.interpreted-text role="gh"}.)
  • typing.ByteString{.interpreted-text role="class"}, deprecated since Python 3.9, now causes a DeprecationWarning{.interpreted-text role="exc"} to be emitted when it is used. (Contributed by Alex Waygood in 91896{.interpreted-text role="gh"}.)

• xml.etree.ElementTree{.interpreted-text role="mod"}: The module now emits DeprecationWarning{.interpreted-text role="exc"} when testing the truth value of an xml.etree.ElementTree.Element{.interpreted-text role="class"}. Before, the Python implementation emitted FutureWarning{.interpreted-text role="exc"}, and the C implementation emitted nothing. (Contributed by Jacob Walls in 83122{.interpreted-text role="gh"}.)

• The 3-arg signatures (type, value, traceback) of coroutine throw() <coroutine.throw>{.interpreted-text role="meth"}, generator throw() <generator.throw>{.interpreted-text role="meth"} and async generator throw() <agen.athrow>{.interpreted-text role="meth"} are deprecated and may be removed in a future version of Python. Use the single-arg versions of these functions instead. (Contributed by Ofey Chan in 89874{.interpreted-text role="gh"}.)

• DeprecationWarning{.interpreted-text role="exc"} is now raised when ~module.__package__{.interpreted-text role="attr"} on a module differs from __spec__.parent <importlib.machinery.ModuleSpec.parent>{.interpreted-text role="attr"} (previously it was ImportWarning{.interpreted-text role="exc"}). (Contributed by Brett Cannon in 65961{.interpreted-text role="gh"}.)

• Setting ~module.__package__{.interpreted-text role="attr"} or __cached__ on a module is deprecated, and will cease to be set or taken into consideration by the import system in Python 3.14. (Contributed by Brett Cannon in 65961{.interpreted-text role="gh"}.)

• The bitwise inversion operator (~) on bool is deprecated. It will throw an error in Python 3.16. Use not for logical negation of bools instead. In the rare case that you really need the bitwise inversion of the underlying int, convert to int explicitly: ~int(x). (Contributed by Tim Hoffmann in 103487{.interpreted-text role="gh"}.)

• Accessing ~codeobject.co_lnotab{.interpreted-text role="attr"} on code objects was deprecated in Python 3.10 via 626{.interpreted-text role="pep"}, but it only got a proper DeprecationWarning{.interpreted-text role="exc"} in 3.12. May be removed in 3.15. (Contributed by Nikita Sobolev in 101866{.interpreted-text role="gh"}.)

Pending removal in Python 3.13

Modules (see 594{.interpreted-text role="pep"}):

• !aifc{.interpreted-text role="mod"}
• !audioop{.interpreted-text role="mod"}
• !cgi{.interpreted-text role="mod"}
• !cgitb{.interpreted-text role="mod"}
• !chunk{.interpreted-text role="mod"}
• !crypt{.interpreted-text role="mod"}
• !imghdr{.interpreted-text role="mod"}
• !mailcap{.interpreted-text role="mod"}
• !msilib{.interpreted-text role="mod"}
• !nis{.interpreted-text role="mod"}
• !nntplib{.interpreted-text role="mod"}
• !ossaudiodev{.interpreted-text role="mod"}
• !pipes{.interpreted-text role="mod"}
• !sndhdr{.interpreted-text role="mod"}
• !spwd{.interpreted-text role="mod"}
• !sunau{.interpreted-text role="mod"}
• !telnetlib{.interpreted-text role="mod"}
• !uu{.interpreted-text role="mod"}
• !xdrlib{.interpreted-text role="mod"}

Other modules:

• !lib2to3{.interpreted-text role="mod"}, and the 2to3{.interpreted-text role="program"} program (84540{.interpreted-text role="gh"})

APIs:

• !configparser.LegacyInterpolation{.interpreted-text role="class"} (90765{.interpreted-text role="gh"})
• locale.resetlocale() (90817{.interpreted-text role="gh"})
• !turtle.RawTurtle.settiltangle{.interpreted-text role="meth"} (50096{.interpreted-text role="gh"})
• !unittest.findTestCases{.interpreted-text role="func"} (50096{.interpreted-text role="gh"})
• !unittest.getTestCaseNames{.interpreted-text role="func"} (50096{.interpreted-text role="gh"})
• !unittest.makeSuite{.interpreted-text role="func"} (50096{.interpreted-text role="gh"})
• !unittest.TestProgram.usageExit{.interpreted-text role="meth"} (67048{.interpreted-text role="gh"})
• !webbrowser.MacOSX{.interpreted-text role="class"} (86421{.interpreted-text role="gh"})
• classmethod{.interpreted-text role="class"} descriptor chaining (89519{.interpreted-text role="gh"})

Pending removal in Python 3.14

• argparse{.interpreted-text role="mod"}: The type, choices, and metavar parameters of !argparse.BooleanOptionalAction{.interpreted-text role="class"} are deprecated and will be removed in 3.14. (Contributed by Nikita Sobolev in 92248{.interpreted-text role="gh"}.)

• ast{.interpreted-text role="mod"}: The following features have been deprecated in documentation since Python 3.8, now cause a DeprecationWarning{.interpreted-text role="exc"} to be emitted at runtime when they are accessed or used, and will be removed in Python 3.14:

  • !ast.Num{.interpreted-text role="class"}
  • !ast.Str{.interpreted-text role="class"}
  • !ast.Bytes{.interpreted-text role="class"}
  • !ast.NameConstant{.interpreted-text role="class"}
  • !ast.Ellipsis{.interpreted-text role="class"}

  Use ast.Constant{.interpreted-text role="class"} instead. (Contributed by Serhiy Storchaka in 90953{.interpreted-text role="gh"}.)

• asyncio{.interpreted-text role="mod"}:

  • The child watcher classes !asyncio.MultiLoopChildWatcher{.interpreted-text role="class"}, !asyncio.FastChildWatcher{.interpreted-text role="class"}, !asyncio.AbstractChildWatcher{.interpreted-text role="class"} and !asyncio.SafeChildWatcher{.interpreted-text role="class"} are deprecated and will be removed in Python 3.14. (Contributed by Kumar Aditya in 94597{.interpreted-text role="gh"}.)
  • !asyncio.set_child_watcher{.interpreted-text role="func"}, !asyncio.get_child_watcher{.interpreted-text role="func"}, !asyncio.AbstractEventLoopPolicy.set_child_watcher{.interpreted-text role="meth"} and !asyncio.AbstractEventLoopPolicy.get_child_watcher{.interpreted-text role="meth"} are deprecated and will be removed in Python 3.14. (Contributed by Kumar Aditya in 94597{.interpreted-text role="gh"}.)
  • The ~asyncio.get_event_loop{.interpreted-text role="meth"} method of the default event loop policy now emits a DeprecationWarning{.interpreted-text role="exc"} if there is no current event loop set and it decides to create one. (Contributed by Serhiy Storchaka and Guido van Rossum in 100160{.interpreted-text role="gh"}.)

• email{.interpreted-text role="mod"}: Deprecated the isdst parameter in email.utils.localtime{.interpreted-text role="func"}. (Contributed by Alan Williams in 72346{.interpreted-text role="gh"}.)

• importlib.abc{.interpreted-text role="mod"} deprecated classes:

  • !importlib.abc.ResourceReader{.interpreted-text role="class"}
  • !importlib.abc.Traversable{.interpreted-text role="class"}
  • !importlib.abc.TraversableResources{.interpreted-text role="class"}

  Use importlib.resources.abc{.interpreted-text role="mod"} classes instead:

  • importlib.resources.abc.Traversable{.interpreted-text role="class"}
  • importlib.resources.abc.TraversableResources{.interpreted-text role="class"}

  (Contributed by Jason R. Coombs and Hugo van Kemenade in 93963{.interpreted-text role="gh"}.)

• itertools{.interpreted-text role="mod"} had undocumented, inefficient, historically buggy, and inconsistent support for copy, deepcopy, and pickle operations. This will be removed in 3.14 for a significant reduction in code volume and maintenance burden. (Contributed by Raymond Hettinger in 101588{.interpreted-text role="gh"}.)

• multiprocessing{.interpreted-text role="mod"}: The default start method will change to a safer one on Linux, BSDs, and other non-macOS POSIX platforms where 'fork' is currently the default (84559{.interpreted-text role="gh"}). Adding a runtime warning about this was deemed too disruptive as the majority of code is not expected to care. Use the ~multiprocessing.get_context{.interpreted-text role="func"} or ~multiprocessing.set_start_method{.interpreted-text role="func"} APIs to explicitly specify when your code requires 'fork'. See multiprocessing-start-methods{.interpreted-text role="ref"}.

• pathlib{.interpreted-text role="mod"}: ~pathlib.PurePath.is_relative_to{.interpreted-text role="meth"} and ~pathlib.PurePath.relative_to{.interpreted-text role="meth"}: passing additional arguments is deprecated.

• pkgutil{.interpreted-text role="mod"}: !pkgutil.find_loader{.interpreted-text role="func"} and !pkgutil.get_loader{.interpreted-text role="func"} now raise DeprecationWarning{.interpreted-text role="exc"}; use importlib.util.find_spec{.interpreted-text role="func"} instead. (Contributed by Nikita Sobolev in 97850{.interpreted-text role="gh"}.)

• pty{.interpreted-text role="mod"}:

  • master_open(): use pty.openpty{.interpreted-text role="func"}.
  • slave_open(): use pty.openpty{.interpreted-text role="func"}.

• sqlite3{.interpreted-text role="mod"}:

  • !version{.interpreted-text role="data"} and !version_info{.interpreted-text role="data"}.
  • ~sqlite3.Cursor.execute{.interpreted-text role="meth"} and ~sqlite3.Cursor.executemany{.interpreted-text role="meth"} if named placeholders <sqlite3-placeholders>{.interpreted-text role="ref"} are used and parameters is a sequence instead of a dict{.interpreted-text role="class"}.

• urllib{.interpreted-text role="mod"}: !urllib.parse.Quoter{.interpreted-text role="class"} is deprecated: it was not intended to be a public API. (Contributed by Gregory P. Smith in 88168{.interpreted-text role="gh"}.)

Pending removal in Python 3.15

• The import system:
  • Setting __cached__ on a module while failing to set __spec__.cached <importlib.machinery.ModuleSpec.cached>{.interpreted-text role="attr"} is deprecated. In Python 3.15, __cached__ will cease to be set or take into consideration by the import system or standard library. (97879{.interpreted-text role="gh"})
  • Setting ~module.__package__{.interpreted-text role="attr"} on a module while failing to set __spec__.parent <importlib.machinery.ModuleSpec.parent>{.interpreted-text role="attr"} is deprecated. In Python 3.15, !__package__{.interpreted-text role="attr"} will cease to be set or take into consideration by the import system or standard library. (97879{.interpreted-text role="gh"})
• ctypes{.interpreted-text role="mod"}:
  • The undocumented !ctypes.SetPointerType{.interpreted-text role="func"} function has been deprecated since Python 3.13.
• http.server{.interpreted-text role="mod"}:
  • The obsolete and rarely used !CGIHTTPRequestHandler{.interpreted-text role="class"} has been deprecated since Python 3.13. No direct replacement exists. Anything is better than CGI to interface a web server with a request handler.
  • The !--cgi{.interpreted-text role="option"} flag to the python -m http.server{.interpreted-text role="program"} command-line interface has been deprecated since Python 3.13.
• importlib{.interpreted-text role="mod"}:
  • load_module() method: use exec_module() instead.
• pathlib{.interpreted-text role="mod"}:
  • !.PurePath.is_reserved{.interpreted-text role="meth"} has been deprecated since Python 3.13. Use os.path.isreserved{.interpreted-text role="func"} to detect reserved paths on Windows.
• platform{.interpreted-text role="mod"}:
  • !platform.java_ver{.interpreted-text role="func"} has been deprecated since Python 3.13. This function is only useful for Jython support, has a confusing API, and is largely untested.
• sysconfig{.interpreted-text role="mod"}:
  • The check_home argument of sysconfig.is_python_build{.interpreted-text role="func"} has been deprecated since Python 3.12.
• threading{.interpreted-text role="mod"}:
  • ~threading.RLock{.interpreted-text role="func"} will take no arguments in Python 3.15. Passing any arguments has been deprecated since Python 3.14, as the Python version does not permit any arguments, but the C version allows any number of positional or keyword arguments, ignoring every argument.
• types{.interpreted-text role="mod"}:
  • types.CodeType{.interpreted-text role="class"}: Accessing ~codeobject.co_lnotab{.interpreted-text role="attr"} was deprecated in 626{.interpreted-text role="pep"} since 3.10 and was planned to be removed in 3.12, but it only got a proper DeprecationWarning{.interpreted-text role="exc"} in 3.12. May be removed in 3.15. (Contributed by Nikita Sobolev in 101866{.interpreted-text role="gh"}.)
• typing{.interpreted-text role="mod"}:
  • The undocumented keyword argument syntax for creating ~typing.NamedTuple{.interpreted-text role="class"} classes (for example, Point = NamedTuple("Point", x=int, y=int)) has been deprecated since Python 3.13. Use the class-based syntax or the functional syntax instead.
  • When using the functional syntax of ~typing.TypedDict{.interpreted-text role="class"}s, failing to pass a value to the fields parameter (TD = TypedDict("TD")) or passing None (TD = TypedDict("TD", None)) has been deprecated since Python 3.13. Use class TD(TypedDict): pass or TD = TypedDict("TD", {}) to create a TypedDict with zero field.
  • The !typing.no_type_check_decorator{.interpreted-text role="func"} decorator function has been deprecated since Python 3.13. After eight years in the typing{.interpreted-text role="mod"} module, it has yet to be supported by any major type checker.
• !sre_compile{.interpreted-text role="mod"}, !sre_constants{.interpreted-text role="mod"} and !sre_parse{.interpreted-text role="mod"} modules.
• wave{.interpreted-text role="mod"}:
  • The getmark(), setmark() and getmarkers() methods of the ~wave.Wave_read{.interpreted-text role="class"} and ~wave.Wave_write{.interpreted-text role="class"} classes have been deprecated since Python 3.13.
• zipimport{.interpreted-text role="mod"}:
  • !zipimport.zipimporter.load_module{.interpreted-text role="meth"} has been deprecated since Python 3.10. Use ~zipimport.zipimporter.exec_module{.interpreted-text role="meth"} instead. (125746{.interpreted-text role="gh"}.)

Pending removal in Python 3.16

• The import system:
  • Setting ~module.__loader__{.interpreted-text role="attr"} on a module while failing to set __spec__.loader <importlib.machinery.ModuleSpec.loader>{.interpreted-text role="attr"} is deprecated. In Python 3.16, !__loader__{.interpreted-text role="attr"} will cease to be set or taken into consideration by the import system or the standard library.
• array{.interpreted-text role="mod"}:
  • The 'u' format code (wchar_t{.interpreted-text role="c:type"}) has been deprecated in documentation since Python 3.3 and at runtime since Python 3.13. Use the 'w' format code (Py_UCS4{.interpreted-text role="c:type"}) for Unicode characters instead.
• asyncio{.interpreted-text role="mod"}:

  • !asyncio.iscoroutinefunction{.interpreted-text role="func"} is deprecated and will be removed in Python 3.16; use inspect.iscoroutinefunction{.interpreted-text role="func"} instead. (Contributed by Jiahao Li and Kumar Aditya in 122875{.interpreted-text role="gh"}.)

  • asyncio{.interpreted-text role="mod"} policy system is deprecated and will be removed in Python 3.16. In particular, the following classes and functions are deprecated:

    • asyncio.AbstractEventLoopPolicy{.interpreted-text role="class"}
    • asyncio.DefaultEventLoopPolicy{.interpreted-text role="class"}
    • asyncio.WindowsSelectorEventLoopPolicy{.interpreted-text role="class"}
    • asyncio.WindowsProactorEventLoopPolicy{.interpreted-text role="class"}
    • asyncio.get_event_loop_policy{.interpreted-text role="func"}
    • asyncio.set_event_loop_policy{.interpreted-text role="func"}

    Users should use asyncio.run{.interpreted-text role="func"} or asyncio.Runner{.interpreted-text role="class"} with loop_factory to use the desired event loop implementation.

    For example, to use asyncio.SelectorEventLoop{.interpreted-text role="class"} on Windows:

    import asyncio
    
    async def main():
        ...
    
    asyncio.run(main(), loop_factory=asyncio.SelectorEventLoop)
    

    (Contributed by Kumar Aditya in 127949{.interpreted-text role="gh"}.)

• builtins{.interpreted-text role="mod"}:
  • Bitwise inversion on boolean types, ~True or ~False has been deprecated since Python 3.12, as it produces surprising and unintuitive results (-2 and -1). Use not x instead for the logical negation of a Boolean. In the rare case that you need the bitwise inversion of the underlying integer, convert to int explicitly (~int(x)).
• functools{.interpreted-text role="mod"}:
  • Calling the Python implementation of functools.reduce{.interpreted-text role="func"} with function or sequence as keyword arguments has been deprecated since Python 3.14.
• logging{.interpreted-text role="mod"}:
  • Support for custom logging handlers with the strm argument is deprecated and scheduled for removal in Python 3.16. Define handlers with the stream argument instead. (Contributed by Mariusz Felisiak in 115032{.interpreted-text role="gh"}.)
• mimetypes{.interpreted-text role="mod"}:
  • Valid extensions start with a '.' or are empty for mimetypes.MimeTypes.add_type{.interpreted-text role="meth"}. Undotted extensions are deprecated and will raise a ValueError{.interpreted-text role="exc"} in Python 3.16. (Contributed by Hugo van Kemenade in 75223{.interpreted-text role="gh"}.)
• shutil{.interpreted-text role="mod"}:
  • The !ExecError{.interpreted-text role="class"} exception has been deprecated since Python 3.14. It has not been used by any function in !shutil{.interpreted-text role="mod"} since Python 3.4, and is now an alias of RuntimeError{.interpreted-text role="exc"}.
• symtable{.interpreted-text role="mod"}:
  • The Class.get_methods <symtable.Class.get_methods>{.interpreted-text role="meth"} method has been deprecated since Python 3.14.
• sys{.interpreted-text role="mod"}:
  • The ~sys._enablelegacywindowsfsencoding{.interpreted-text role="func"} function has been deprecated since Python 3.13. Use the PYTHONLEGACYWINDOWSFSENCODING{.interpreted-text role="envvar"} environment variable instead.
• sysconfig{.interpreted-text role="mod"}:
  • The !sysconfig.expand_makefile_vars{.interpreted-text role="func"} function has been deprecated since Python 3.14. Use the vars argument of sysconfig.get_paths{.interpreted-text role="func"} instead.
• tarfile{.interpreted-text role="mod"}:
  • The undocumented and unused !TarFile.tarfile{.interpreted-text role="attr"} attribute has been deprecated since Python 3.13.

Pending removal in Python 3.17

• collections.abc{.interpreted-text role="mod"}:

  • collections.abc.ByteString{.interpreted-text role="class"} is scheduled for removal in Python 3.17.

    Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol <bufferobjects>{.interpreted-text role="ref"} at runtime. For use in type annotations, either use ~collections.abc.Buffer{.interpreted-text role="class"} or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

    !ByteString{.interpreted-text role="class"} was originally intended to be an abstract class that would serve as a supertype of both bytes{.interpreted-text role="class"} and bytearray{.interpreted-text role="class"}. However, since the ABC never had any methods, knowing that an object was an instance of !ByteString{.interpreted-text role="class"} never actually told you anything useful about the object. Other common buffer types such as memoryview{.interpreted-text role="class"} were also never understood as subtypes of !ByteString{.interpreted-text role="class"} (either at runtime or by static type checkers).

    See PEP 688 <688#current-options>{.interpreted-text role="pep"} for more details. (Contributed by Shantanu Jain in 91896{.interpreted-text role="gh"}.)

• encodings{.interpreted-text role="mod"}:
  • Passing non-ascii encoding names to encodings.normalize_encoding{.interpreted-text role="func"} is deprecated and scheduled for removal in Python 3.17. (Contributed by Stan Ulbrych in 136702{.interpreted-text role="gh"})
• typing{.interpreted-text role="mod"}:

  • Before Python 3.14, old-style unions were implemented using the private class typing._UnionGenericAlias. This class is no longer needed for the implementation, but it has been retained for backward compatibility, with removal scheduled for Python 3.17. Users should use documented introspection helpers like typing.get_origin{.interpreted-text role="func"} and typing.get_args{.interpreted-text role="func"} instead of relying on private implementation details.

  • typing.ByteString{.interpreted-text role="class"}, deprecated since Python 3.9, is scheduled for removal in Python 3.17.

    Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol <bufferobjects>{.interpreted-text role="ref"} at runtime. For use in type annotations, either use ~collections.abc.Buffer{.interpreted-text role="class"} or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

    !ByteString{.interpreted-text role="class"} was originally intended to be an abstract class that would serve as a supertype of both bytes{.interpreted-text role="class"} and bytearray{.interpreted-text role="class"}. However, since the ABC never had any methods, knowing that an object was an instance of !ByteString{.interpreted-text role="class"} never actually told you anything useful about the object. Other common buffer types such as memoryview{.interpreted-text role="class"} were also never understood as subtypes of !ByteString{.interpreted-text role="class"} (either at runtime or by static type checkers).

    See PEP 688 <688#current-options>{.interpreted-text role="pep"} for more details. (Contributed by Shantanu Jain in 91896{.interpreted-text role="gh"}.)

Pending removal in Python 3.19

• ctypes{.interpreted-text role="mod"}:
  • Implicitly switching to the MSVC-compatible struct layout by setting ~ctypes.Structure._pack_{.interpreted-text role="attr"} but not ~ctypes.Structure._layout_{.interpreted-text role="attr"} on non-Windows platforms.
• hashlib{.interpreted-text role="mod"}:

  • In hash function constructors such as ~hashlib.new{.interpreted-text role="func"} or the direct hash-named constructors such as ~hashlib.md5{.interpreted-text role="func"} and ~hashlib.sha256{.interpreted-text role="func"}, their optional initial data parameter could also be passed a keyword argument named data= or string= in various !hashlib{.interpreted-text role="mod"} implementations.

    Support for the string keyword argument name is now deprecated and slated for removal in Python 3.19.

    Before Python 3.13, the string keyword parameter was not correctly supported depending on the backend implementation of hash functions. Prefer passing the initial data as a positional argument for maximum backwards compatibility.

Pending removal in Python 3.20

• The __version__, version and VERSION attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Use sys.version_info{.interpreted-text role="py:data"} instead.

  • argparse{.interpreted-text role="mod"}
  • csv{.interpreted-text role="mod"}
  • ctypes{.interpreted-text role="mod"}
  • !ctypes.macholib{.interpreted-text role="mod"}
  • decimal{.interpreted-text role="mod"} (use decimal.SPEC_VERSION{.interpreted-text role="data"} instead)
  • http.server{.interpreted-text role="mod"}
  • imaplib{.interpreted-text role="mod"}
  • ipaddress{.interpreted-text role="mod"}
  • json{.interpreted-text role="mod"}
  • logging{.interpreted-text role="mod"} (__date__ also deprecated)
  • optparse{.interpreted-text role="mod"}
  • pickle{.interpreted-text role="mod"}
  • platform{.interpreted-text role="mod"}
  • re{.interpreted-text role="mod"}
  • socketserver{.interpreted-text role="mod"}
  • tabnanny{.interpreted-text role="mod"}
  • tkinter.font{.interpreted-text role="mod"}
  • tkinter.ttk{.interpreted-text role="mod"}
  • wsgiref.simple_server{.interpreted-text role="mod"}
  • xml.etree.ElementTree{.interpreted-text role="mod"}
  • !xml.sax.expatreader{.interpreted-text role="mod"}
  • xml.sax.handler{.interpreted-text role="mod"}
  • zlib{.interpreted-text role="mod"}

  (Contributed by Hugo van Kemenade and Stan Ulbrych in 76007{.interpreted-text role="gh"}.)

Pending removal in future versions

The following APIs will be removed in the future, although there is currently no date scheduled for their removal.

• argparse{.interpreted-text role="mod"}:
  • Nesting argument groups and nesting mutually exclusive groups are deprecated.
  • Passing the undocumented keyword argument prefix_chars to ~argparse.ArgumentParser.add_argument_group{.interpreted-text role="meth"} is now deprecated.
  • The argparse.FileType{.interpreted-text role="class"} type converter is deprecated.
• builtins{.interpreted-text role="mod"}:
  • Generators: throw(type, exc, tb) and athrow(type, exc, tb) signature is deprecated: use throw(exc) and athrow(exc) instead, the single argument signature.
  • Currently Python accepts numeric literals immediately followed by keywords, for example 0in x, 1or x, 0if 1else 2. It allows confusing and ambiguous expressions like [0x1for x in y] (which can be interpreted as [0x1 for x in y] or [0x1f or x in y]). A syntax warning is raised if the numeric literal is immediately followed by one of keywords and{.interpreted-text role="keyword"}, else{.interpreted-text role="keyword"}, for{.interpreted-text role="keyword"}, if{.interpreted-text role="keyword"}, in{.interpreted-text role="keyword"}, is{.interpreted-text role="keyword"} and or{.interpreted-text role="keyword"}. In a future release it will be changed to a syntax error. (87999{.interpreted-text role="gh"})
  • Support for __index__() and __int__() method returning non-int type: these methods will be required to return an instance of a strict subclass of int{.interpreted-text role="class"}.
  • Support for __float__() method returning a strict subclass of float{.interpreted-text role="class"}: these methods will be required to return an instance of float{.interpreted-text role="class"}.
  • Support for __complex__() method returning a strict subclass of complex{.interpreted-text role="class"}: these methods will be required to return an instance of complex{.interpreted-text role="class"}.
  • Passing a complex number as the real or imag argument in the complex{.interpreted-text role="func"} constructor is now deprecated; it should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in 109218{.interpreted-text role="gh"}.)
• calendar{.interpreted-text role="mod"}: calendar.January and calendar.February constants are deprecated and replaced by calendar.JANUARY{.interpreted-text role="data"} and calendar.FEBRUARY{.interpreted-text role="data"}. (Contributed by Prince Roshan in 103636{.interpreted-text role="gh"}.)
• codecs{.interpreted-text role="mod"}: use open{.interpreted-text role="func"} instead of codecs.open{.interpreted-text role="func"}. (133038{.interpreted-text role="gh"})
• codeobject.co_lnotab{.interpreted-text role="attr"}: use the codeobject.co_lines{.interpreted-text role="meth"} method instead.
• datetime{.interpreted-text role="mod"}:
  • ~datetime.datetime.utcnow{.interpreted-text role="meth"}: use datetime.datetime.now(tz=datetime.UTC).
  • ~datetime.datetime.utcfromtimestamp{.interpreted-text role="meth"}: use datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC).
• gettext{.interpreted-text role="mod"}: Plural value must be an integer.
• importlib{.interpreted-text role="mod"}:
  • ~importlib.util.cache_from_source{.interpreted-text role="func"} debug_override parameter is deprecated: use the optimization parameter instead.
• importlib.metadata{.interpreted-text role="mod"}:
  • EntryPoints tuple interface.
  • Implicit None on return values.
• logging{.interpreted-text role="mod"}: the warn() method has been deprecated since Python 3.3, use ~logging.warning{.interpreted-text role="meth"} instead.
• mailbox{.interpreted-text role="mod"}: Use of StringIO input and text mode is deprecated, use BytesIO and binary mode instead.
• os{.interpreted-text role="mod"}: Calling os.register_at_fork{.interpreted-text role="func"} in a multi-threaded process.
• os.path{.interpreted-text role="mod"}: os.path.commonprefix{.interpreted-text role="func"} is deprecated, use os.path.commonpath{.interpreted-text role="func"} for path prefixes. The os.path.commonprefix{.interpreted-text role="func"} function is being deprecated due to having a misleading name and module. The function is not safe to use for path prefixes despite being included in a module about path manipulation, meaning it is easy to accidentally introduce path traversal vulnerabilities into Python programs by using this function.
• !pydoc.ErrorDuringImport{.interpreted-text role="class"}: A tuple value for exc_info parameter is deprecated, use an exception instance.
• re{.interpreted-text role="mod"}: More strict rules are now applied for numerical group references and group names in regular expressions. Only sequence of ASCII digits is now accepted as a numerical reference. The group name in bytes patterns and replacement strings can now only contain ASCII letters and digits and underscore. (Contributed by Serhiy Storchaka in 91760{.interpreted-text role="gh"}.)
• shutil{.interpreted-text role="mod"}: ~shutil.rmtree{.interpreted-text role="func"}'s onerror parameter is deprecated in Python 3.12; use the onexc parameter instead.
• ssl{.interpreted-text role="mod"} options and protocols:
  • ssl.SSLContext{.interpreted-text role="class"} without protocol argument is deprecated.
  • ssl.SSLContext{.interpreted-text role="class"}: ~ssl.SSLContext.set_npn_protocols{.interpreted-text role="meth"} and !selected_npn_protocol{.interpreted-text role="meth"} are deprecated: use ALPN instead.
  • ssl.OP_NO_SSL* options
  • ssl.OP_NO_TLS* options
  • ssl.PROTOCOL_SSLv3
  • ssl.PROTOCOL_TLS
  • ssl.PROTOCOL_TLSv1
  • ssl.PROTOCOL_TLSv1_1
  • ssl.PROTOCOL_TLSv1_2
  • ssl.TLSVersion.SSLv3
  • ssl.TLSVersion.TLSv1
  • ssl.TLSVersion.TLSv1_1
• threading{.interpreted-text role="mod"} methods:
  • !threading.Condition.notifyAll{.interpreted-text role="meth"}: use ~threading.Condition.notify_all{.interpreted-text role="meth"}.
  • !threading.Event.isSet{.interpreted-text role="meth"}: use ~threading.Event.is_set{.interpreted-text role="meth"}.
  • !threading.Thread.isDaemon{.interpreted-text role="meth"}, threading.Thread.setDaemon{.interpreted-text role="meth"}: use threading.Thread.daemon{.interpreted-text role="attr"} attribute.
  • !threading.Thread.getName{.interpreted-text role="meth"}, threading.Thread.setName{.interpreted-text role="meth"}: use threading.Thread.name{.interpreted-text role="attr"} attribute.
  • !threading.currentThread{.interpreted-text role="meth"}: use threading.current_thread{.interpreted-text role="meth"}.
  • !threading.activeCount{.interpreted-text role="meth"}: use threading.active_count{.interpreted-text role="meth"}.
• typing.Text{.interpreted-text role="class"} (92332{.interpreted-text role="gh"}).
• The internal class typing._UnionGenericAlias is no longer used to implement typing.Union{.interpreted-text role="class"}. To preserve compatibility with users using this private class, a compatibility shim will be provided until at least Python 3.17. (Contributed by Jelle Zijlstra in 105499{.interpreted-text role="gh"}.)
• unittest.IsolatedAsyncioTestCase{.interpreted-text role="class"}: it is deprecated to return a value that is not None from a test case.
• urllib.parse{.interpreted-text role="mod"} deprecated functions: ~urllib.parse.urlparse{.interpreted-text role="func"} instead
  • splitattr()
  • splithost()
  • splitnport()
  • splitpasswd()
  • splitport()
  • splitquery()
  • splittag()
  • splittype()
  • splituser()
  • splitvalue()
  • to_bytes()
• wsgiref{.interpreted-text role="mod"}: SimpleHandler.stdout.write() should not do partial writes.
• xml.etree.ElementTree{.interpreted-text role="mod"}: Testing the truth value of an ~xml.etree.ElementTree.Element{.interpreted-text role="class"} is deprecated. In a future release it will always return True. Prefer explicit len(elem) or elem is not None tests instead.
• sys._clear_type_cache{.interpreted-text role="func"} is deprecated: use sys._clear_internal_caches{.interpreted-text role="func"} instead.

Removed {#whatsnew312-removed}

asynchat and asyncore

• These two modules have been removed according to the schedule in 594{.interpreted-text role="pep"}, having been deprecated in Python 3.6. Use asyncio{.interpreted-text role="mod"} instead. (Contributed by Nikita Sobolev in 96580{.interpreted-text role="gh"}.)

configparser

• Several names deprecated in the configparser{.interpreted-text role="mod"} way back in 3.2 have been removed per 89336{.interpreted-text role="gh"}:
  • configparser.ParsingError{.interpreted-text role="class"} no longer has a filename attribute or argument. Use the source attribute and argument instead.
  • configparser{.interpreted-text role="mod"} no longer has a SafeConfigParser class. Use the shorter ~configparser.ConfigParser{.interpreted-text role="class"} name instead.
  • configparser.ConfigParser{.interpreted-text role="class"} no longer has a readfp method. Use ~configparser.ConfigParser.read_file{.interpreted-text role="meth"} instead.

distutils {#whatsnew312-removed-distutils}

• Remove the !distutils{.interpreted-text role="py:mod"} package. It was deprecated in Python 3.10 by 632{.interpreted-text role="pep"} "Deprecate distutils module". For projects still using distutils and cannot be updated to something else, the setuptools project can be installed: it still provides distutils. (Contributed by Victor Stinner in 92584{.interpreted-text role="gh"}.)

ensurepip

• Remove the bundled setuptools wheel from ensurepip{.interpreted-text role="mod"}, and stop installing setuptools in environments created by venv{.interpreted-text role="mod"}.

  pip (>= 22.1) does not require setuptools to be installed in the environment. setuptools-based (and distutils-based) packages can still be used with pip install, since pip will provide setuptools in the build environment it uses for building a package.

  easy_install, pkg_resources, setuptools and distutils are no longer provided by default in environments created with venv or bootstrapped with ensurepip, since they are part of the setuptools package. For projects relying on these at runtime, the setuptools project should be declared as a dependency and installed separately (typically, using pip).

  (Contributed by Pradyun Gedam in 95299{.interpreted-text role="gh"}.)

enum

• Remove enum{.interpreted-text role="mod"}'s EnumMeta.__getattr__, which is no longer needed for enum attribute access. (Contributed by Ethan Furman in 95083{.interpreted-text role="gh"}.)

ftplib

• Remove ftplib{.interpreted-text role="mod"}'s FTP_TLS.ssl_version class attribute: use the context parameter instead. (Contributed by Victor Stinner in 94172{.interpreted-text role="gh"}.)

gzip

• Remove the filename attribute of gzip{.interpreted-text role="mod"}'s gzip.GzipFile{.interpreted-text role="class"}, deprecated since Python 2.6, use the ~gzip.GzipFile.name{.interpreted-text role="attr"} attribute instead. In write mode, the filename attribute added '.gz' file extension if it was not present. (Contributed by Victor Stinner in 94196{.interpreted-text role="gh"}.)

hashlib

• Remove the pure Python implementation of hashlib{.interpreted-text role="mod"}'s hashlib.pbkdf2_hmac{.interpreted-text role="func"}, deprecated in Python 3.10. Python 3.10 and newer requires OpenSSL 1.1.1 (644{.interpreted-text role="pep"}): this OpenSSL version provides a C implementation of ~hashlib.pbkdf2_hmac{.interpreted-text role="func"} which is faster. (Contributed by Victor Stinner in 94199{.interpreted-text role="gh"}.)

importlib

• Many previously deprecated cleanups in importlib{.interpreted-text role="mod"} have now been completed:
  • References to, and support for !module_repr{.interpreted-text role="meth"} has been removed. (Contributed by Barry Warsaw in 97850{.interpreted-text role="gh"}.)
  • importlib.util.set_package, importlib.util.set_loader and importlib.util.module_for_loader have all been removed. (Contributed by Brett Cannon and Nikita Sobolev in 65961{.interpreted-text role="gh"} and 97850{.interpreted-text role="gh"}.)
  • Support for find_loader() and find_module() APIs have been removed. (Contributed by Barry Warsaw in 98040{.interpreted-text role="gh"}.)
  • importlib.abc.Finder, pkgutil.ImpImporter, and pkgutil.ImpLoader have been removed. (Contributed by Barry Warsaw in 98040{.interpreted-text role="gh"}.)

imp {#whatsnew312-removed-imp}

• The !imp{.interpreted-text role="mod"} module has been removed. (Contributed by Barry Warsaw in 98040{.interpreted-text role="gh"}.)

  To migrate, consult the following correspondence table:

  imp importlib

  ---

  imp.NullImporter Insert None into sys.path_importer_cache imp.cache_from_source() importlib.util.cache_from_source{.interpreted-text role="func"} imp.find_module() importlib.util.find_spec{.interpreted-text role="func"} imp.get_magic() importlib.util.MAGIC_NUMBER{.interpreted-text role="const"} imp.get_suffixes() importlib.machinery.SOURCE_SUFFIXES{.interpreted-text role="const"}, importlib.machinery.EXTENSION_SUFFIXES{.interpreted-text role="const"}, and importlib.machinery.BYTECODE_SUFFIXES{.interpreted-text role="const"} imp.get_tag() sys.implementation.cache_tag <sys.implementation>{.interpreted-text role="attr"} imp.load_module() importlib.import_module{.interpreted-text role="func"} imp.new_module(name) types.ModuleType(name) imp.reload() importlib.reload{.interpreted-text role="func"} imp.source_from_cache() importlib.util.source_from_cache{.interpreted-text role="func"} imp.load_source() See below

  Replace imp.load_source() with:

  import importlib.util
  import importlib.machinery
  
  def load_source(modname, filename):
      loader = importlib.machinery.SourceFileLoader(modname, filename)
      spec = importlib.util.spec_from_file_location(modname, filename, loader=loader)
      module = importlib.util.module_from_spec(spec)
      # The module is always executed and not cached in sys.modules.
      # Uncomment the following line to cache the module.
      # sys.modules[module.__name__] = module
      loader.exec_module(module)
      return module
  

• Remove !imp{.interpreted-text role="mod"} functions and attributes with no replacements:

  • Undocumented functions:
    • imp.init_builtin()
    • imp.load_compiled()
    • imp.load_dynamic()
    • imp.load_package()
  • imp.lock_held(), imp.acquire_lock(), imp.release_lock(): the locking scheme has changed in Python 3.3 to per-module locks.
  • imp.find_module() constants: SEARCH_ERROR, PY_SOURCE, PY_COMPILED, C_EXTENSION, PY_RESOURCE, PKG_DIRECTORY, C_BUILTIN, PY_FROZEN, PY_CODERESOURCE, IMP_HOOK.

io

• Remove io{.interpreted-text role="mod"}'s io.OpenWrapper and _pyio.OpenWrapper, deprecated in Python 3.10: just use open{.interpreted-text role="func"} instead. The open{.interpreted-text role="func"} (io.open{.interpreted-text role="func"}) function is a built-in function. Since Python 3.10, !_pyio.open{.interpreted-text role="func"} is also a static method. (Contributed by Victor Stinner in 94169{.interpreted-text role="gh"}.)

locale

• Remove locale{.interpreted-text role="mod"}'s !locale.format{.interpreted-text role="func"} function, deprecated in Python 3.7: use locale.format_string{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in 94226{.interpreted-text role="gh"}.)

smtpd

• The smtpd module has been removed according to the schedule in 594{.interpreted-text role="pep"}, having been deprecated in Python 3.4.7 and 3.5.4. Use the aiosmtpd{.interpreted-text role="pypi"} PyPI module or any other asyncio{.interpreted-text role="mod"}-based server instead. (Contributed by Oleg Iarygin in 93243{.interpreted-text role="gh"}.)

sqlite3

• The following undocumented sqlite3{.interpreted-text role="mod"} features, deprecated in Python 3.10, are now removed:

  • sqlite3.enable_shared_cache()
  • sqlite3.OptimizedUnicode

  If a shared cache must be used, open the database in URI mode using the cache=shared query parameter.

  The sqlite3.OptimizedUnicode text factory has been an alias for str{.interpreted-text role="class"} since Python 3.3. Code that previously set the text factory to OptimizedUnicode can either use str explicitly, or rely on the default value which is also str.

  (Contributed by Erlend E. Aasland in 92548{.interpreted-text role="gh"}.)

ssl

• Remove ssl{.interpreted-text role="mod"}'s !ssl.RAND_pseudo_bytes{.interpreted-text role="func"} function, deprecated in Python 3.6: use os.urandom{.interpreted-text role="func"} or ssl.RAND_bytes{.interpreted-text role="func"} instead. (Contributed by Victor Stinner in 94199{.interpreted-text role="gh"}.)
• Remove the !ssl.match_hostname{.interpreted-text role="func"} function. It was deprecated in Python 3.7. OpenSSL performs hostname matching since Python 3.7, Python no longer uses the !ssl.match_hostname{.interpreted-text role="func"} function. (Contributed by Victor Stinner in 94199{.interpreted-text role="gh"}.)
• Remove the !ssl.wrap_socket{.interpreted-text role="func"} function, deprecated in Python 3.7: instead, create a ssl.SSLContext{.interpreted-text role="class"} object and call its ssl.SSLContext.wrap_socket{.interpreted-text role="class"} method. Any package that still uses !ssl.wrap_socket{.interpreted-text role="func"} is broken and insecure. The function neither sends a SNI TLS extension nor validates the server hostname. Code is subject to 295{.interpreted-text role="cwe"} (Improper Certificate Validation). (Contributed by Victor Stinner in 94199{.interpreted-text role="gh"}.)

unittest

• Remove many long-deprecated unittest{.interpreted-text role="mod"} features:

  ::: {#unittest-TestCase-removed-aliases}

  • A number of ~unittest.TestCase{.interpreted-text role="class"} method aliases:

    Deprecated alias Method Name Deprecated in

    ---

    failUnless .assertTrue{.interpreted-text role="meth"} 3.1 failIf .assertFalse{.interpreted-text role="meth"} 3.1 failUnlessEqual .assertEqual{.interpreted-text role="meth"} 3.1 failIfEqual .assertNotEqual{.interpreted-text role="meth"} 3.1 failUnlessAlmostEqual .assertAlmostEqual{.interpreted-text role="meth"} 3.1 failIfAlmostEqual .assertNotAlmostEqual{.interpreted-text role="meth"} 3.1 failUnlessRaises .assertRaises{.interpreted-text role="meth"} 3.1 assert_ .assertTrue{.interpreted-text role="meth"} 3.2 assertEquals .assertEqual{.interpreted-text role="meth"} 3.2 assertNotEquals .assertNotEqual{.interpreted-text role="meth"} 3.2 assertAlmostEquals .assertAlmostEqual{.interpreted-text role="meth"} 3.2 assertNotAlmostEquals .assertNotAlmostEqual{.interpreted-text role="meth"} 3.2 assertRegexpMatches .assertRegex{.interpreted-text role="meth"} 3.2 assertRaisesRegexp .assertRaisesRegex{.interpreted-text role="meth"} 3.2 assertNotRegexpMatches .assertNotRegex{.interpreted-text role="meth"} 3.5

    You can use https://github.com/isidentical/teyit to automatically modernise your unit tests.

  • Undocumented and broken ~unittest.TestCase{.interpreted-text role="class"} method assertDictContainsSubset (deprecated in Python 3.2).

  • Undocumented TestLoader.loadTestsFromModule <unittest.TestLoader.loadTestsFromModule>{.interpreted-text role="meth"} parameter use_load_tests (deprecated and ignored since Python 3.5).

  • An alias of the ~unittest.TextTestResult{.interpreted-text role="class"} class: _TextTestResult (deprecated in Python 3.2). :::

  (Contributed by Serhiy Storchaka in 89325{.interpreted-text role="gh"}.)

webbrowser

• Remove support for obsolete browsers from webbrowser{.interpreted-text role="mod"}. The removed browsers include: Grail, Mosaic, Netscape, Galeon, Skipstone, Iceape, Firebird, and Firefox versions 35 and below (102871{.interpreted-text role="gh"}).

xml.etree.ElementTree

• Remove the ElementTree.Element.copy() method of the pure Python implementation, deprecated in Python 3.10, use the copy.copy{.interpreted-text role="func"} function instead. The C implementation of xml.etree.ElementTree{.interpreted-text role="mod"} has no copy() method, only a __copy__() method. (Contributed by Victor Stinner in 94383{.interpreted-text role="gh"}.)

zipimport

• Remove zipimport{.interpreted-text role="mod"}'s find_loader() and find_module() methods, deprecated in Python 3.10: use the find_spec() method instead. See 451{.interpreted-text role="pep"} for the rationale. (Contributed by Victor Stinner in 94379{.interpreted-text role="gh"}.)

Others

• Remove the suspicious rule from the documentation Makefile{.interpreted-text role="file"} and Doc/tools/rstlint.py{.interpreted-text role="file"}, both in favor of sphinx-lint. (Contributed by Julien Palard in 98179{.interpreted-text role="gh"}.)
• Remove the keyfile and certfile parameters from the ftplib{.interpreted-text role="mod"}, imaplib{.interpreted-text role="mod"}, poplib{.interpreted-text role="mod"} and smtplib{.interpreted-text role="mod"} modules, and the key_file, cert_file and check_hostname parameters from the http.client{.interpreted-text role="mod"} module, all deprecated since Python 3.6. Use the context parameter (ssl_context in imaplib{.interpreted-text role="mod"}) instead. (Contributed by Victor Stinner in 94172{.interpreted-text role="gh"}.)
• Remove Jython compatibility hacks from several stdlib modules and tests. (Contributed by Nikita Sobolev in 99482{.interpreted-text role="gh"}.)
• Remove _use_broken_old_ctypes_structure_semantics_ flag from ctypes{.interpreted-text role="mod"} module. (Contributed by Nikita Sobolev in 99285{.interpreted-text role="gh"}.)

Porting to Python 3.12 {#whatsnew312-porting-to-python312}

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

Changes in the Python API

• More strict rules are now applied for numerical group references and group names in regular expressions. Only sequence of ASCII digits is now accepted as a numerical reference. The group name in bytes patterns and replacement strings can now only contain ASCII letters and digits and underscore. (Contributed by Serhiy Storchaka in 91760{.interpreted-text role="gh"}.)

• Remove randrange() functionality deprecated since Python 3.10. Formerly, randrange(10.0) losslessly converted to randrange(10). Now, it raises a TypeError{.interpreted-text role="exc"}. Also, the exception raised for non-integer values such as randrange(10.5) or randrange('10') has been changed from ValueError{.interpreted-text role="exc"} to TypeError{.interpreted-text role="exc"}. This also prevents bugs where randrange(1e25) would silently select from a larger range than randrange(10**25). (Originally suggested by Serhiy Storchaka 86388{.interpreted-text role="gh"}.)

• argparse.ArgumentParser{.interpreted-text role="class"} changed encoding and error handler for reading arguments from file (e.g. fromfile_prefix_chars option) from default text encoding (e.g. locale.getpreferredencoding(False) <locale.getpreferredencoding>{.interpreted-text role="func"}) to filesystem encoding and error handler{.interpreted-text role="term"}. Argument files should be encoded in UTF-8 instead of ANSI Codepage on Windows.

• Remove the asyncore-based smtpd module deprecated in Python 3.4.7 and 3.5.4. A recommended replacement is the asyncio{.interpreted-text role="mod"}-based aiosmtpd{.interpreted-text role="pypi"} PyPI module.

• shlex.split{.interpreted-text role="func"}: Passing None for s argument now raises an exception, rather than reading sys.stdin{.interpreted-text role="data"}. The feature was deprecated in Python 3.9. (Contributed by Victor Stinner in 94352{.interpreted-text role="gh"}.)

• The os{.interpreted-text role="mod"} module no longer accepts bytes-like paths, like bytearray{.interpreted-text role="class"} and memoryview{.interpreted-text role="class"} types: only the exact bytes{.interpreted-text role="class"} type is accepted for bytes strings. (Contributed by Victor Stinner in 98393{.interpreted-text role="gh"}.)

• syslog.openlog{.interpreted-text role="func"} and syslog.closelog{.interpreted-text role="func"} now fail if used in subinterpreters. syslog.syslog{.interpreted-text role="func"} may still be used in subinterpreters, but now only if syslog.openlog{.interpreted-text role="func"} has already been called in the main interpreter. These new restrictions do not apply to the main interpreter, so only a very small set of users might be affected. This change helps with interpreter isolation. Furthermore, syslog{.interpreted-text role="mod"} is a wrapper around process-global resources, which are best managed from the main interpreter. (Contributed by Donghee Na in 99127{.interpreted-text role="gh"}.)

• The undocumented locking behavior of ~functools.cached_property{.interpreted-text role="func"} is removed, because it locked across all instances of the class, leading to high lock contention. This means that a cached property getter function could now run more than once for a single instance, if two threads race. For most simple cached properties (e.g. those that are idempotent and simply calculate a value based on other attributes of the instance) this will be fine. If synchronization is needed, implement locking within the cached property getter function or around multi-threaded access points.

• sys._current_exceptions{.interpreted-text role="func"} now returns a mapping from thread-id to an exception instance, rather than to a (typ, exc, tb) tuple. (Contributed by Irit Katriel in 103176{.interpreted-text role="gh"}.)

• When extracting tar files using tarfile{.interpreted-text role="mod"} or shutil.unpack_archive{.interpreted-text role="func"}, pass the filter argument to limit features that may be surprising or dangerous. See tarfile-extraction-filter{.interpreted-text role="ref"} for details.

• The output of the tokenize.tokenize{.interpreted-text role="func"} and tokenize.generate_tokens{.interpreted-text role="func"} functions is now changed due to the changes introduced in 701{.interpreted-text role="pep"}. This means that STRING tokens are not emitted any more for f-strings and the tokens described in 701{.interpreted-text role="pep"} are now produced instead: FSTRING_START, FSTRING_MIDDLE and FSTRING_END are now emitted for f-string "string" parts in addition to the appropriate tokens for the tokenization in the expression components. For example for the f-string f"start {1+1} end" the old version of the tokenizer emitted:

  1,0-1,18:           STRING         'f"start {1+1} end"'
  

  while the new version emits:

  1,0-1,2:            FSTRING_START  'f"'
  1,2-1,8:            FSTRING_MIDDLE 'start '
  1,8-1,9:            OP             '{'
  1,9-1,10:           NUMBER         '1'
  1,10-1,11:          OP             '+'
  1,11-1,12:          NUMBER         '1'
  1,12-1,13:          OP             '}'
  1,13-1,17:          FSTRING_MIDDLE ' end'
  1,17-1,18:          FSTRING_END    '"'
  

  Additionally, there may be some minor behavioral changes as a consequence of the changes required to support 701{.interpreted-text role="pep"}. Some of these changes include:

  • The type attribute of the tokens emitted when tokenizing some invalid Python characters such as ! has changed from ERRORTOKEN to OP.
  • Incomplete single-line strings now also raise tokenize.TokenError{.interpreted-text role="exc"} as incomplete multiline strings do.
  • Some incomplete or invalid Python code now raises tokenize.TokenError{.interpreted-text role="exc"} instead of returning arbitrary ERRORTOKEN tokens when tokenizing it.
  • Mixing tabs and spaces as indentation in the same file is not supported anymore and will raise a TabError{.interpreted-text role="exc"}.

• The threading{.interpreted-text role="mod"} module now expects the !_thread{.interpreted-text role="mod"} module to have an _is_main_interpreter attribute. It is a function with no arguments that returns True if the current interpreter is the main interpreter.

  Any library or application that provides a custom _thread module should provide _is_main_interpreter(). (See 112826{.interpreted-text role="gh"}.)

Build Changes

• Python no longer uses setup.py{.interpreted-text role="file"} to build shared C extension modules. Build parameters like headers and libraries are detected in configure script. Extensions are built by Makefile{.interpreted-text role="file"}. Most extensions use pkg-config and fall back to manual detection. (Contributed by Christian Heimes in 93939{.interpreted-text role="gh"}.)

• va_start() with two parameters, like va_start(args, format), is now required to build Python. va_start() is no longer called with a single parameter. (Contributed by Kumar Aditya in 93207{.interpreted-text role="gh"}.)

• CPython now uses the ThinLTO option as the default link time optimization policy if the Clang compiler accepts the flag. (Contributed by Donghee Na in 89536{.interpreted-text role="gh"}.)

• Add COMPILEALL_OPTS variable in Makefile{.interpreted-text role="file"} to override compileall{.interpreted-text role="mod"} options (default: -j0) in make install. Also merged the 3 compileall commands into a single command to build .pyc files for all optimization levels (0, 1, 2) at once. (Contributed by Victor Stinner in 99289{.interpreted-text role="gh"}.)

• Add platform triplets for 64-bit LoongArch:

  • loongarch64-linux-gnusf
  • loongarch64-linux-gnuf32
  • loongarch64-linux-gnu

  (Contributed by Zhang Na in 90656{.interpreted-text role="gh"}.)

• PYTHON_FOR_REGEN now require Python 3.10 or newer.

• Autoconf 2.71 and aclocal 1.16.4 is now required to regenerate configure{.interpreted-text role="file"}. (Contributed by Christian Heimes in 89886{.interpreted-text role="gh"}.)

• Windows builds and macOS installers from python.org now use OpenSSL 3.0.

C API Changes

New Features

::: {#whatsnew312-pep697}

• 697{.interpreted-text role="pep"}: Introduce the Unstable C API tier <unstable-c-api>{.interpreted-text role="ref"}, intended for low-level tools like debuggers and JIT compilers. This API may change in each minor release of CPython without deprecation warnings. Its contents are marked by the PyUnstable_ prefix in names.

  Code object constructors:

  • PyUnstable_Code_New() (renamed from PyCode_New)
  • PyUnstable_Code_NewWithPosOnlyArgs() (renamed from PyCode_NewWithPosOnlyArgs)

  Extra storage for code objects (523{.interpreted-text role="pep"}):

  • PyUnstable_Eval_RequestCodeExtraIndex() (renamed from _PyEval_RequestCodeExtraIndex)
  • PyUnstable_Code_GetExtra() (renamed from _PyCode_GetExtra)
  • PyUnstable_Code_SetExtra() (renamed from _PyCode_SetExtra)

  The original names will continue to be available until the respective API changes.

  (Contributed by Petr Viktorin in 101101{.interpreted-text role="gh"}.)

• 697{.interpreted-text role="pep"}: Add an API for extending types whose instance memory layout is opaque:

  • PyType_Spec.basicsize{.interpreted-text role="c:member"} can be zero or negative to specify inheriting or extending the base class size.
  • PyObject_GetTypeData{.interpreted-text role="c:func"} and PyType_GetTypeDataSize{.interpreted-text role="c:func"} added to allow access to subclass-specific instance data.
  • Py_TPFLAGS_ITEMS_AT_END{.interpreted-text role="c:macro"} and PyObject_GetItemData{.interpreted-text role="c:func"} added to allow safely extending certain variable-sized types, including PyType_Type{.interpreted-text role="c:var"}.
  • Py_RELATIVE_OFFSET{.interpreted-text role="c:macro"} added to allow defining members <PyMemberDef>{.interpreted-text role="c:type"} in terms of a subclass-specific struct.

  (Contributed by Petr Viktorin in 103509{.interpreted-text role="gh"}.)

• Add the new limited C API <limited-c-api>{.interpreted-text role="ref"} function PyType_FromMetaclass{.interpreted-text role="c:func"}, which generalizes the existing PyType_FromModuleAndSpec{.interpreted-text role="c:func"} using an additional metaclass argument. (Contributed by Wenzel Jakob in 93012{.interpreted-text role="gh"}.)

• API for creating objects that can be called using the vectorcall protocol <vectorcall>{.interpreted-text role="ref"} was added to the Limited API <stable>{.interpreted-text role="ref"}:

  • Py_TPFLAGS_HAVE_VECTORCALL{.interpreted-text role="c:macro"}
  • PyVectorcall_NARGS{.interpreted-text role="c:func"}
  • PyVectorcall_Call{.interpreted-text role="c:func"}
  • vectorcallfunc{.interpreted-text role="c:type"}

  The Py_TPFLAGS_HAVE_VECTORCALL{.interpreted-text role="c:macro"} flag is now removed from a class when the class's ~object.__call__{.interpreted-text role="py:meth"} method is reassigned. This makes vectorcall safe to use with mutable types (i.e. heap types without the immutable flag, Py_TPFLAGS_IMMUTABLETYPE{.interpreted-text role="c:macro"}). Mutable types that do not override ~PyTypeObject.tp_call{.interpreted-text role="c:member"} now inherit the Py_TPFLAGS_HAVE_VECTORCALL flag. (Contributed by Petr Viktorin in 93274{.interpreted-text role="gh"}.)

  The Py_TPFLAGS_MANAGED_DICT{.interpreted-text role="c:macro"} and Py_TPFLAGS_MANAGED_WEAKREF{.interpreted-text role="c:macro"} flags have been added. This allows extensions classes to support object ~object.__dict__{.interpreted-text role="attr"} and weakrefs with less bookkeeping, using less memory and with faster access.

• API for performing calls using the vectorcall protocol <vectorcall>{.interpreted-text role="ref"} was added to the Limited API <stable>{.interpreted-text role="ref"}:

  • PyObject_Vectorcall{.interpreted-text role="c:func"}
  • PyObject_VectorcallMethod{.interpreted-text role="c:func"}
  • PY_VECTORCALL_ARGUMENTS_OFFSET{.interpreted-text role="c:macro"}

  This means that both the incoming and outgoing ends of the vector call protocol are now available in the Limited API <stable>{.interpreted-text role="ref"}. (Contributed by Wenzel Jakob in 98586{.interpreted-text role="gh"}.)

• Add two new public functions, PyEval_SetProfileAllThreads{.interpreted-text role="c:func"} and PyEval_SetTraceAllThreads{.interpreted-text role="c:func"}, that allow to set tracing and profiling functions in all running threads in addition to the calling one. (Contributed by Pablo Galindo in 93503{.interpreted-text role="gh"}.)

• Add new function PyFunction_SetVectorcall{.interpreted-text role="c:func"} to the C API which sets the vectorcall field of a given PyFunctionObject{.interpreted-text role="c:type"}. (Contributed by Andrew Frost in 92257{.interpreted-text role="gh"}.)

• The C API now permits registering callbacks via PyDict_AddWatcher{.interpreted-text role="c:func"}, PyDict_Watch{.interpreted-text role="c:func"} and related APIs to be called whenever a dictionary is modified. This is intended for use by optimizing interpreters, JIT compilers, or debuggers. (Contributed by Carl Meyer in 91052{.interpreted-text role="gh"}.)

• Add PyType_AddWatcher{.interpreted-text role="c:func"} and PyType_Watch{.interpreted-text role="c:func"} API to register callbacks to receive notification on changes to a type. (Contributed by Carl Meyer in 91051{.interpreted-text role="gh"}.)

• Add PyCode_AddWatcher{.interpreted-text role="c:func"} and PyCode_ClearWatcher{.interpreted-text role="c:func"} APIs to register callbacks to receive notification on creation and destruction of code objects. (Contributed by Itamar Oren in 91054{.interpreted-text role="gh"}.)

• Add PyFrame_GetVar{.interpreted-text role="c:func"} and PyFrame_GetVarString{.interpreted-text role="c:func"} functions to get a frame variable by its name. (Contributed by Victor Stinner in 91248{.interpreted-text role="gh"}.)

• Add PyErr_GetRaisedException{.interpreted-text role="c:func"} and PyErr_SetRaisedException{.interpreted-text role="c:func"} for saving and restoring the current exception. These functions return and accept a single exception object, rather than the triple arguments of the now-deprecated PyErr_Fetch{.interpreted-text role="c:func"} and PyErr_Restore{.interpreted-text role="c:func"}. This is less error prone and a bit more efficient. (Contributed by Mark Shannon in 101578{.interpreted-text role="gh"}.)

• Add _PyErr_ChainExceptions1, which takes an exception instance, to replace the legacy-API _PyErr_ChainExceptions, which is now deprecated. (Contributed by Mark Shannon in 101578{.interpreted-text role="gh"}.)

• Add PyException_GetArgs{.interpreted-text role="c:func"} and PyException_SetArgs{.interpreted-text role="c:func"} as convenience functions for retrieving and modifying the ~BaseException.args{.interpreted-text role="attr"} passed to the exception's constructor. (Contributed by Mark Shannon in 101578{.interpreted-text role="gh"}.)

• Add PyErr_DisplayException{.interpreted-text role="c:func"}, which takes an exception instance, to replace the legacy-api !PyErr_Display{.interpreted-text role="c:func"}. (Contributed by Irit Katriel in 102755{.interpreted-text role="gh"}). :::

::: {#whatsnew312-pep683}

• 683{.interpreted-text role="pep"}: Introduce Immortal Objects, which allows objects to bypass reference counts, and related changes to the C-API:

  -

  _Py_IMMORTAL_REFCNT: The reference count that defines an object

  : as immortal.

  • _Py_IsImmortal Checks if an object has the immortal reference count.

  • PyObject_HEAD_INIT This will now initialize reference count to

    : _Py_IMMORTAL_REFCNT when used with Py_BUILD_CORE.

  • SSTATE_INTERNED_IMMORTAL An identifier for interned unicode objects

    : that are immortal.

  • SSTATE_INTERNED_IMMORTAL_STATIC An identifier for interned unicode

    : objects that are immortal and static

  • sys.getunicodeinternedsize This returns the total number of unicode

    : objects that have been interned. This is now needed for refleak.py{.interpreted-text role="file"} to correctly track reference counts and allocated blocks

  (Contributed by Eddie Elizondo in 84436{.interpreted-text role="gh"}.)

• 684{.interpreted-text role="pep"}: Add the new Py_NewInterpreterFromConfig{.interpreted-text role="c:func"} function and PyInterpreterConfig{.interpreted-text role="c:type"}, which may be used to create sub-interpreters with their own GILs. (See whatsnew312-pep684{.interpreted-text role="ref"} for more info.) (Contributed by Eric Snow in 104110{.interpreted-text role="gh"}.)

• In the limited C API version 3.12, Py_INCREF{.interpreted-text role="c:func"} and Py_DECREF{.interpreted-text role="c:func"} functions are now implemented as opaque function calls to hide implementation details. (Contributed by Victor Stinner in 105387{.interpreted-text role="gh"}.) :::

Porting to Python 3.12

• Legacy Unicode APIs based on Py_UNICODE* representation has been removed. Please migrate to APIs based on UTF-8 or wchar_t*.

• Argument parsing functions like PyArg_ParseTuple{.interpreted-text role="c:func"} doesn't support Py_UNICODE* based format (e.g. u, Z) anymore. Please migrate to other formats for Unicode like s, z, es, and U.

• tp_weaklist for all static builtin types is always NULL. This is an internal-only field on PyTypeObject but we're pointing out the change in case someone happens to be accessing the field directly anyway. To avoid breakage, consider using the existing public C-API instead, or, if necessary, the (internal-only) _PyObject_GET_WEAKREFS_LISTPTR() macro.

• This internal-only PyTypeObject.tp_subclasses{.interpreted-text role="c:member"} may now not be a valid object pointer. Its type was changed to void *{.interpreted-text role="c:expr"} to reflect this. We mention this in case someone happens to be accessing the internal-only field directly.

  To get a list of subclasses, call the Python method ~type.__subclasses__{.interpreted-text role="py:meth"} (using PyObject_CallMethod{.interpreted-text role="c:func"}, for example).

• Add support of more formatting options (left aligning, octals, uppercase hexadecimals, intmax_t{.interpreted-text role="c:type"}, ptrdiff_t{.interpreted-text role="c:type"}, wchar_t{.interpreted-text role="c:type"} C strings, variable width and precision) in PyUnicode_FromFormat{.interpreted-text role="c:func"} and PyUnicode_FromFormatV{.interpreted-text role="c:func"}. (Contributed by Serhiy Storchaka in 98836{.interpreted-text role="gh"}.)

• An unrecognized format character in PyUnicode_FromFormat{.interpreted-text role="c:func"} and PyUnicode_FromFormatV{.interpreted-text role="c:func"} now sets a SystemError{.interpreted-text role="exc"}. In previous versions it caused all the rest of the format string to be copied as-is to the result string, and any extra arguments discarded. (Contributed by Serhiy Storchaka in 95781{.interpreted-text role="gh"}.)

• Fix wrong sign placement in PyUnicode_FromFormat{.interpreted-text role="c:func"} and PyUnicode_FromFormatV{.interpreted-text role="c:func"}. (Contributed by Philip Georgi in 95504{.interpreted-text role="gh"}.)

• Extension classes wanting to add a ~object.__dict__{.interpreted-text role="attr"} or weak reference slot should use Py_TPFLAGS_MANAGED_DICT{.interpreted-text role="c:macro"} and Py_TPFLAGS_MANAGED_WEAKREF{.interpreted-text role="c:macro"} instead of tp_dictoffset and tp_weaklistoffset, respectively. The use of tp_dictoffset and tp_weaklistoffset is still supported, but does not fully support multiple inheritance (95589{.interpreted-text role="gh"}), and performance may be worse. Classes declaring Py_TPFLAGS_MANAGED_DICT{.interpreted-text role="c:macro"} must call !_PyObject_VisitManagedDict{.interpreted-text role="c:func"} and !_PyObject_ClearManagedDict{.interpreted-text role="c:func"} to traverse and clear their instance's dictionaries. To clear weakrefs, call PyObject_ClearWeakRefs{.interpreted-text role="c:func"}, as before.

• The PyUnicode_FSDecoder{.interpreted-text role="c:func"} function no longer accepts bytes-like paths, like bytearray{.interpreted-text role="class"} and memoryview{.interpreted-text role="class"} types: only the exact bytes{.interpreted-text role="class"} type is accepted for bytes strings. (Contributed by Victor Stinner in 98393{.interpreted-text role="gh"}.)

• The Py_CLEAR{.interpreted-text role="c:macro"}, Py_SETREF{.interpreted-text role="c:macro"} and Py_XSETREF{.interpreted-text role="c:macro"} macros now only evaluate their arguments once. If an argument has side effects, these side effects are no longer duplicated. (Contributed by Victor Stinner in 98724{.interpreted-text role="gh"}.)

• The interpreter's error indicator is now always normalized. This means that PyErr_SetObject{.interpreted-text role="c:func"}, PyErr_SetString{.interpreted-text role="c:func"} and the other functions that set the error indicator now normalize the exception before storing it. (Contributed by Mark Shannon in 101578{.interpreted-text role="gh"}.)

• _Py_RefTotal is no longer authoritative and only kept around for ABI compatibility. Note that it is an internal global and only available on debug builds. If you happen to be using it then you'll need to start using _Py_GetGlobalRefTotal().

• The following functions now select an appropriate metaclass for the newly created type:

  • PyType_FromSpec{.interpreted-text role="c:func"}
  • PyType_FromSpecWithBases{.interpreted-text role="c:func"}
  • PyType_FromModuleAndSpec{.interpreted-text role="c:func"}

  Creating classes whose metaclass overrides ~PyTypeObject.tp_new{.interpreted-text role="c:member"} is deprecated, and in Python 3.14+ it will be disallowed. Note that these functions ignore tp_new of the metaclass, possibly allowing incomplete initialization.

  Note that PyType_FromMetaclass{.interpreted-text role="c:func"} (added in Python 3.12) already disallows creating classes whose metaclass overrides tp_new (~object.__new__{.interpreted-text role="meth"} in Python).

  Since tp_new overrides almost everything PyType_From* functions do, the two are incompatible with each other. The existing behavior -- ignoring the metaclass for several steps of type creation -- is unsafe in general, since (meta)classes assume that tp_new was called. There is no simple general workaround. One of the following may work for you:

  • If you control the metaclass, avoid using tp_new in it:
    • If initialization can be skipped, it can be done in ~PyTypeObject.tp_init{.interpreted-text role="c:member"} instead.
    • If the metaclass doesn't need to be instantiated from Python, set its tp_new to NULL using the Py_TPFLAGS_DISALLOW_INSTANTIATION{.interpreted-text role="c:macro"} flag. This makes it acceptable for PyType_From* functions.
  • Avoid PyType_From* functions: if you don't need C-specific features (slots or setting the instance size), create types by calling <call>{.interpreted-text role="ref"} the metaclass.
  • If you know the tp_new can be skipped safely, filter the deprecation warning out using warnings.catch_warnings{.interpreted-text role="func"} from Python.

• PyOS_InputHook{.interpreted-text role="c:var"} and PyOS_ReadlineFunctionPointer{.interpreted-text role="c:var"} are no longer called in subinterpreters <sub-interpreter-support>{.interpreted-text role="ref"}. This is because clients generally rely on process-wide global state (since these callbacks have no way of recovering extension module state).

  This also avoids situations where extensions may find themselves running in a subinterpreter that they don't support (or haven't yet been loaded in). See 104668{.interpreted-text role="gh"} for more info.

• PyLongObject{.interpreted-text role="c:struct"} has had its internals changed for better performance. Although the internals of PyLongObject{.interpreted-text role="c:struct"} are private, they are used by some extension modules. The internal fields should no longer be accessed directly, instead the API functions beginning PyLong_... should be used instead. Two new unstable API functions are provided for efficient access to the value of PyLongObject{.interpreted-text role="c:struct"}s which fit into a single machine word:

  • PyUnstable_Long_IsCompact{.interpreted-text role="c:func"}
  • PyUnstable_Long_CompactValue{.interpreted-text role="c:func"}

• Custom allocators, set via PyMem_SetAllocator{.interpreted-text role="c:func"}, are now required to be thread-safe, regardless of memory domain. Allocators that don't have their own state, including "hooks", are not affected. If your custom allocator is not already thread-safe and you need guidance then please create a new GitHub issue and CC @ericsnowcurrently.

Deprecated

• In accordance with 699{.interpreted-text role="pep"}, the ma_version_tag field in PyDictObject{.interpreted-text role="c:type"} is deprecated for extension modules. Accessing this field will generate a compiler warning at compile time. This field will be removed in Python 3.14. (Contributed by Ramvikrams and Kumar Aditya in 101193{.interpreted-text role="gh"}. PEP by Ken Jin.)

• Deprecate global configuration variable:

  • Py_DebugFlag{.interpreted-text role="c:var"}: use PyConfig.parser_debug{.interpreted-text role="c:member"}
  • Py_VerboseFlag{.interpreted-text role="c:var"}: use PyConfig.verbose{.interpreted-text role="c:member"}
  • Py_QuietFlag{.interpreted-text role="c:var"}: use PyConfig.quiet{.interpreted-text role="c:member"}
  • Py_InteractiveFlag{.interpreted-text role="c:var"}: use PyConfig.interactive{.interpreted-text role="c:member"}
  • Py_InspectFlag{.interpreted-text role="c:var"}: use PyConfig.inspect{.interpreted-text role="c:member"}
  • Py_OptimizeFlag{.interpreted-text role="c:var"}: use PyConfig.optimization_level{.interpreted-text role="c:member"}
  • Py_NoSiteFlag{.interpreted-text role="c:var"}: use PyConfig.site_import{.interpreted-text role="c:member"}
  • Py_BytesWarningFlag{.interpreted-text role="c:var"}: use PyConfig.bytes_warning{.interpreted-text role="c:member"}
  • Py_FrozenFlag{.interpreted-text role="c:var"}: use PyConfig.pathconfig_warnings{.interpreted-text role="c:member"}
  • Py_IgnoreEnvironmentFlag{.interpreted-text role="c:var"}: use PyConfig.use_environment{.interpreted-text role="c:member"}
  • Py_DontWriteBytecodeFlag{.interpreted-text role="c:var"}: use PyConfig.write_bytecode{.interpreted-text role="c:member"}
  • Py_NoUserSiteDirectory{.interpreted-text role="c:var"}: use PyConfig.user_site_directory{.interpreted-text role="c:member"}
  • Py_UnbufferedStdioFlag{.interpreted-text role="c:var"}: use PyConfig.buffered_stdio{.interpreted-text role="c:member"}
  • Py_HashRandomizationFlag{.interpreted-text role="c:var"}: use PyConfig.use_hash_seed{.interpreted-text role="c:member"} and PyConfig.hash_seed{.interpreted-text role="c:member"}
  • Py_IsolatedFlag{.interpreted-text role="c:var"}: use PyConfig.isolated{.interpreted-text role="c:member"}
  • Py_LegacyWindowsFSEncodingFlag{.interpreted-text role="c:var"}: use PyPreConfig.legacy_windows_fs_encoding{.interpreted-text role="c:member"}
  • Py_LegacyWindowsStdioFlag{.interpreted-text role="c:var"}: use PyConfig.legacy_windows_stdio{.interpreted-text role="c:member"}
  • !Py_FileSystemDefaultEncoding{.interpreted-text role="c:var"}: use PyConfig.filesystem_encoding{.interpreted-text role="c:member"}
  • !Py_HasFileSystemDefaultEncoding{.interpreted-text role="c:var"}: use PyConfig.filesystem_encoding{.interpreted-text role="c:member"}
  • !Py_FileSystemDefaultEncodeErrors{.interpreted-text role="c:var"}: use PyConfig.filesystem_errors{.interpreted-text role="c:member"}
  • !Py_UTF8Mode{.interpreted-text role="c:var"}: use PyPreConfig.utf8_mode{.interpreted-text role="c:member"} (see Py_PreInitialize{.interpreted-text role="c:func"})

  The Py_InitializeFromConfig{.interpreted-text role="c:func"} API should be used with PyConfig{.interpreted-text role="c:type"} instead. (Contributed by Victor Stinner in 77782{.interpreted-text role="gh"}.)

• Creating immutable types <Py_TPFLAGS_IMMUTABLETYPE>{.interpreted-text role="c:data"} with mutable bases is deprecated and will be disabled in Python 3.14. (95388{.interpreted-text role="gh"})

• The structmember.h{.interpreted-text role="file"} header is deprecated, though it continues to be available and there are no plans to remove it.

  Its contents are now available just by including Python.h{.interpreted-text role="file"}, with a Py prefix added if it was missing:

  • PyMemberDef{.interpreted-text role="c:struct"}, PyMember_GetOne{.interpreted-text role="c:func"} and PyMember_SetOne{.interpreted-text role="c:func"}
  • Type macros like Py_T_INT{.interpreted-text role="c:macro"}, Py_T_DOUBLE{.interpreted-text role="c:macro"}, etc. (previously T_INT, T_DOUBLE, etc.)
  • The flags Py_READONLY{.interpreted-text role="c:macro"} (previously READONLY) and Py_AUDIT_READ{.interpreted-text role="c:macro"} (previously all uppercase)

  Several items are not exposed from Python.h{.interpreted-text role="file"}:

  • T_OBJECT{.interpreted-text role="c:macro"} (use Py_T_OBJECT_EX{.interpreted-text role="c:macro"})
  • T_NONE{.interpreted-text role="c:macro"} (previously undocumented, and pretty quirky)
  • The macro WRITE_RESTRICTED which does nothing.
  • The macros RESTRICTED and READ_RESTRICTED, equivalents of Py_AUDIT_READ{.interpreted-text role="c:macro"}.
  • In some configurations, <stddef.h> is not included from Python.h{.interpreted-text role="file"}. It should be included manually when using offsetof().

  The deprecated header continues to provide its original contents under the original names. Your old code can stay unchanged, unless the extra include and non-namespaced macros bother you greatly.

  (Contributed in 47146{.interpreted-text role="gh"} by Petr Viktorin, based on earlier work by Alexander Belopolsky and Matthias Braun.)

• PyErr_Fetch{.interpreted-text role="c:func"} and PyErr_Restore{.interpreted-text role="c:func"} are deprecated. Use PyErr_GetRaisedException{.interpreted-text role="c:func"} and PyErr_SetRaisedException{.interpreted-text role="c:func"} instead. (Contributed by Mark Shannon in 101578{.interpreted-text role="gh"}.)

• !PyErr_Display{.interpreted-text role="c:func"} is deprecated. Use PyErr_DisplayException{.interpreted-text role="c:func"} instead. (Contributed by Irit Katriel in 102755{.interpreted-text role="gh"}).

• _PyErr_ChainExceptions is deprecated. Use _PyErr_ChainExceptions1 instead. (Contributed by Irit Katriel in 102192{.interpreted-text role="gh"}.)

• Using PyType_FromSpec{.interpreted-text role="c:func"}, PyType_FromSpecWithBases{.interpreted-text role="c:func"} or PyType_FromModuleAndSpec{.interpreted-text role="c:func"} to create a class whose metaclass overrides ~PyTypeObject.tp_new{.interpreted-text role="c:member"} is deprecated. Call the metaclass instead.

Pending removal in Python 3.14

• The ma_version_tag field in PyDictObject{.interpreted-text role="c:type"} for extension modules (699{.interpreted-text role="pep"}; 101193{.interpreted-text role="gh"}).
• Creating immutable types <Py_TPFLAGS_IMMUTABLETYPE>{.interpreted-text role="c:data"} with mutable bases (95388{.interpreted-text role="gh"}).

Pending removal in Python 3.15

• The !PyImport_ImportModuleNoBlock{.interpreted-text role="c:func"}: Use PyImport_ImportModule{.interpreted-text role="c:func"} instead.

• !PyWeakref_GetObject{.interpreted-text role="c:func"} and !PyWeakref_GET_OBJECT{.interpreted-text role="c:func"}: Use PyWeakref_GetRef{.interpreted-text role="c:func"} instead. The pythoncapi-compat project can be used to get PyWeakref_GetRef{.interpreted-text role="c:func"} on Python 3.12 and older.

• Py_UNICODE{.interpreted-text role="c:type"} type and the !Py_UNICODE_WIDE{.interpreted-text role="c:macro"} macro: Use wchar_t{.interpreted-text role="c:type"} instead.

• !PyUnicode_AsDecodedObject{.interpreted-text role="c:func"}: Use PyCodec_Decode{.interpreted-text role="c:func"} instead.

• !PyUnicode_AsDecodedUnicode{.interpreted-text role="c:func"}: Use PyCodec_Decode{.interpreted-text role="c:func"} instead; Note that some codecs (for example, "base64") may return a type other than str{.interpreted-text role="class"}, such as bytes{.interpreted-text role="class"}.

• !PyUnicode_AsEncodedObject{.interpreted-text role="c:func"}: Use PyCodec_Encode{.interpreted-text role="c:func"} instead.

• !PyUnicode_AsEncodedUnicode{.interpreted-text role="c:func"}: Use PyCodec_Encode{.interpreted-text role="c:func"} instead; Note that some codecs (for example, "base64") may return a type other than bytes{.interpreted-text role="class"}, such as str{.interpreted-text role="class"}.

• Python initialization functions, deprecated in Python 3.13:

  • !Py_GetPath{.interpreted-text role="c:func"}: Use PyConfig_Get("module_search_paths") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.path{.interpreted-text role="data"}) instead.
  • !Py_GetPrefix{.interpreted-text role="c:func"}: Use PyConfig_Get("base_prefix") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.base_prefix{.interpreted-text role="data"}) instead. Use PyConfig_Get("prefix") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.prefix{.interpreted-text role="data"}) if virtual environments <venv-def>{.interpreted-text role="ref"} need to be handled.
  • !Py_GetExecPrefix{.interpreted-text role="c:func"}: Use PyConfig_Get("base_exec_prefix") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.base_exec_prefix{.interpreted-text role="data"}) instead. Use PyConfig_Get("exec_prefix") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.exec_prefix{.interpreted-text role="data"}) if virtual environments <venv-def>{.interpreted-text role="ref"} need to be handled.
  • !Py_GetProgramFullPath{.interpreted-text role="c:func"}: Use PyConfig_Get("executable") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.executable{.interpreted-text role="data"}) instead.
  • !Py_GetProgramName{.interpreted-text role="c:func"}: Use PyConfig_Get("executable") <PyConfig_Get>{.interpreted-text role="c:func"} (sys.executable{.interpreted-text role="data"}) instead.
  • !Py_GetPythonHome{.interpreted-text role="c:func"}: Use PyConfig_Get("home") <PyConfig_Get>{.interpreted-text role="c:func"} or the PYTHONHOME{.interpreted-text role="envvar"} environment variable instead.

  The pythoncapi-compat project can be used to get PyConfig_Get{.interpreted-text role="c:func"} on Python 3.13 and older.

• Functions to configure Python's initialization, deprecated in Python 3.11:

  • !PySys_SetArgvEx(){.interpreted-text role="c:func"}: Set PyConfig.argv{.interpreted-text role="c:member"} instead.
  • !PySys_SetArgv(){.interpreted-text role="c:func"}: Set PyConfig.argv{.interpreted-text role="c:member"} instead.
  • !Py_SetProgramName(){.interpreted-text role="c:func"}: Set PyConfig.program_name{.interpreted-text role="c:member"} instead.
  • !Py_SetPythonHome(){.interpreted-text role="c:func"}: Set PyConfig.home{.interpreted-text role="c:member"} instead.
  • !PySys_ResetWarnOptions{.interpreted-text role="c:func"}: Clear sys.warnoptions{.interpreted-text role="data"} and !warnings.filters{.interpreted-text role="data"} instead.

  The Py_InitializeFromConfig{.interpreted-text role="c:func"} API should be used with PyConfig{.interpreted-text role="c:type"} instead.

• Global configuration variables:

  • Py_DebugFlag{.interpreted-text role="c:var"}: Use PyConfig.parser_debug{.interpreted-text role="c:member"} or PyConfig_Get("parser_debug") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_VerboseFlag{.interpreted-text role="c:var"}: Use PyConfig.verbose{.interpreted-text role="c:member"} or PyConfig_Get("verbose") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_QuietFlag{.interpreted-text role="c:var"}: Use PyConfig.quiet{.interpreted-text role="c:member"} or PyConfig_Get("quiet") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_InteractiveFlag{.interpreted-text role="c:var"}: Use PyConfig.interactive{.interpreted-text role="c:member"} or PyConfig_Get("interactive") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_InspectFlag{.interpreted-text role="c:var"}: Use PyConfig.inspect{.interpreted-text role="c:member"} or PyConfig_Get("inspect") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_OptimizeFlag{.interpreted-text role="c:var"}: Use PyConfig.optimization_level{.interpreted-text role="c:member"} or PyConfig_Get("optimization_level") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_NoSiteFlag{.interpreted-text role="c:var"}: Use PyConfig.site_import{.interpreted-text role="c:member"} or PyConfig_Get("site_import") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_BytesWarningFlag{.interpreted-text role="c:var"}: Use PyConfig.bytes_warning{.interpreted-text role="c:member"} or PyConfig_Get("bytes_warning") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_FrozenFlag{.interpreted-text role="c:var"}: Use PyConfig.pathconfig_warnings{.interpreted-text role="c:member"} or PyConfig_Get("pathconfig_warnings") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_IgnoreEnvironmentFlag{.interpreted-text role="c:var"}: Use PyConfig.use_environment{.interpreted-text role="c:member"} or PyConfig_Get("use_environment") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_DontWriteBytecodeFlag{.interpreted-text role="c:var"}: Use PyConfig.write_bytecode{.interpreted-text role="c:member"} or PyConfig_Get("write_bytecode") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_NoUserSiteDirectory{.interpreted-text role="c:var"}: Use PyConfig.user_site_directory{.interpreted-text role="c:member"} or PyConfig_Get("user_site_directory") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_UnbufferedStdioFlag{.interpreted-text role="c:var"}: Use PyConfig.buffered_stdio{.interpreted-text role="c:member"} or PyConfig_Get("buffered_stdio") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_HashRandomizationFlag{.interpreted-text role="c:var"}: Use PyConfig.use_hash_seed{.interpreted-text role="c:member"} and PyConfig.hash_seed{.interpreted-text role="c:member"} or PyConfig_Get("hash_seed") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_IsolatedFlag{.interpreted-text role="c:var"}: Use PyConfig.isolated{.interpreted-text role="c:member"} or PyConfig_Get("isolated") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_LegacyWindowsFSEncodingFlag{.interpreted-text role="c:var"}: Use PyPreConfig.legacy_windows_fs_encoding{.interpreted-text role="c:member"} or PyConfig_Get("legacy_windows_fs_encoding") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • Py_LegacyWindowsStdioFlag{.interpreted-text role="c:var"}: Use PyConfig.legacy_windows_stdio{.interpreted-text role="c:member"} or PyConfig_Get("legacy_windows_stdio") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • !Py_FileSystemDefaultEncoding{.interpreted-text role="c:var"}, !Py_HasFileSystemDefaultEncoding{.interpreted-text role="c:var"}: Use PyConfig.filesystem_encoding{.interpreted-text role="c:member"} or PyConfig_Get("filesystem_encoding") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • !Py_FileSystemDefaultEncodeErrors{.interpreted-text role="c:var"}: Use PyConfig.filesystem_errors{.interpreted-text role="c:member"} or PyConfig_Get("filesystem_errors") <PyConfig_Get>{.interpreted-text role="c:func"} instead.
  • !Py_UTF8Mode{.interpreted-text role="c:var"}: Use PyPreConfig.utf8_mode{.interpreted-text role="c:member"} or PyConfig_Get("utf8_mode") <PyConfig_Get>{.interpreted-text role="c:func"} instead. (see Py_PreInitialize{.interpreted-text role="c:func"})

  The Py_InitializeFromConfig{.interpreted-text role="c:func"} API should be used with PyConfig{.interpreted-text role="c:type"} to set these options. Or PyConfig_Get{.interpreted-text role="c:func"} can be used to get these options at runtime.

Pending removal in Python 3.16

• The bundled copy of libmpdec.

Pending removal in future versions

The following APIs are deprecated and will be removed, although there is currently no date scheduled for their removal.

• Py_TPFLAGS_HAVE_FINALIZE{.interpreted-text role="c:macro"}: Unneeded since Python 3.8.
• PyErr_Fetch{.interpreted-text role="c:func"}: Use PyErr_GetRaisedException{.interpreted-text role="c:func"} instead.
• PyErr_NormalizeException{.interpreted-text role="c:func"}: Use PyErr_GetRaisedException{.interpreted-text role="c:func"} instead.
• PyErr_Restore{.interpreted-text role="c:func"}: Use PyErr_SetRaisedException{.interpreted-text role="c:func"} instead.
• PyModule_GetFilename{.interpreted-text role="c:func"}: Use PyModule_GetFilenameObject{.interpreted-text role="c:func"} instead.
• PyOS_AfterFork{.interpreted-text role="c:func"}: Use PyOS_AfterFork_Child{.interpreted-text role="c:func"} instead.
• PySlice_GetIndicesEx{.interpreted-text role="c:func"}: Use PySlice_Unpack{.interpreted-text role="c:func"} and PySlice_AdjustIndices{.interpreted-text role="c:func"} instead.
• PyUnicode_READY{.interpreted-text role="c:func"}: Unneeded since Python 3.12
• !PyErr_Display{.interpreted-text role="c:func"}: Use PyErr_DisplayException{.interpreted-text role="c:func"} instead.
• !_PyErr_ChainExceptions{.interpreted-text role="c:func"}: Use !_PyErr_ChainExceptions1{.interpreted-text role="c:func"} instead.
• !PyBytesObject.ob_shash{.interpreted-text role="c:member"} member: call PyObject_Hash{.interpreted-text role="c:func"} instead.
• Thread Local Storage (TLS) API:
  • PyThread_create_key{.interpreted-text role="c:func"}: Use PyThread_tss_alloc{.interpreted-text role="c:func"} instead.
  • PyThread_delete_key{.interpreted-text role="c:func"}: Use PyThread_tss_free{.interpreted-text role="c:func"} instead.
  • PyThread_set_key_value{.interpreted-text role="c:func"}: Use PyThread_tss_set{.interpreted-text role="c:func"} instead.
  • PyThread_get_key_value{.interpreted-text role="c:func"}: Use PyThread_tss_get{.interpreted-text role="c:func"} instead.
  • PyThread_delete_key_value{.interpreted-text role="c:func"}: Use PyThread_tss_delete{.interpreted-text role="c:func"} instead.
  • PyThread_ReInitTLS{.interpreted-text role="c:func"}: Unneeded since Python 3.7.

Removed

• Remove the token.h{.interpreted-text role="file"} header file. There was never any public tokenizer C API. The token.h{.interpreted-text role="file"} header file was only designed to be used by Python internals. (Contributed by Victor Stinner in 92651{.interpreted-text role="gh"}.)
• Legacy Unicode APIs have been removed. See 623{.interpreted-text role="pep"} for detail.
  • !PyUnicode_WCHAR_KIND{.interpreted-text role="c:macro"}
  • !PyUnicode_AS_UNICODE{.interpreted-text role="c:func"}
  • !PyUnicode_AsUnicode{.interpreted-text role="c:func"}
  • !PyUnicode_AsUnicodeAndSize{.interpreted-text role="c:func"}
  • !PyUnicode_AS_DATA{.interpreted-text role="c:func"}
  • !PyUnicode_FromUnicode{.interpreted-text role="c:func"}
  • !PyUnicode_GET_SIZE{.interpreted-text role="c:func"}
  • !PyUnicode_GetSize{.interpreted-text role="c:func"}
  • !PyUnicode_GET_DATA_SIZE{.interpreted-text role="c:func"}
• Remove the PyUnicode_InternImmortal() function macro. (Contributed by Victor Stinner in 85858{.interpreted-text role="gh"}.)