What's new in Python 3.15

Editor
Hugo van Kemenade

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

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.15, compared to 3.14. Python 3.15 was released on 9 October 2026. For full details, see the changelog <changelog>.

Summary -- Release highlights

Python 3.15 is the latest stable release of the Python programming language, with a mix of changes to the language, the implementation, and the standard library. The biggest changes include lazy imports <whatsnew315-lazy-imports>, frozendict <whatsnew315-frozendict> and sentinel <whatsnew315-sentinel> builtins, UTF-8 as the default encoding <whatsnew315-utf8-default>, unpacking in comprehensions <whatsnew315-unpacking-in-comprehensions>, and a stable ABI for free-threaded builds <whatsnew315-abi3t>.

The library changes include a new profiling package <whatsnew315-profiling-package> with Tachyon <whatsnew315-sampling-profiler>, a high-frequency statistical sampling profiler, more color <whatsnew315-more-color> in command-line output, as well as the usual deprecations and removals, and improvements in user-friendliness and correctness.

This article doesn't attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details refer to the documentation, such as the Library Reference <library-index> and Language Reference <reference-index>. 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.

See Porting to Python 3.15 for guidance on upgrading from earlier versions of Python.

---

Interpreter improvements:

• 661: Add sentinel built-in type <whatsnew315-sentinel>
• 686: Python now uses UTF-8 as the default encoding <whatsnew315-utf8-default>
• 798: Unpacking in comprehensions <whatsnew315-unpacking-in-comprehensions>
• 810: Explicit lazy imports for faster startup times <whatsnew315-lazy-imports>
• 814: Add frozendict built-in type <whatsnew315-frozendict>
• 829: Package startup configuration files <whatsnew315-startup-files>
• The experimental JIT compiler has been significantly upgraded <whatsnew315-jit>
• Improved error messages <whatsnew315-improved-error-messages>

Significant improvements in the standard library:

• 799: A dedicated profiling package for organizing Python profiling tools <whatsnew315-profiling-package>
• 799: Tachyon: High-frequency statistical sampling profiler <whatsnew315-sampling-profiler>
• More color <whatsnew315-more-color>

New typing features:

• 728: TypedDict with typed extra items <whatsnew315-typeddict>
• 747: Annotating type forms with TypeForm <whatsnew315-typeform>
• 800: Disjoint bases in the type system <whatsnew315-disjoint-base>

C API improvements:

• 782: A new PyBytesWriter C API to create a Python bytes object <whatsnew315-pybyteswriter>
• 788: Protection against finalization in the C API <whatsnew315-c-api-interpreter-finalization>
• 803, 820 <820>, 793 <793>: Stable ABI for free-threaded builds <whatsnew315-abi3t> and related C API

Build changes:

• 831: Frame pointers are enabled by default for improved system-level observability <whatsnew315-frame-pointers>

Release changes:

• The official Windows 64-bit binaries now use the tail-calling interpreter <whatsnew315-windows-tail-calling-interpreter>
• The official macOS binaries now install free-threading support by default

New features

810: Explicit lazy imports

Large Python applications often suffer from slow startup times. A significant contributor to this problem is the import system: when a module is imported, Python must locate the file, read it from disk, compile it to bytecode, and execute all top-level code. For applications with deep dependency trees, this process can take seconds, even when most of the imported code is never actually used during a particular run.

Developers have worked around this by moving imports inside functions, using importlib to load modules on demand, or restructuring code to avoid unnecessary dependencies. These approaches work but make code harder to read and maintain, scatter import statements throughout the codebase, and require discipline to apply consistently.

Python now provides a cleaner solution through explicit lazy imports using the new lazy soft keyword. When you mark an import as lazy, Python defers the actual module loading until the imported name is first used. This gives you the organizational benefits of declaring all imports at the top of the file while only paying the loading cost for modules you actually use.

The lazy keyword works with both import and from ... import statements. When you write lazy import heavy_module, Python does not immediately load the module. Instead, it creates a lightweight proxy object. The actual module loading happens transparently when you first access the name:

lazy import json
lazy from pathlib import Path

print("Starting up...")  # json and pathlib are not fully imported yet

data = json.loads('{"key": "value"}')  # json gets fully imported here
p = Path(".")  # pathlib gets fully imported here

This mechanism is particularly useful for applications that import many modules at the top level but may only use a subset of them in any given run. The deferred loading reduces startup latency without requiring code restructuring or conditional imports scattered throughout the codebase.

In the case where loading a lazily imported module fails (for example, if the module does not exist), Python raises the exception at the point of first use rather than at import time. The associated traceback includes both the location where the name was accessed and the original import statement, making it straightforward to diagnose and debug the failure.

For cases where you want to enable lazy loading globally without modifying source code, Python provides the -X lazy_imports <-X> command-line option and the PYTHON_LAZY_IMPORTS environment variable. Both accept two values: all makes all imports lazy by default, and normal (the default) respects the lazy keyword in source code. The sys.set_lazy_imports and sys.get_lazy_imports functions allow changing and querying this mode at runtime.

For more selective control, sys.set_lazy_imports_filter accepts a callable that determines whether a specific module should be loaded lazily. The filter receives three arguments: the importing module's name (or None), the imported module's name, and the fromlist (or None for regular imports). It should return True to allow the import to be lazy, or False to force eager loading. This allows patterns like making only your own application's modules lazy while keeping third-party dependencies eager:

import sys

def myapp_filter(importing, imported, fromlist):
    return imported.startswith("myapp.")
sys.set_lazy_imports_filter(myapp_filter)
sys.set_lazy_imports("all")

import myapp.slow_module  # lazy (matches filter)
import json               # eager (does not match filter)

The proxy type itself is available as types.LazyImportType for code that needs to detect lazy imports programmatically.

There are some restrictions on where the lazy keyword can be used. Lazy imports are only permitted at module scope; using lazy inside a function, class body, or try/except/finally block raises a SyntaxError. Neither star imports nor future imports can be lazy (lazy from module import * and lazy from __future__ import ... both raise SyntaxError).

For code that cannot use the lazy keyword directly (for example, when supporting Python versions older than 3.15 while still using lazy imports on 3.15+), a module can define ~module.__lazy_modules__ as a container of fully qualified module name strings. Regular import statements for those modules are then treated as lazy, with the same semantics as the lazy keyword:

__lazy_modules__ = ["json", "pathlib"]

import json     # lazy
import os       # still eager

(Contributed by Pablo Galindo Salgado and Dino Viehland in 142349.)

814: Add frozendict built-in type

A new immutable type, frozendict, is added to the builtins module. It does not allow modification after creation. A !frozendict is not a subclass of dict; it inherits directly from object. A !frozendict is hashable as long as all of its keys and values are hashable. A !frozendict preserves insertion order, but comparison does not take order into account.

For example:

>>> a = frozendict(x=1, y=2)
>>> a
frozendict({'x': 1, 'y': 2})
>>> a['z'] = 3
Traceback (most recent call last):
  File "<python-input-2>", line 1, in <module>
    a['z'] = 3
    ~^^^^^
TypeError: 'frozendict' object does not support item assignment
>>> b = frozendict(y=2, x=1)
>>> hash(a) == hash(b)
True
>>> a == b
True

The following standard library modules have been updated to accept !frozendict: copy, decimal, json, marshal, plistlib (only for serialization), pickle, pprint and xml.etree.ElementTree.

eval and exec accept !frozendict for globals, and type and str.maketrans accept !frozendict for dict.

Code checking for dict type using isinstance(arg, dict) can be updated to isinstance(arg, (dict, frozendict)) to accept also the !frozendict type, or to isinstance(arg, collections.abc.Mapping) to accept also other mapping types such as ~types.MappingProxyType.

(Contributed by Victor Stinner and Donghee Na in 141510.)

661: Add sentinel built-in type

A new sentinel type is added to the builtins module for creating unique sentinel values with a concise representation. Sentinel objects preserve identity when copied, support use in type expressions with the | operator, and can be pickled when they are importable by module and name.

(Contributed by Jelle Zijlstra in 148829; PEP 661 written by Tal Einat.)

799: A dedicated profiling package

A new profiling module has been added to organize Python's built-in profiling tools under a single, coherent namespace. This module contains:

• profiling.tracing: deterministic function-call tracing (relocated from cProfile).
• profiling.sampling: a new statistical sampling profiler (named Tachyon).

The cProfile module remains as an alias for backwards compatibility. The profile module is deprecated and will be removed in Python 3.17.

(Contributed by Pablo Galindo and László Kiss Kollár in 138122.)

Tachyon: High-frequency statistical sampling profiler

A new statistical sampling profiler (Tachyon) has been added as profiling.sampling. This profiler enables low-overhead performance analysis of running Python processes without requiring code modification or process restart.

Unlike deterministic profilers (such as profiling.tracing) that instrument every function call, the sampling profiler periodically captures stack traces from running processes. This approach provides virtually zero overhead while achieving sampling rates of up to 1,000,000 Hz, making it the fastest sampling profiler available for Python (at the time of its contribution) and ideal for debugging performance issues in production environments. This capability is particularly valuable for debugging performance issues in production systems where traditional profiling approaches would be too intrusive.

Key features include:

• Zero-overhead profiling: Attach to any running Python process without affecting its performance. Ideal for production debugging where you can't afford to restart or slow down your application.
• No code modification required: Profile existing applications without restart. Simply point the profiler at a running process by PID and start collecting data.
• Flexible target modes:
  • Profile running processes by PID (attach) - attach to already-running applications
  • Run and profile scripts directly (run) - profile from the very start of execution
  • Execute and profile modules (run -m) - profile packages run as python -m module
  • Capture a one-shot snapshot of a running process (dump) - print a traceback-style stack of every thread (or all asyncio tasks with --async-aware). Useful for investigating hung processes.
• Multiple profiling modes: Choose what to measure based on your performance investigation:
  • Wall-clock time (--mode wall, default): Measures real elapsed time including I/O, network waits, and blocking operations. Use this to understand where your program spends calendar time, including when waiting for external resources.
  • CPU time (--mode cpu): Measures only active CPU execution time, excluding I/O waits and blocking. Use this to identify CPU-bound bottlenecks and optimize computational work.
  • GIL-holding time (--mode gil): Measures time spent holding Python's Global Interpreter Lock. Use this to identify which threads dominate GIL usage in multi-threaded applications.
  • Exception handling time (--mode exception): Captures samples only from threads with an active exception. Use this to analyze exception handling overhead.
• Thread-aware profiling: Option to profile all threads (-a) or just the main thread, essential for understanding multi-threaded application behavior.
• Multiple output formats: Choose the visualization that best fits your workflow:
  • --pstats: Detailed tabular statistics compatible with pstats. Shows function-level timing with direct and cumulative samples. Best for detailed analysis and integration with existing Python profiling tools.
  • --collapsed: Generates collapsed stack traces (one line per stack). This format is specifically designed for creating flame graphs with external tools like Brendan Gregg's FlameGraph scripts or speedscope.
  • --flamegraph: Generates a self-contained interactive HTML flame graph using D3.js. Opens directly in your browser for immediate visual analysis. Flame graphs show the call hierarchy where width represents time spent, making it easy to spot bottlenecks at a glance.
  • --gecko: Generates Gecko Profiler format compatible with Firefox Profiler. Upload the output to Firefox Profiler for advanced timeline-based analysis with features like stack charts, markers, and network activity.
  • --heatmap: Generates an interactive HTML heatmap visualization with line-level sample counts. Creates a directory with per-file heatmaps showing exactly where time is spent at the source code level.
• Live interactive mode: Real-time TUI profiler with a top-like interface (--live). Monitor performance as your application runs with interactive sorting and filtering.
• Async-aware profiling: Profile async/await code with task-based stack reconstruction (--async-aware). See which coroutines are consuming time, with options to show only running tasks or all tasks including those waiting.
• Opcode-level profiling: Gather bytecode opcode information for instruction-level profiling (--opcodes). Shows which bytecode instructions are executing, including specializations from the adaptive interpreter.

See profiling.sampling for the complete documentation, including all available output formats, profiling modes, and configuration options.

(Contributed by Pablo Galindo and László Kiss Kollár in 135953 and 138122.)

831: Frame pointers enabled by default

CPython is now built with frame pointers by default on platforms that support them. This uses the compiler flags -fno-omit-frame-pointer and -mno-omit-leaf-frame-pointer, making native stack unwinding faster and more reliable for system profilers, debuggers, crash analysis tools, and eBPF-based observability tools.

The flags are exposed through sysconfig, so extension modules built by tools that consume Python's build configuration inherit frame pointers by default. This propagation is intentional: mixed Python/native profiling needs an unbroken frame-pointer chain through the interpreter, extension modules, embedding applications, and native libraries.

[!IMPORTANT] Third-party build backends and native build systems should preserve these flags when they consume Python's sysconfig values. Build systems that compile C, C++, Rust, or other native code without inheriting Python's compiler flags should enable equivalent frame-pointer flags themselves. A single native component built without frame pointers can break stack unwinding for the whole Python process.

(Contributed by Pablo Galindo Salgado and Savannah Ostrowski in 149201; PEP 831 written by Pablo Galindo Salgado, Ken Jin, Savannah Ostrowski, and Diego Russo.)

798: Unpacking in comprehensions

List, set, and dictionary comprehensions, as well as generator expressions, now support unpacking with * and **. This extends the unpacking syntax from 448 to comprehensions, providing a new syntax for combining an arbitrary number of iterables or dictionaries into a single flat structure. This new syntax is a direct alternative to nested comprehensions, itertools.chain, and itertools.chain.from_iterable. For example:

>>> lists = [[1, 2], [3, 4], [5]]
>>> [*L for L in lists]  # equivalent to [x for L in lists for x in L]
[1, 2, 3, 4, 5]

>>> sets = [{1, 2}, {2, 3}, {3, 4}]
>>> {*s for s in sets}  # equivalent to {x for s in sets for x in s}
{1, 2, 3, 4}

>>> dicts = [{'a': 1}, {'b': 2}, {'a': 3}]
>>> {**d for d in dicts}  # equivalent to {k: v for d in dicts for k,v in d.items()}
{'a': 3, 'b': 2}

Generator expressions can similarly use unpacking to yield values from multiple iterables:

>>> gen = (*L for L in lists)  # equivalent to (x for L in lists for x in L)
>>> list(gen)
[1, 2, 3, 4, 5]

This change also extends to asynchronous generator expressions, such that, for example, (*a async for a in agen()) is equivalent to (x async for a in agen() for x in a).

(Contributed by Adam Hartz in 143055.)

829: Package startup configuration files

Loaded by the site module when -S is not given, .pth files <site-pth-files> can contain lines that both extend sys.path and execute arbitrary code when the line starts with import (followed by a space or tab). The latter functionality can be problematic, since it is difficult to know exactly what gets executed when Python starts up.

As a step towards improving the ability to audit pre-start executable code, Python 3.15 introduces .start files <site-start-files> which contain entry point specifications of the form pkg.mod:callable where pkg.mod is the import path to the given callable. When Python starts up, the callable is located and called with no arguments.

import lines in .pth files are silently deprecated. When a matching .start file is found, import lines in .pth files are ignored. There is no change to sys.path extension lines in .pth files.

The site module also provides site.StartupState to batch startup processing for multiple site directories, ensuring all static path extensions are applied before any startup code is executed. site.main uses an instance of this class implicitly to batch process all startup configuration files during normal interpreter startup. Callers needing the same batching behavior can build a ~site.StartupState directly and drive it with ~site.StartupState.addsitedir, ~site.StartupState.addusersitepackages, and ~site.StartupState.addsitepackages, then call ~site.StartupState.process once at the end of the batch.

(Contributed by Barry Warsaw in 148641 and 150228.)

803: Stable ABI for free-threaded builds

C extensions that target the Stable ABI <stable-abi> can now be compiled for the new Stable ABI for Free-Threaded Builds (also known as abi3t), which makes them compatible with free-threaded builds <free-threaded build> of CPython. This usually requires some non-trivial changes to the source code; specifically:

• Switching to API introduced in 697 (Python 3.12), such as negative ~PyType_Spec.basicsize and PyObject_GetTypeData, rather than making PyObject part of the instance struct; and
• Switching from a PyInit_ function to a new export hook, PyModExport_* <PyModExport_modulename>, introduced for this purpose in 793, with a new PySlot structure introduced in 820.

Note that Stable ABI does not offer all the functionality that CPython has to offer. Extensions that cannot switch to abi3t should continue to build for the existing Stable ABI (abi3) and the version-specific ABI for free-threading (cp315t) separately.

Stable ABI for Free-Threaded Builds should typically be selected in a build tool. Tools with abi3t support include meson-python, scikit-build-core, and Maturin; see abi3t-migration-build for links to their documentation on abi3t builds. If your build tool does not support abi3t, compile for cp315t separately. If not using a build tool -- or when writing such a tool -- you can select abi3t by setting the macro !Py_TARGET_ABI3T as discussed in abi3-compiling.

A practical migration guide <abi3t-migration-howto> for switching to abi3t is available. The community-maintained Python Free-Threading Guide provides examples of building and testing abi3t wheels.

788: Protecting the C API from interpreter finalization

In the C API, interpreter finalization <interpreter shutdown> can be problematic for many extensions, because attaching <attached thread state> a thread state will permanently hang the thread, resulting in deadlocks and other spurious issues. Additionally, it has historically been impossible to safely check whether an interpreter is alive before using it, leading to crashes when a thread concurrently deletes an interpreter while another thread is trying to attach to it.

There are now several new suites of APIs to circumvent these problems:

• Interpreter guards <interpreter-guards>, which prevent an interpreter from finalizing.
• Interpreter views <interpreter-views>, which allow thread-safe access to an interpreter that may be concurrently finalizing or deleted.
• New APIs <c-api-attach-detach> to automatically attach and detach thread states that come with built-in protection against finalization.

In addition, APIs in the PyGILState family (most notably PyGILState_Ensure and PyGILState_Release) have been soft deprecated. There is no plan to remove them, and existing code will continue to work, but there will be no new PyGILState APIs in future versions of Python.

(Contributed by Peter Bierma in 149101.)

Improved error messages

• The interpreter now provides more helpful suggestions in AttributeError exceptions when accessing an attribute on an object that does not exist, but a similar attribute is available through one of its members.

  For example, if the object has an attribute that itself exposes the requested name, the error message will suggest accessing it via that inner attribute:

  from dataclasses import dataclass
  from math import pi
  
  @dataclass
  class Circle:
     radius: float
  
     @property
     def area(self) -> float:
        return pi * self.radius**2
  
  class Container:
     def __init__(self, inner: Circle) -> None:
        self.inner = inner
  
  circle = Circle(radius=4.0)
  container = Container(circle)
  print(container.area)
  

  Running this code now produces a clearer suggestion:

  Traceback (most recent call last):
    File "example.py", line 18, in <module>
      print(container.area)
            ^^^^^^^^^^^^^^
  AttributeError: 'Container' object has no attribute 'area'. Did you mean '.inner.area' instead of '.area'?
  

• When an AttributeError on a builtin type has no close match via Levenshtein distance, the error message now checks a static table of common method names from other languages (JavaScript, Java, Ruby, C#) and suggests the Python equivalent:

  >>> [1, 2, 3].push(4) # doctest: +ELLIPSIS Traceback (most recent call last): ... AttributeError: 'list' object has no attribute 'push'. Did you mean '.append'?

  >>> 'hello'.toUpperCase() # doctest: +ELLIPSIS Traceback (most recent call last): ... AttributeError: 'str' object has no attribute 'toUpperCase'. Did you mean '.upper'?

  When the Python equivalent is a language construct rather than a method, the hint describes the construct directly:

  >>> {}.put("a", 1) # doctest: +ELLIPSIS Traceback (most recent call last): ... AttributeError: 'dict' object has no attribute 'put'. Use d[k] = v.

  When a mutable method is called on an immutable type, the hint suggests the mutable counterpart:

  >>> (1, 2, 3).append(4) # doctest: +ELLIPSIS Traceback (most recent call last): ... AttributeError: 'tuple' object has no attribute 'append'. Did you mean to use a 'list' object?

  These hints also work for subclasses of builtin types.

  (Contributed by Matt Van Horn in 146406.)

• The interpreter now tries to provide a suggestion when delattr fails due to a missing attribute. When an attribute name that closely resembles an existing attribute is used, the interpreter will suggest the correct attribute name in the error message. For example:

  >>> class A: ... pass >>> a = A() >>> a.abcde = 1 >>> del a.abcdf # doctest: +ELLIPSIS Traceback (most recent call last): ... AttributeError: 'A' object has no attribute 'abcdf'. Did you mean: 'abcde'?

  (Contributed by Nikita Sobolev and Pranjal Prajapati in 136588.)

• Several error messages incorrectly using the term "argument" have been corrected. (Contributed by Stan Ulbrych in 133382.)

Other language changes

Default interactive shell

New modules

math.integer

This module provides access to the mathematical functions for integer arguments (791). (Contributed by Serhiy Storchaka in 81313.)

Improved modules

argparse

• The ~argparse.BooleanOptionalAction action now supports single-dash long options and alternate prefix characters. (Contributed by Serhiy Storchaka in 138525.)
• Changed the suggest_on_error parameter of argparse.ArgumentParser to default to True. This enables suggestions for mistyped arguments by default. (Contributed by Jakob Schluse in 140450.)
• Added backtick markup support in ~argparse.ArgumentParser description and epilog text to highlight inline code when color output is enabled. (Contributed by Savannah Ostrowski in 142390.)
• Extended backtick markup to argument help text and added support for double backticks (RST inline-literal style). (Contributed by Hugo van Kemenade in 149375.)

array

• Support the float complex and double complex C types: formatting characters 'Zf' and 'Zd' respectively. (Contributed by Victor Stinner in 146151 and 148675.)
• Support half-floats (16-bit IEEE 754 binary interchange format): formatting character 'e'. (Contributed by Sergey B Kirpichev in 146238.)
• The array.typecodes type changed from str to tuple to support type codes longer than 1 character (Zf and Zd). (Contributed by Victor Stinner in 148675.)

ast

• Add color parameter to ~ast.dump. If True, the returned string is syntax highlighted using ANSI escape sequences. If False (the default), colored output is always disabled. (Contributed by Stan Ulbrych in 148981.)
• The command-line <ast-cli> output is now syntax highlighted by default. This can be controlled using environment variables <using-on-controlling-color>. (Contributed by Stan Ulbrych in 148981.)

asyncio

• Added TaskGroup.cancel <asyncio.TaskGroup.cancel> to allow early termination of a task group, for instance, when the goal of the tasks has been achieved or their services are no longer needed. Previously this would involve unintuitive boilerplate such as an extra task raising a custom exception which is then suppressed as it exits the task group. (Contributed by John Belmonte in 127214.)

base64

• Added the pad parameter in ~base64.z85encode. (Contributed by Hauke Dämpfling in 143103.)
• Added the padded parameter in ~base64.b32encode, ~base64.b32decode, ~base64.b32hexencode, ~base64.b32hexdecode, ~base64.b64encode, ~base64.b64decode, ~base64.urlsafe_b64encode, and ~base64.urlsafe_b64decode. (Contributed by Serhiy Storchaka in 73613.)
• Added the wrapcol parameter in ~base64.b16encode, ~base64.b32encode, ~base64.b32hexencode, ~base64.b64encode, ~base64.b85encode, and ~base64.z85encode. (Contributed by Serhiy Storchaka in 143214 and 146431.)
• Added the ignorechars parameter in ~base64.b16decode, ~base64.b32decode, ~base64.b32hexdecode, ~base64.b64decode, ~base64.b85decode, and ~base64.z85decode. (Contributed by Serhiy Storchaka in 144001 and 146431.)
• Added the canonical parameter in ~base64.b32decode, ~base64.b32hexdecode, ~base64.b64decode, ~base64.a85decode, ~base64.b85decode, and ~base64.z85decode, to reject encodings with non-zero padding bits or other non-canonical forms. (Contributed by Gregory P. Smith in 146311.)

binascii

• Added functions for Base32 encoding:

  • ~binascii.b2a_base32 and ~binascii.a2b_base32

  (Contributed by James Seo in 146192.)

• Added functions for Ascii85, Base85, and Z85 encoding:

  • ~binascii.b2a_ascii85 and ~binascii.a2b_ascii85
  • ~binascii.b2a_base85 and ~binascii.a2b_base85

  (Contributed by James Seo and Serhiy Storchaka in 101178.)

• Added the padded parameter in ~binascii.b2a_base32, ~binascii.a2b_base32, ~binascii.b2a_base64, and ~binascii.a2b_base64. (Contributed by Serhiy Storchaka in 73613.)

• Added the wrapcol parameter in ~binascii.b2a_base64. (Contributed by Serhiy Storchaka in 143214.)

• Added the alphabet parameter in ~binascii.b2a_base64 and ~binascii.a2b_base64. (Contributed by Serhiy Storchaka in 145980.)

• Added the ignorechars parameter in ~binascii.a2b_hex, ~binascii.unhexlify, and ~binascii.a2b_base64. (Contributed by Serhiy Storchaka in 144001 and 146431.)

• Added the canonical parameter in ~binascii.a2b_base64, to reject encodings with non-zero padding bits. (Contributed by Gregory P. Smith in 146311.)

calendar

• calendar's command-line <calendar-cli> text output has more color. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 148352.)
• The calendar's command-line <calendar-cli> HTML output now accepts the year-month option: python -m calendar -t html 2009 06. (Contributed by Pål Grønås Drange in 140212.)
• Calendar pages generated by the calendar.HTMLCalendar class now support dark mode and have been migrated to the HTML5 standard for improved accessibility. (Contributed by Jiahao Li and Hugo van Kemenade in 137634.)

collections

• Added !collections.Counter.__xor__ and !collections.Counter.__ixor__ to compute the symmetric difference between ~collections.Counter objects. (Contributed by Raymond Hettinger in 138682.)

concurrent.futures

• Improved error reporting when a child process in a concurrent.futures.ProcessPoolExecutor terminates abruptly. The resulting traceback will now tell you the PID and exit code of the terminated process. (Contributed by Jonathan Berg in 139486.)

contextlib

• Added support for arbitrary descriptors !__enter__, !__exit__, !__aenter__, and !__aexit__ in ~contextlib.ExitStack and contextlib.AsyncExitStack, for consistency with the with and async with statements. (Contributed by Serhiy Storchaka in 144386.)
• ~contextlib.ContextDecorator and ~contextlib.AsyncContextDecorator (and therefore ~contextlib.contextmanager and ~contextlib.asynccontextmanager used as decorators) now detect generator functions, coroutine functions, and asynchronous generator functions and keep the context manager open across iteration or await. Previously the context manager exited as soon as the generator or coroutine object was created. (Contributed by Alex Grönholm & Gregory P. Smith in 125862.)

ctypes

• Change the ~ctypes._SimpleCData._type_ of ~ctypes.c_float_complex, ~ctypes.c_double_complex and ~ctypes.c_longdouble_complex from F, D and G to Zf, Zd and Zg for compatibility with NumPy. (Contributed by Victor Stinner in 148675.)

dataclasses

• Annotations for generated __init__ methods no longer include internal type names. (Contributed by David Ellis in 137530.)

dbm

• Added new !reorganize methods to dbm.dumb and dbm.sqlite3 to recover unused free space previously occupied by deleted entries. (Contributed by Andrea Oliveri in 134004.)

difflib

• Introduced the optional color parameter to difflib.unified_diff, enabling color output similar to git diff. This can be controlled by environment variables <using-on-controlling-color>. (Contributed by Douglas Thor in 133725.)
• Improved the styling of HTML diff pages generated by the difflib.HtmlDiff class, and migrated the output to the HTML5 standard. (Contributed by Jiahao Li in 134580.)

email

• Email generators now raise an error when an .EmailMessage cannot be accurately flattened due to a non-ASCII email address (mailbox) in an address header. Options for supporting Email Address Internationalization (EAI) are discussed in .EmailPolicy.utf8. (Contributed by R David Murray and Mike Edmunds in 122540.)

faulthandler

• Added the max_threads parameter in faulthandler.enable, faulthandler.dump_traceback, faulthandler.dump_traceback_later, and faulthandler.register. (Contributed by Eric Froemling in 149085.)

functools

• ~functools.singledispatchmethod now supports non-descriptor callables. (Contributed by Serhiy Storchaka in 140873.)
• ~functools.singledispatchmethod now dispatches on the second argument if it wraps a regular method and is called as a class attribute. (Contributed by Bartosz Sławecki in 143535.)

gc

• Python 3.14.0-3.14.4 shipped with a new incremental garbage collector. However, due to a number of reports of significant memory pressure in production environments, it has been reverted back to the generational GC from 3.13. This is the GC now used in Python 3.14.5 and later and Python 3.15. (Contributed by Sergey Miryanov in 148726.)

hashlib

• Ensure that hash functions guaranteed to be always available exist as attributes of hashlib even if they will not work at runtime due to missing backend implementations. For instance, hashlib.md5 will no longer raise AttributeError if OpenSSL is not available and Python has been built without MD5 support. (Contributed by Bénédikt Tran in 136929.)

http.client

• A new max_response_headers keyword-only parameter has been added to ~http.client.HTTPConnection and ~http.client.HTTPSConnection constructors. This parameter overrides the default maximum number of allowed response headers. (Contributed by Alexander Enrique Urieles Nieto in 131724.)

http.server

• The logging of ~http.server.BaseHTTPRequestHandler, as used by the command-line interface <http-server-cli>, is colored by default. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 146292.)
• Added ~http.server.SimpleHTTPRequestHandler.default_content_type and the --content-type <http.server --content-type> command-line option to allow customizing the default Content-Type header for files with unknown extensions. (Contributed by John Comeau and Hugo van Kemenade in 113471.)
• Add a new extra_response_headers keyword argument to ~http.server.SimpleHTTPRequestHandler to support custom headers in HTTP responses. (Contributed by Anton I. Sipos in 135057.)
• Add a -H/--header <http.server --header> option to the python -m http.server command-line interface to support custom headers in HTTP responses. (Contributed by Anton I. Sipos in 135057.)

importlib.metadata

• Previously, when accessing a distribution metadata directory not containing a metadata file, metadata() and Distribution.metadata would return an empty PackageMetadata object as if the file was present but empty. Now, a MetadataNotFound exception is raised. See importlib_metadata#493 for background and rationale and 143387 for rationale on the compatibility concerns. (Contributed by Jason R. Coombs.)

inspect

• Add parameters inherit_class_doc and fallback_to_class_doc for ~inspect.getdoc. (Contributed by Serhiy Storchaka in 132686.)

json

• Add the array_hook parameter to ~json.load and ~json.loads functions: allow a callback for JSON literal array types to customize Python lists in the resulting decoded object. Passing combined frozendict to object_pairs_hook parameter and tuple to array_hook will yield a deeply nested immutable Python structure representing the JSON data. (Contributed by Joao S. O. Bueno in 146440.)

locale

• ~locale.setlocale now supports language codes with @-modifiers. @-modifiers are no longer silently removed in ~locale.getlocale, but included in the language code. (Contributed by Serhiy Storchaka in 137729.)
• Undeprecate the locale.getdefaultlocale function. (Contributed by Victor Stinner in 130796.)

math

• Add math.isnormal and math.issubnormal functions. (Contributed by Sergey B Kirpichev in 132908.)
• Add math.fmax, math.fmin and math.signbit functions. (Contributed by Bénédikt Tran in 135853.)

mimetypes

• Add more MIME types. (Contributed by Benedikt Johannes, Charlie Lin, Foolbar, Gil Forcada and John Franey in 144217, 145720, 140937, 139959, 145698, 145718, 145918, and 144213.)
• Rename application/x-texinfo to application/texinfo. (Contributed by Charlie Lin in 140165.)
• Changed the MIME type for .ai files to application/pdf. (Contributed by Stan Ulbrych in 141239.)

mmap

• mmap.mmap now has a trackfd parameter on Windows; if it is False, the file handle corresponding to fileno will not be duplicated. (Contributed by Serhiy Storchaka in 78502.)
• Added the mmap.mmap.set_name method to annotate an anonymous memory mapping if Linux kernel supports PR_SET_VMA_ANON_NAME <PR_SET_VMA(2const)> (Linux 5.17 or newer). (Contributed by Donghee Na in 142419.)

os

• Add os.statx on Linux kernel versions 4.11 and later with glibc versions 2.28 and later. (Contributed by Jeffrey Bosboom and Victor Stinner in 83714.)
• os.makedirs function now has a parent_mode parameter that allows specifying the mode for intermediate directories. This can be used to match the behavior from Python 3.6 and earlier by passing parent_mode=mode. (Contributed by Zackery Spytz and Gregory P. Smith in 86533.)

os.path

• Add support of the all-but-last mode in ~os.path.realpath. (Contributed by Serhiy Storchaka in 71189.)
• The strict parameter to os.path.realpath accepts a new value, os.path.ALLOW_MISSING. If used, errors other than FileNotFoundError will be re-raised; the resulting path can be missing but it will be free of symlinks. (Contributed by Petr Viktorin for 2025-4517.)

pathlib

• pathlib.Path.mkdir now has a parent_mode parameter that allows specifying the mode for intermediate directories when parents=True. (Contributed by Gregory P. Smith in 86533.)

pdb

• Use the new interactive shell as the default input shell for pdb. (Contributed by Tian Gao in 145379.)

pickle

• Add support for pickling private methods and nested classes. (Contributed by Zackery Spytz and Serhiy Storchaka in 77188.)

pickletools

• The output of the pickletools command-line interface is colored by default. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 149026.)

pprint

• Add an expand keyword argument for pprint.pprint, pprint.pformat, pprint.pp. If true, the output will be formatted similar to pretty-printed json.dumps when indent is supplied. (Contributed by Stefan Todoran, Semyon Moroz and Hugo van Kemenade in 112632.)
• Add t-string support to pprint. (Contributed by Loïc Simon and Hugo van Kemenade in 134551.)

re

• re.prefixmatch and a corresponding re.Pattern.prefixmatch have been added as alternate, more explicit names for the existing and now soft deprecated re.match and re.Pattern.match APIs. These are intended to be used to alleviate confusion around what match means by following the Zen of Python's "Explicit is better than implicit" mantra. Most other language regular expression libraries use an API named match to mean what Python has always called search. (Contributed by Gregory P. Smith in 86519.)

resource

• Add new constants: ~resource.RLIMIT_NTHR, ~resource.RLIMIT_UMTXP, ~resource.RLIMIT_THREADS, ~resource.RLIM_SAVED_CUR, and ~resource.RLIM_SAVED_MAX. (Contributed by Serhiy Storchaka in 137512.)

shelve

• Added new !reorganize method to shelve used to recover unused free space previously occupied by deleted entries. (Contributed by Andrea Oliveri in 134004.)
• Add support for custom serialization and deserialization functions in the shelve module. (Contributed by Furkan Onder in 99631.)

shutil

• shutil.copyfile now also raises ~shutil.SpecialFileError for sockets and device files. (Contributed by Savannah Ostrowski in 142693.)

socket

• Add constants for the ISO-TP CAN protocol. (Contributed by Patrick Menschel and Stefan Tatschner in 86819.)

sqlite3

• The command-line interface <sqlite3-cli> has several new features:

  • SQL keyword completion on Tab. (Contributed by Long Tan in 133393.)
  • Prompts, error messages, and help text are now colored. This is enabled by default, see using-on-controlling-color for details. (Contributed by Stan Ulbrych and Łukasz Langa in 133461.)
  • Table, index, trigger, view, column, function, and schema completion on Tab. (Contributed by Long Tan in 136101.)

ssl

• Indicate through ssl.HAS_PSK_TLS13 whether the ssl module supports "External PSKs" in TLSv1.3, as described in 9258. (Contributed by Will Childs-Klein in 133624.)

• Added new methods for managing groups used for SSL key agreement:

  • ssl.SSLContext.set_groups sets the groups allowed for doing key agreement, extending the previous ssl.SSLContext.set_ecdh_curve method. This new API provides the ability to list multiple groups and supports fixed-field and post-quantum groups in addition to ECDH curves. This method can also be used to control what key shares are sent in the TLS handshake.
  • ssl.SSLSocket.group returns the group selected for doing key agreement on the current connection after the TLS handshake completes. This call requires OpenSSL 3.2 or later.
  • ssl.SSLContext.get_groups returns a list of all available key agreement groups compatible with the minimum and maximum TLS versions currently set in the context. This call requires OpenSSL 3.5 or later.

  (Contributed by Ron Frederick in 136306.)

• Added a new method ssl.SSLContext.set_ciphersuites for setting TLS 1.3 ciphers. For TLS 1.2 or earlier, ssl.SSLContext.set_ciphers should continue to be used. Both calls can be made on the same context and the selected cipher suite will depend on the TLS version negotiated when a connection is made. (Contributed by Ron Frederick in 137197.)

• Added new methods for managing signature algorithms:

  • ssl.get_sigalgs returns a list of all available TLS signature algorithms. This call requires OpenSSL 3.4 or later.
  • ssl.SSLContext.set_client_sigalgs sets the signature algorithms allowed for certificate-based client authentication.
  • ssl.SSLContext.set_server_sigalgs sets the signature algorithms allowed for the server to complete the TLS handshake.
  • ssl.SSLSocket.client_sigalg returns the signature algorithm selected for client authentication on the current connection. This call requires OpenSSL 3.5 or later.
  • ssl.SSLSocket.server_sigalg returns the signature algorithm selected for the server to complete the TLS handshake on the current connection. This call requires OpenSSL 3.5 or later.

  (Contributed by Ron Frederick in 138252.)

subprocess

• subprocess.Popen.wait: when timeout is not None and the platform supports it, an efficient event-driven mechanism is used to wait for process termination:

  • Linux >= 5.3 uses os.pidfd_open + select.poll.
  • macOS and other BSD variants use select.kqueue + KQ_FILTER_PROC + KQ_NOTE_EXIT.
  • Windows keeps using WaitForSingleObject (unchanged).

  If none of these mechanisms are available, the function falls back to the traditional busy loop (non-blocking call and short sleeps). (Contributed by Giampaolo Rodola in 83069.)

symtable

• Add symtable.Function.get_cells and symtable.Symbol.is_cell methods. (Contributed by Yashp002 in 143504.)

sys

• Add sys.abi_info namespace to improve access to ABI information. (Contributed by Klaus Zimmermann in 137476.)

sys.monitoring

• The other events <monitoring-event-global> (PY_THROW, PY_UNWIND, RAISE, EXCEPTION_HANDLED, and RERAISE) can now be turned on and disabled on a per code object basis. Returning ~sys.monitoring.DISABLE from a callback for one of these events disables the event for the entire code object (for the current tool), rather than raising ValueError as in prior versions. (Contributed by Gabriele N. Tornetta in 146182.)

tarfile

• ~tarfile.data_filter now normalizes symbolic link targets in order to avoid path traversal attacks. (Contributed by Petr Viktorin in 127987 and 2025-4138.)
• ~tarfile.TarFile.extractall now skips fixing up directory attributes when a directory was removed or replaced by another kind of file. (Contributed by Petr Viktorin in 127987 and 2024-12718.)
• ~tarfile.TarFile.extract and ~tarfile.TarFile.extractall now (re-)apply the extraction filter when substituting a link (hard or symbolic) with a copy of another archive member, and when fixing up directory attributes. The former raises a new exception, ~tarfile.LinkFallbackError. (Contributed by Petr Viktorin for 2025-4330 and 2024-12718.)
• ~tarfile.TarFile.extract and ~tarfile.TarFile.extractall no longer extract rejected members when ~tarfile.TarFile.errorlevel is zero. (Contributed by Matt Prodani and Petr Viktorin in 112887 and 2025-4435.)
• ~tarfile.TarFile.extract and ~tarfile.TarFile.extractall now replace slashes with backslashes in symlink targets on Windows to prevent creation of corrupted links. (Contributed by Christoph Walcher in 57911.)
• ~tarfile.TarFile.gettarinfo now replaces backslashes with slashes in symlink targets on Windows to conform to the tar format standard. (Contributed by Daniele Nicolodi in 151669.)

threading

• Added ~threading.serialize_iterator, ~threading.synchronized_iterator, and ~threading.concurrent_tee to support concurrent access to generators and iterators. (Contributed by Raymond Hettinger in 124397.)

timeit

• The output of the timeit command-line interface is colored by default. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 146609.)
• The command-line interface now colorizes error tracebacks by default. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Yi Hong in 139374.)
• Make the target time of timeit.Timer.autorange configurable and add --target-time option to the command-line interface. (Contributed by Alessandro Cucci and Miikka Koskinen in 80642.)

tkinter

• The !tkinter.Text.search method now supports two additional arguments: nolinestop which allows the search to continue across line boundaries; and strictlimits which restricts the search to within the specified range. (Contributed by Rihaan Meher in 130848.)
• A new method !tkinter.Text.search_all has been introduced. This method allows for searching for all matches of a pattern using Tcl's -all and -overlap options. (Contributed by Rihaan Meher in 130848.)
• Added new methods !pack_content, !place_content and !grid_content which use Tk commands with new names (introduced in Tk 8.6) instead of !*_slaves methods which use Tk commands with outdated names. (Contributed by Serhiy Storchaka in 143754.)
• Added !Event attributes !user_data for Tk virtual events and !detail for Enter, Leave, FocusIn, FocusOut, and ConfigureRequest events. (Contributed by Matthias Kievernagel and Serhiy Storchaka in 47655.)

tokenize

• The output of the tokenize command-line interface <tokenize-cli> is colored by default. This can be controlled with environment variables <using-on-controlling-color>. (Contributed by Hugo van Kemenade in 148991.)

tomllib

• The tomllib module now supports TOML 1.1.0. This is a backwards compatible update, meaning that all valid TOML 1.0.0 documents are parsed the same way.

  The changes, according to the official TOML changelog, are:

  • Allow newlines and trailing commas in inline tables.

    Previously an inline table had to be on a single line and couldn't end with a trailing comma. This is now relaxed so that the following is valid:

    tbl = {
       key      = "a string",
       moar-tbl =  {
          key = 1,
       },
    }
    

  • Add \xHH notation to basic strings for codepoints under 255, and the \e escape for the escape character:

    null = "null byte: \x00; letter a: \x61"
    csi = "\e["
    

  • Seconds in datetime and time values are now optional. The following are now valid:

    dt = 2010-02-03 14:15
    t  = 14:15
    

  (Contributed by Taneli Hukkinen in 142956.)

types

• Expose the write-through locals proxy type as types.FrameLocalsProxyType. This represents the type of the frame.f_locals attribute, as described in 667. (Contributed by Peter Bierma in 136492.)

typing

unicodedata

• The Unicode database has been updated to Unicode 17.0.0. (Contributed by Benjamin Peterson in 138706.)
• Add unicodedata.isxidstart and unicodedata.isxidcontinue functions to check whether a character can start or continue a Unicode Standard Annex #31 identifier. (Contributed by Stan Ulbrych in 129117.)
• Add the ~unicodedata.iter_graphemes function to iterate over grapheme clusters according to rules defined in Unicode Standard Annex #29, "Unicode Text Segmentation". Add ~unicodedata.grapheme_cluster_break, ~unicodedata.indic_conjunct_break and ~unicodedata.extended_pictographic functions to get the properties of the character which are related to the above algorithm. (Contributed by Serhiy Storchaka and Guillaume Sanchez in 74902.)
• Add ~unicodedata.block function to return the Unicode block assigned to a character. (Contributed by Stan Ulbrych in 66802.)

unittest

• unittest.TestCase.assertLogs will now accept a formatter to control how messages are formatted. (Contributed by Garry Cairns in 134567.)
• unittest.TestCase.assertWarns and unittest.TestCase.assertWarnsRegex no longer swallow warnings that do not match the specified category or regex. Nested context managers are now supported. (Contributed by Serhiy Storchaka in 143231.)

urllib.parse

• Add the missing_as_none parameter to ~urllib.parse.urlsplit, ~urllib.parse.urlparse and ~urllib.parse.urldefrag functions. Add the keep_empty parameter to ~urllib.parse.urlunsplit and ~urllib.parse.urlunparse functions. This allows distinguishing between empty and undefined URI components and preserving empty components. (Contributed by Serhiy Storchaka in 67041.)

venv

• On POSIX platforms, platlib directories will be created if needed when creating virtual environments, instead of using a lib64 -> lib symlink. This means purelib and platlib of virtual environments no longer share the same lib directory on platforms where sys.platlibdir is not equal to lib. (Contributed by Rui Xi in 133951.)

warnings

• Improve filtering by module in warnings.warn_explicit if no module argument is passed. It now tests the module regular expression in the warnings filter not only against the filename with .py stripped, but also against module names constructed starting from different parent directories of the filename (with /__init__.py, .py and, on Windows, .pyw stripped). (Contributed by Serhiy Storchaka in 135801.)

wave

• Added support for IEEE floating-point WAVE audio (WAVE_FORMAT_IEEE_FLOAT) in wave.
• Added wave.Wave_read.getformat, wave.Wave_write.getformat, and wave.Wave_write.setformat for explicit frame format handling.
• wave.Wave_write.setparams accepts both 7-item tuples including format and 6-item tuples for backwards compatibility (defaulting to WAVE_FORMAT_PCM).
• WAVE_FORMAT_IEEE_FLOAT output now includes a fact chunk, as required for non-PCM WAVE formats.

(Contributed by Lionel Koenig and Michiel W. Beijen in 60729.)

webbrowser

• On macOS, the new !webbrowser.MacOS class opens URLs via /usr/bin/open instead of constructing and executing AppleScript via osascript. The default browser is detected from the LaunchServices preferences file using plistlib, with !com.apple.Safari as the fallback on fresh installations. For non-HTTP(S) URLs, open -b <bundle-id> is used to route the URL through a browser rather than the OS file handler, preventing file injection attacks. (Contributed by Jeff Lyon in 137586.)

xml

• Add the xml.is_valid_name function to check whether a string can be used as an element or attribute name in XML. (Contributed by Serhiy Storchaka in 139489.)
• Add the xml.is_valid_text function to check whether a string can be used in an XML document. (Contributed by Serhiy Storchaka in 139489.)

xml.parsers.expat

• Add ~xml.parsers.expat.xmlparser.SetAllocTrackerActivationThreshold and ~xml.parsers.expat.xmlparser.SetAllocTrackerMaximumAmplification to xmlparser <xmlparser-objects> objects to tune protections against disproportional amounts of dynamic memory usage from within an Expat parser. (Contributed by Bénédikt Tran in 90949.)
• Add ~xml.parsers.expat.xmlparser.SetBillionLaughsAttackProtectionActivationThreshold and ~xml.parsers.expat.xmlparser.SetBillionLaughsAttackProtectionMaximumAmplification to xmlparser <xmlparser-objects> objects to tune protections against billion laughs attacks. (Contributed by Bénédikt Tran in 90949.)

zlib

• Allow combining two Adler-32 checksums via ~zlib.adler32_combine. (Contributed by Callum Attryde and Bénédikt Tran in 134635.)
• Allow combining two CRC-32 checksums via ~zlib.crc32_combine. (Contributed by Bénédikt Tran in 134635.)

Optimizations

• mimalloc is now used as the default allocator for raw memory allocations such as via PyMem_RawMalloc for better performance on free-threaded builds <free-threaded build>. (Contributed by Kumar Aditya in 144914.)

base64 & binascii

• CPython's underlying base64 implementation now encodes 2x faster and decodes 3x faster thanks to simple CPU pipelining optimizations. (Contributed by Gregory P. Smith and Serhiy Storchaka in 143262.)
• Implementation for Ascii85, Base85, and Z85 encoding has been rewritten in C. Encoding and decoding is now two orders of magnitude faster and consumes two orders of magnitude less memory. (Contributed by James Seo and Serhiy Storchaka in 101178.)
• Implementation for Base32 has been rewritten in C. Encoding and decoding is now two orders of magnitude faster. (Contributed by James Seo in 146192.)

csv

• csv.Sniffer.sniff delimiter detection is now up to 1.6x faster. (Contributed by Maurycy Pawłowski-Wieroński in 137628.)

Upgraded experimental JIT compiler

Results from the pyperformance benchmark suite report a 7-8% geometric mean performance improvement for the JIT over the standard CPython interpreter built with all optimizations enabled on x86-64 Linux. On AArch64 macOS, the JIT has an 11-12% speedup over the tail calling interpreter <whatsnew314-tail-call-interpreter> with all optimizations enabled. The speedups for JIT builds versus no JIT builds range from roughly 15% slowdown to over 100% speedup (ignoring the unpack_sequence microbenchmark) on x86-64 Linux and AArch64 macOS systems.

The major upgrades to the JIT are:

• LLVM 21 build-time dependency
• New tracing frontend
• Basic register allocation in the JIT
• More JIT optimizations
• GDB and GNU backtrace() unwinding support
• Better machine code generation

LLVM 21 build-time dependency

The JIT compiler now uses LLVM 21 for build-time stencil generation. As always, LLVM is only needed when building CPython with the JIT enabled; end users running Python do not need LLVM installed. Instructions for installing LLVM can be found in the JIT compiler documentation for all supported platforms. (Contributed by Savannah Ostrowski in 140973.)

A new tracing frontend

The JIT compiler now supports significantly more bytecode operations and control flow than in Python 3.14, enabling speedups on a wider variety of code. For example, simple Python object creation is now understood by the 3.15 JIT compiler. Overloaded operations and generators are also partially supported. This was made possible by an overhauled JIT tracing frontend that records actual execution paths through code, rather than estimating them as the previous implementation did. (Contributed by Ken Jin in 139109. Support for Windows added by Mark Shannon in 141703.)

Basic register allocation in the JIT

A basic form of register allocation has been added to the JIT compiler's optimizer. This allows the JIT compiler to avoid certain stack operations altogether and instead operate on registers. This allows the JIT to produce more efficient traces by avoiding reads and writes to memory. (Contributed by Mark Shannon in 135379.)

More JIT optimizations

More constant-propagation is now performed. This means when the JIT compiler detects that certain user code results in constants, the code can be simplified by the JIT. (Contributed by Ken Jin and Savannah Ostrowski in 132732.)

Reference counts <reference count> are avoided whenever it is safe to do so. This generally reduces the cost of most operations in Python. (Contributed by Ken Jin, Donghee Na, Zheao Li, Hai Zhu, Savannah Ostrowski, Reiden Ong, Noam Cohen, Tomas Roun, PuQing, Cajetan Rodrigues, and Sacul in 134584.)

By tracking unique references to objects, the JIT optimizer can now eliminate reference count updates and perform in-place operations on ints and floats. (Contributed by Reiden Ong, and Pieter Eendebak in 143414 and 146306.)

The JIT optimizer now supports significantly more operations than in 3.14. (Contributed by Kumar Aditya, Ken Jin, Jiahao Li, and Sacul in 131798.)

GDB and GNU backtrace() unwinding support

The JIT compiler now publishes unwind information for generated machine code to the GDB interface on supported Linux ELF platforms. When libgcc frame registration is available, the same unwind information is also registered for GNU backtrace() stack walkers. This allows native debuggers, crash handlers, and diagnostic tools using these mechanisms to unwind through JIT frames instead of stopping at generated code. (Contributed by Diego Russo and Pablo Galindo Salgado in 146071 and 149104.)

Better machine code generation

The JIT compiler's machine code generator now produces better machine code for x86-64 and AArch64 macOS and Linux targets. In general, users should experience lower memory usage for generated machine code and more efficient machine code versus 3.14. (Contributed by Brandt Bucher in 136528 and 135905. Implementation for AArch64 contributed by Mark Shannon in 139855. Additional optimizations for AArch64 contributed by Mark Shannon and Diego Russo in 140683 and 142305.)

Maintainability

The JIT optimizer's operations have been simplified. This was made possible by a refactoring of JIT data structures. (Contributed by Zhongtian Zheng in 148211 and Hai Zhu in 143421.)

Removed

ast

• The constructors of AST nodes <ast_nodes> now raise a TypeError when a required argument is omitted or when a keyword argument that does not map to a field on the AST node is passed. These cases had previously raised a DeprecationWarning since Python 3.13. (Contributed by Brian Schubert and Jelle Zijlstra in 137600 and 105858.)

collections.abc

• collections.abc.ByteString has been removed from collections.abc.__all__. !collections.abc.ByteString has been deprecated since Python 3.12, and is scheduled for removal in Python 3.17. (Contributed by Alex Waygood in 118803.)

ctypes

• Removed the undocumented function !ctypes.SetPointerType, which has been deprecated since Python 3.13. (Contributed by Bénédikt Tran in 133866.)

datetime

• ~datetime.datetime.strptime now raises ValueError when the format string contains %d (day of month) without a year directive. This has been deprecated since Python 3.13. (Contributed by Stan Ulbrych and Gregory P. Smith in 70647.)

glob

• Removed the undocumented !glob.glob0 and !glob.glob1 functions, which have been deprecated since Python 3.13. Use glob.glob and pass a directory to its root_dir argument instead. (Contributed by Barney Gale in 137466.)

http.server

• Removed the !CGIHTTPRequestHandler class and the --cgi flag from the python -m http.server command-line interface. They were deprecated in Python 3.13. (Contributed by Bénédikt Tran in 133810.)

importlib

• The load_module() methods of ~importlib.abc.Loader and its subclasses is removed. The import system will no longer call it when defined on custom subclasses. The method has been deprecated in favor of ~importlib.abc.Loader.exec_module since Python 3.4. (Contributed by Brett Cannon in 97850.)

importlib.resources

• Removed deprecated package parameter from importlib.resources.files function. (Contributed by Semyon Moroz in 138044.)

pathlib

• Removed deprecated !pathlib.PurePath.is_reserved. Use os.path.isreserved to detect reserved paths on Windows. (Contributed by Nikita Sobolev in 133875.)

platform

• Removed the !platform.java_ver function, which was deprecated since Python 3.13. (Contributed by Alexey Makridenko in 133604.)

sre*

• Removed !sre_compile, !sre_constants and !sre_parse modules. (Contributed by Stan Ulbrych in 135994.)

sysconfig

• Removed the check_home parameter of sysconfig.is_python_build. (Contributed by Filipe Laíns in 92897.)

threading

• Remove support for arbitrary positional or keyword arguments in the C implementation of ~threading.RLock objects. This was deprecated in Python 3.14. (Contributed by Bénédikt Tran in 134087.)

types

• Removed !codeobject.co_lnotab from types.CodeType, deprecated since Python 3.12 by 626. (Contributed by Nikita Sobolev in 134690.)

typing

• typing.ByteString has been removed from typing.__all__. !typing.ByteString has been deprecated since Python 3.9, and is scheduled for removal in Python 3.17. (Contributed by Alex Waygood in 118803.)
• The undocumented keyword argument syntax for creating ~typing.NamedTuple classes (for example, Point = NamedTuple("Point", x=int, y=int)) is no longer supported. Use the class-based syntax or the functional syntax instead. (Contributed by Bénédikt Tran in 133817.)
• Using TD = TypedDict("TD") or TD = TypedDict("TD", None) to construct a ~typing.TypedDict type with zero fields is no longer supported. Use class TD(TypedDict): pass or TD = TypedDict("TD", {}) instead. (Contributed by Bénédikt Tran in 133823.)
• Deprecated !typing.no_type_check_decorator has been removed. (Contributed by Nikita Sobolev in 133601.)

wave

• Removed the getmark(), setmark() and getmarkers() methods of the ~wave.Wave_read and ~wave.Wave_write classes, which were deprecated since Python 3.13. (Contributed by Bénédikt Tran in 133873.)

zipimport

• Remove deprecated !zipimport.zipimporter.load_module. Use zipimport.zipimporter.exec_module instead. (Contributed by Jiahao Li in 133656.)

Deprecated

New deprecations

• ast:

  • Creating instances of abstract AST nodes (such as ast.AST or !ast.expr) is deprecated and will raise an error in Python 3.20.

    (Contributed by Brian Schubert in 116021.)

• base64:
  • Accepting the + and / characters with an alternative alphabet in ~base64.b64decode and ~base64.urlsafe_b64decode is now deprecated. In future Python versions they will be errors in the strict mode and discarded in the non-strict mode. (Contributed by Serhiy Storchaka in 125346.)
• CLI:

  • Deprecate -b and !-bb command-line options and schedule them to become no-ops in Python 3.17. These were primarily helpers for the Python 2 -> 3 transition. Starting with Python 3.17, no BytesWarning will be raised for these cases; use a type checker instead.

    (Contributed by Nikita Sobolev in 136355.)

• collections.abc:

  • The following statements now cause DeprecationWarnings to be emitted at runtime:

    • from collections.abc import ByteString
    • import collections.abc; collections.abc.ByteString.

    DeprecationWarnings were already emitted if collections.abc.ByteString was subclassed or used as the second argument to isinstance or issubclass, but warnings were not previously emitted if it was merely imported or accessed from the !collections.abc module. (Contributed by Alex Waygood in 118803.)

• hashlib:

  • In hash function constructors such as ~hashlib.new or the direct hash-named constructors such as ~hashlib.md5 and ~hashlib.sha256, the optional initial data parameter could also be passed as a keyword argument named data= or string= in various hashlib implementations.

    Support for the string keyword argument name is now deprecated and is slated for removal in Python 3.19. Prefer passing the initial data as a positional argument for maximum backwards compatibility.

    (Contributed by Bénédikt Tran in 134978.)

• http.cookies:
  • Morsel.js_output <http.cookies.Morsel.js_output> and BaseCookie.js_output <http.cookies.BaseCookie.js_output> are deprecated and will be removed in Python 3.19. Use Morsel.output <http.cookies.Morsel.output> or BaseCookie.output <http.cookies.BaseCookie.output> instead. (Contributed by kishorhange111 in 148849.)
• imaplib:
  • Altering IMAP4.file <imaplib.IMAP4.file> is now deprecated and slated for removal in Python 3.19. This property is now unused and changing its value does not explicitly close the current file. (Contributed by Bénédikt Tran in 142307.)
• profile:
  • The !profile module is deprecated and will be removed in Python 3.17. Use profiling.tracing instead, which provides a compatible API. See 799 for details. (Contributed by Pablo Galindo and László Kiss Kollár in 138122.)
• re:

  • re.match and re.Pattern.match are now soft deprecated in favor of the new re.prefixmatch and re.Pattern.prefixmatch APIs, which have been added as alternate, more explicit names. These are intended to be used to alleviate confusion around what match means by following the Zen of Python's "Explicit is better than implicit" mantra. Most other language regular expression libraries use an API named match to mean what Python has always called search.

    We do not plan to remove the older !match name, as it has been used in code for over 30 years. Code supporting older versions of Python should continue to use !match, while new code should prefer !prefixmatch. See prefixmatch-vs-match.

    (Contributed by Gregory P. Smith in 86519 and Hugo van Kemenade in 148100.)

• struct:

  • Calling Struct.__new__() without a required argument is now deprecated and will be removed in Python 3.20. Calling the ~object.__init__ method on an initialized ~struct.Struct object is deprecated and will be removed in Python 3.20.

    (Contributed by Sergey B Kirpichev and Serhiy Storchaka in 143715.)

  • The 'F' and 'D' type codes are now soft deprecated in favor of the two-letter forms 'Zf' and 'Zd'. (Contributed by Sergey B Kirpichev in 121249.)

• typing:

  • The following statements now cause DeprecationWarnings to be emitted at runtime:

    • from typing import ByteString
    • import typing; typing.ByteString.

    DeprecationWarnings were already emitted if typing.ByteString was subclassed or used as the second argument to isinstance or issubclass, but warnings were not previously emitted if it was merely imported or accessed from the !typing module. (Contributed by Alex Waygood in 118803.)

  • It is deprecated to call isinstance and issubclass checks on protocol classes that were not explicitly decorated with !runtime_checkable but that inherit from a runtime-checkable protocol class. This will raise a TypeError in Python 3.20.

    (Contributed by Bartosz Sławecki in 132604.)

• webbrowser:
  • !webbrowser.MacOSXOSAScript is deprecated in favour of !webbrowser.MacOS and scheduled for removal in Python 3.17. (Contributed by Jeff Lyon in 137586.)
• __version__:

  • 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 instead.

    • argparse
    • csv
    • ctypes
    • !ctypes.macholib
    • decimal (use decimal.SPEC_VERSION instead)
    • http.server
    • imaplib
    • ipaddress
    • json
    • logging (__date__ also deprecated)
    • optparse
    • pickle
    • platform
    • re
    • socketserver
    • tabnanny
    • tarfile
    • tkinter.font
    • tkinter.ttk
    • wsgiref.simple_server
    • xml.etree.ElementTree
    • !xml.sax.expatreader
    • xml.sax.handler
    • zlib

    (Contributed by Hugo van Kemenade and Stan Ulbrych in 76007.)

Pending removal in Python 3.16

• The import system:
  • Setting ~module.__loader__ on a module while failing to set __spec__.loader <importlib.machinery.ModuleSpec.loader> is deprecated. In Python 3.16, !__loader__ will cease to be set or taken into consideration by the import system or the standard library.
  • Setting ~module.__package__ on a module while failing to set __spec__.parent <importlib.machinery.ModuleSpec.parent> is deprecated. In Python 3.16, !__package__ will cease to be taken into consideration by the import system or standard library. (97879)
• The bundled copy of libmpdec.
• array:
  • The 'u' format code (wchar_t) has been deprecated in documentation since Python 3.3 and at runtime since Python 3.13. Use the 'w' format code (Py_UCS4) for Unicode characters instead.
• asyncio:

  • !asyncio.iscoroutinefunction is deprecated and will be removed in Python 3.16; use inspect.iscoroutinefunction instead. (Contributed by Jiahao Li and Kumar Aditya in 122875.)

  • asyncio policy system is deprecated and will be removed in Python 3.16. In particular, the following classes and functions are deprecated:

    • !asyncio.AbstractEventLoopPolicy
    • !asyncio.DefaultEventLoopPolicy
    • !asyncio.WindowsSelectorEventLoopPolicy
    • !asyncio.WindowsProactorEventLoopPolicy
    • !asyncio.get_event_loop_policy
    • !asyncio.set_event_loop_policy

    Users should use asyncio.run or asyncio.Runner with loop_factory to use the desired event loop implementation.

    For example, to use asyncio.SelectorEventLoop on Windows:

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

    (Contributed by Kumar Aditya in 127949.)

• builtins:
  • 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:
  • Calling the Python implementation of functools.reduce with function or sequence as keyword arguments has been deprecated since Python 3.14.
• logging:
  • 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.)
• mimetypes:
  • Valid extensions start with a '.' or are empty for mimetypes.MimeTypes.add_type. Undotted extensions are deprecated and will raise a ValueError in Python 3.16. (Contributed by Hugo van Kemenade in 75223.)
• shutil:
  • The !ExecError exception has been deprecated since Python 3.14. It has not been used by any function in !shutil since Python 3.4, and is now an alias of RuntimeError.
• symtable:
  • The !symtable.Class.get_methods method has been deprecated since Python 3.14.
• sys:
  • The !_enablelegacywindowsfsencoding function has been deprecated since Python 3.13. Use the PYTHONLEGACYWINDOWSFSENCODING environment variable instead.
• sysconfig:
  • The !sysconfig.expand_makefile_vars function has been deprecated since Python 3.14. Use the vars argument of sysconfig.get_paths instead.
• tarfile:
  • The undocumented and unused !TarInfo.tarfile attribute has been deprecated since Python 3.13.

Pending removal in Python 3.17

• datetime:
  • ~datetime.datetime.strptime calls using a format string containing %e (day of month) without a year. This has been deprecated since Python 3.15. (Contributed by Stan Ulbrych in 70647.)
• collections.abc:

  • collections.abc.ByteString is scheduled for removal in Python 3.17.

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

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

    See PEP 688 <688#current-options> for more details. (Contributed by Shantanu Jain in 91896.)

• encodings:
  • Passing non-ascii encoding names to encodings.normalize_encoding is deprecated and scheduled for removal in Python 3.17. (Contributed by Stan Ulbrych in 136702.)
• profile:
  • The !profile module is deprecated and will be removed in Python 3.17. Use profiling.tracing instead, which provides a compatible API. See 799 for details. (Contributed by Pablo Galindo and László Kiss Kollár in 138122.)
• webbrowser:
  • !webbrowser.MacOSXOSAScript is deprecated in favour of !webbrowser.MacOS. (137586)
• typing:

  • 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 and typing.get_args instead of relying on private implementation details.

  • typing.ByteString, 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> at runtime. For use in type annotations, either use ~collections.abc.Buffer or a union that explicitly specifies the types your code supports (e.g., bytes | bytearray | memoryview).

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

    See PEP 688 <688#current-options> for more details. (Contributed by Shantanu Jain in 91896.)

• tkinter:
  • The !tkinter.Variable methods !trace_variable, !trace (an alias of !trace_variable), !trace_vdelete and !trace_vinfo, deprecated since Python 3.14, are scheduled for removal in Python 3.17. Use !trace_add, !trace_remove and !trace_info instead. (Contributed by Serhiy Storchaka in 120220.)

Pending removal in Python 3.18

• No longer accept a boolean value when a file descriptor is expected. (Contributed by Serhiy Storchaka in 82626.)

• decimal:

  • The non-standard and undocumented ~decimal.Decimal format specifier 'N', which is only supported in the !decimal module's C implementation, has been deprecated since Python 3.13. (Contributed by Serhiy Storchaka in 89902.)

• Deprecations defined by 829:

  • import lines in {name}.pth files are silently ignored.

  (Contributed by Barry Warsaw in 148641.)

Pending removal in Python 3.19

• builtins:
  • Passing a complex number as the real or imag argument in the complex constructor is now deprecated; it should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in 109218.)
• ctypes:
  • Implicitly switching to the MSVC-compatible struct layout by setting ~ctypes.Structure._pack_ but not ~ctypes.Structure._layout_ on non-Windows platforms.
• hashlib:

  • In hash function constructors such as ~hashlib.new or the direct hash-named constructors such as ~hashlib.md5 and ~hashlib.sha256, their optional initial data parameter could also be passed a keyword argument named data= or string= in various !hashlib 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.

• http.cookies:
  • http.cookies.Morsel.js_output is deprecated and will be removed in Python 3.19.
  • http.cookies.BaseCookie.js_output is deprecated and will be removed in Python 3.19.
• imaplib:

  • Altering IMAP4.file <imaplib.IMAP4.file> is now deprecated and slated for removal in Python 3.19. This property is now unused and changing its value does not automatically close the current file.

    Before Python 3.14, this property was used to implement the corresponding read() and readline() methods for ~imaplib.IMAP4 but this is no longer the case since then.

• tkinter:
  • tkinter.filedialog.askopenfiles has been deprecated since Python 3.16. Iterate over the names returned by ~tkinter.filedialog.askopenfilenames and open them one by one instead. (Contributed by Serhiy Storchaka in 152638.)

Pending removal in Python 3.20

• Calling the __new__() method of struct.Struct without the format argument is deprecated and will be removed in Python 3.20. Calling ~object.__init__ method on initialized ~struct.Struct objects is deprecated and will be removed in Python 3.20.

  (Contributed by Sergey B Kirpichev and Serhiy Storchaka in 143715.)

• 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 instead.

  • argparse
  • csv
  • ctypes
  • !ctypes.macholib
  • decimal (use decimal.SPEC_VERSION instead)
  • http.server
  • imaplib
  • ipaddress
  • json
  • logging (__date__ also deprecated)
  • optparse
  • pickle
  • platform
  • re
  • socketserver
  • tabnanny
  • tarfile
  • tkinter.font
  • tkinter.ttk
  • wsgiref.simple_server
  • xml.etree.ElementTree
  • !xml.sax.expatreader
  • xml.sax.handler
  • zlib

  (Contributed by Hugo van Kemenade and Stan Ulbrych in 76007.)

• The __author__, __credits__, __copyright__ and __date__ attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Attribution is preserved in the source code and the version control history.

  • bz2
  • concurrent.futures
  • inspect
  • io
  • json
  • logging
  • optparse
  • platform
  • pydoc
  • tarfile
  • tkinter.ttk
  • tokenize
  • uuid

  (Contributed by Stan Ulbrych in 159240.)

• Deprecations defined by 829:

  • Warnings are produced for import lines found in {name}.pth files.
  • {name}.pth files are no longer decoded in the locale encoding by default. They MUST be encoded in utf-8-sig.

  (Contributed by Barry Warsaw in 148641.)

• ast:

  • Creating instances of abstract AST nodes (such as ast.AST or !ast.expr) is deprecated and will raise an error in Python 3.20.

• typing:

  • It is deprecated to call isinstance and issubclass checks on protocol classes that were not explicitly decorated with !runtime_checkable but that inherit from a runtime-checkable protocol class. This will raise a TypeError in Python 3.20.

    (Contributed by Bartosz Sławecki in 132604.)

Pending removal in Python 3.21

• abc

  • Soft-deprecated since Python 3.3 abc.abstractclassmethod, abc.abstractstaticmethod, and abc.abstractproperty now raise a DeprecationWarning. These classes will be removed in Python 3.21, instead use abc.abstractmethod with classmethod, staticmethod, and property respectively.

• ast:

  • Classes slice, Index, ExtSlice, Suite, Param, AugLoad and AugStore, will be removed in Python 3.21. These types are not generated by the parser or accepted by the code generator.
  • The dims property of ast.Tuple will be removed in Python 3.21. Use the ast.Tuple.elts property instead.

• functools:

  • Using a return annotation to infer the dispatch type for functools.singledispatch or functools.singledispatchmethod is deprecated since Python 3.16 and will raise TypeError in Python 3.21. Annotate the dispatch parameter or pass the dispatch type explicitly instead. (Contributed by Bartosz Sławecki in 143465.)

• struct:

  • Soft-deprecated since Python 3.15, using 'F' and 'D' type codes are now deprecated. These codes will be removed in Python 3.21. Use instead two-letter forms 'Zf' and 'Zd'.

• tempfile:

  • tempfile._TemporaryFileWrapper will be removed in Python 3.21. Use the public tempfile.TemporaryFileWrapper instead.

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:
  • Nesting argument groups and nesting mutually exclusive groups are deprecated.
  • Passing the undocumented keyword argument prefix_chars to ~argparse.ArgumentParser.add_argument_group is now deprecated.
  • The argparse.FileType type converter is deprecated.
• builtins:
  • 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, else, for, if, in, is and or. In a future release it will be changed to a syntax error. (87999)
  • 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.
  • Support for __float__() method returning a strict subclass of float: these methods will be required to return an instance of float.
  • Support for __complex__() method returning a strict subclass of complex: these methods will be required to return an instance of complex.
• calendar: calendar.January and calendar.February constants are deprecated and replaced by calendar.JANUARY and calendar.FEBRUARY. (Contributed by Prince Roshan in 103636.)
• codecs: use open instead of codecs.open. (133038)
• !codeobject.co_lnotab: use the codeobject.co_lines method instead.
• datetime:
  • ~datetime.datetime.utcnow: use datetime.datetime.now(tz=datetime.UTC).
  • ~datetime.datetime.utcfromtimestamp: use datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC).
• gettext: Plural value must be an integer.
• importlib:
  • ~importlib.util.cache_from_source debug_override parameter is deprecated: use the optimization parameter instead.
• importlib.metadata:
  • EntryPoints tuple interface.
  • Implicit None on return values.
• logging: the warn() method has been deprecated since Python 3.3, use ~logging.warning instead.
• mailbox: Use of StringIO input and text mode is deprecated, use BytesIO and binary mode instead.
• os: Calling os.register_at_fork in a multi-threaded process.
• os.path: os.path.commonprefix is deprecated, use os.path.commonpath for path prefixes. The os.path.commonprefix 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: A tuple value for exc_info parameter is deprecated, use an exception instance.
• re: 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.)
• shutil: ~shutil.rmtree's onerror parameter is deprecated in Python 3.12; use the onexc parameter instead.
• ssl options and protocols:
  • ssl.SSLContext without protocol argument is deprecated.
  • ssl.SSLContext: ~ssl.SSLContext.set_npn_protocols and !selected_npn_protocol 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 methods:
  • !threading.Condition.notifyAll: use ~threading.Condition.notify_all.
  • !threading.Event.isSet: use ~threading.Event.is_set.
  • !threading.Thread.isDaemon, threading.Thread.setDaemon: use threading.Thread.daemon attribute.
  • !threading.Thread.getName, threading.Thread.setName: use threading.Thread.name attribute.
  • !threading.currentThread: use threading.current_thread.
  • !threading.activeCount: use threading.active_count.
• typing.Text (92332).
• The internal class typing._UnionGenericAlias is no longer used to implement typing.Union. 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.)
• unittest.IsolatedAsyncioTestCase: it is deprecated to return a value that is not None from a test case.
• urllib.parse deprecated functions: ~urllib.parse.urlparse instead
  • splitattr()
  • splithost()
  • splitnport()
  • splitpasswd()
  • splitport()
  • splitquery()
  • splittag()
  • splittype()
  • splituser()
  • splitvalue()
  • to_bytes()
• wsgiref: SimpleHandler.stdout.write() should not do partial writes.
• xml.etree.ElementTree: Testing the truth value of an ~xml.etree.ElementTree.Element 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 is deprecated: use sys._clear_internal_caches instead.

Soft deprecations

There are no plans to remove soft deprecated APIs.

• re.match and re.Pattern.match are now soft deprecated in favor of the new re.prefixmatch and re.Pattern.prefixmatch APIs, which have been added as alternate, more explicit names. These are intended to be used to alleviate confusion around what match means by following the Zen of Python's "Explicit is better than implicit" mantra. Most other language regular expression libraries use an API named match to mean what Python has always called search.

  We do not plan to remove the older !match name, as it has been used in code for over 30 years. Code supporting older versions of Python should continue to use !match, while new code should prefer !prefixmatch. See prefixmatch-vs-match.

  (Contributed by Gregory P. Smith in 86519 and Hugo van Kemenade in 148100.)

C API changes

New features

• Add PyArg_ParseArray and PyArg_ParseArrayAndKeywords functions to parse arguments of functions using the METH_FASTCALL calling convention. (Contributed by Victor Stinner in 144175.)

• Add the following functions for the new frozendict type:

  • PyAnyDict_Check
  • PyAnyDict_CheckExact
  • PyFrozenDict_Check
  • PyFrozenDict_CheckExact
  • PyFrozenDict_New

  (Contributed by Victor Stinner in 141510.)

• Add PyObject_CallFinalizerFromDealloc function to the limited C API. (Contributed by Victor Stinner in 146063.)

• Add PySys_GetAttr, PySys_GetAttrString, PySys_GetOptionalAttr, and PySys_GetOptionalAttrString functions as replacements for PySys_GetObject. (Contributed by Serhiy Storchaka in 108512.)

• Add PyUnstable_Unicode_GET_CACHED_HASH to get the cached hash of a string. See the documentation for caveats. (Contributed by Petr Viktorin in 131510.)

• Add API for checking an extension module's ABI compatibility: Py_mod_abi, PyABIInfo_Check, and PyABIInfo_VAR. (Contributed by Petr Viktorin in 137210.)

Changed C APIs

• If the Py_TPFLAGS_MANAGED_DICT or Py_TPFLAGS_MANAGED_WEAKREF flag is set then Py_TPFLAGS_HAVE_GC must be set too. (Contributed by Sergey Miryanov in 134786.)
• PyDateTime_IMPORT is now thread safe. Code that directly checks PyDateTimeAPI for NULL should be updated to call PyDateTime_IMPORT instead. (Contributed by Kumar Aditya in 141563.)

Removed C APIs

• Remove deprecated PyUnicode functions:

  • !PyUnicode_AsDecodedObject: Use PyCodec_Decode instead.
  • !PyUnicode_AsDecodedUnicode: Use PyCodec_Decode instead; note that some codecs (for example, "base64") may return a type other than str, such as bytes.
  • !PyUnicode_AsEncodedObject: Use PyCodec_Encode instead.
  • !PyUnicode_AsEncodedUnicode: Use PyCodec_Encode instead; note that some codecs (for example, "base64") may return a type other than bytes, such as str.

  (Contributed by Stan Ulbrych in 133612.)

• !PyImport_ImportModuleNoBlock: deprecated alias of PyImport_ImportModule. (Contributed by Bénédikt Tran in 133644.)

• !PyWeakref_GetObject and !PyWeakref_GET_OBJECT: use PyWeakref_GetRef instead. The [|pythoncapi_compat_project_link|](https://github.com/python/pythoncapi-compat) can be used to get !PyWeakref_GetRef on Python 3.12 and older. (Contributed by Bénédikt Tran in 133644.)

• Remove deprecated !PySys_ResetWarnOptions. Clear sys.warnoptions and !warnings.filters instead.

  (Contributed by Nikita Sobolev in 138886.)

The following functions are removed in favor of PyConfig_Get. The [|pythoncapi_compat_project_link|](https://github.com/python/pythoncapi-compat) can be used to get !PyConfig_Get on Python 3.13 and older.

• Python initialization functions:

  • !Py_GetExecPrefix: use PyConfig_Get("base_exec_prefix") <PyConfig_Get> (sys.base_exec_prefix) instead. Use PyConfig_Get("exec_prefix") <PyConfig_Get> (sys.exec_prefix) if virtual environments <venv-def> need to be handled.
  • !Py_GetPath: use PyConfig_Get("module_search_paths") <PyConfig_Get> (sys.path) instead.
  • !Py_GetPrefix: use PyConfig_Get("base_prefix") <PyConfig_Get> (sys.base_prefix) instead. Use PyConfig_Get("prefix") <PyConfig_Get> (sys.prefix) if virtual environments <venv-def> need to be handled.
  • !Py_GetProgramFullPath: use PyConfig_Get("executable") <PyConfig_Get> (sys.executable) instead.
  • !Py_GetProgramName: use PyConfig_Get("executable") <PyConfig_Get> (sys.executable) instead.
  • !Py_GetPythonHome: use PyConfig_Get("home") <PyConfig_Get> or the PYTHONHOME environment variable instead.

  (Contributed by Bénédikt Tran in 133644.)

Deprecated C APIs

• Deprecate 456 support for providing an external definition of the string hashing scheme. Removal is scheduled for Python 3.19.

  Previously, embedders could define Py_HASH_ALGORITHM to be Py_HASH_EXTERNAL to indicate that the hashing scheme was provided externally but this feature was undocumented, untested and most likely unused.

  (Contributed by Bénédikt Tran in 141226.)

• For unsigned integer formats in PyArg_ParseTuple, accepting Python integers with value that is larger than the maximal value for the C type or less than the minimal value for the corresponding signed integer type of the same size is now deprecated. (Contributed by Serhiy Storchaka in 132629.)

• PyBytes_FromStringAndSize(NULL, len) <PyBytes_FromStringAndSize> and _PyBytes_Resize are soft deprecated, use the PyBytesWriter API instead. (Contributed by Victor Stinner in 129813.)

• !_PyObject_CallMethodId, !_PyObject_GetAttrId and !_PyUnicode_FromId are deprecated since Python 3.15 and will be removed in Python 3.20. Instead, use PyUnicode_InternFromString() and cache the result in the module state, then call PyObject_CallMethod or PyObject_GetAttr. (Contributed by Victor Stinner in 141049.)

• Deprecate ~PyComplexObject.cval field of the PyComplexObject type. Use PyComplex_AsCComplex and PyComplex_FromCComplex to convert a Python complex number to/from the C Py_complex representation. (Contributed by Sergey B Kirpichev in 128813.)

• Functions _Py_c_sum, _Py_c_diff, _Py_c_neg, _Py_c_prod, _Py_c_quot, _Py_c_pow and _Py_c_abs are soft deprecated. (Contributed by Sergey B Kirpichev in 128813.)

• ~PyConfig.bytes_warning is deprecated since Python 3.15 and will be removed in Python 3.17. (Contributed by Nikita Sobolev in 136355.)

• !Py_INFINITY macro is soft deprecated, use the C11 standard <math.h> !INFINITY instead. (Contributed by Sergey B Kirpichev in 141004.)

• The following macros are soft deprecated:

  • Py_ALIGNED: Prefer alignas instead.
  • PY_FORMAT_SIZE_T: Use "z" directly.
  • Py_LL and Py_ULL: Use standard suffixes, LL and ULL.
  • PY_LONG_LONG, PY_LLONG_MIN, PY_LLONG_MAX, PY_ULLONG_MAX, PY_INT32_T, PY_UINT32_T, PY_INT64_T, PY_UINT64_T, PY_SIZE_MAX: Use C99 types/limits.
  • Py_UNICODE_SIZE: Use sizeof(wchar_t) directly.
  • Py_VA_COPY: Use va_copy directly.

  The macro Py_UNICODE_WIDE, which was scheduled for removal, is soft deprecated instead.

  (Contributed by Petr Viktorin in 146175.)

• !Py_MATH_El and !Py_MATH_PIl are deprecated since Python 3.15 and will be removed in Python 3.20. (Contributed by Sergey B Kirpichev in 141004.)

Build changes

• Removed implicit fallback to the bundled copy of the libmpdec library. Now this should be explicitly enabled with !--with-system-libmpdec set to no or with !--without-system-libmpdec. (Contributed by Sergey B Kirpichev in 115119.)

• The new configure option --with-missing-stdlib-config=FILE allows distributors to pass a JSON configuration file containing custom error messages for standard library modules that are missing or packaged separately. (Contributed by Stan Ulbrych and Petr Viktorin in 139707.)

• The new configure option --with-pymalloc-hugepages enables huge page support for pymalloc <pymalloc> arenas. When enabled, arena size increases to 2 MiB and allocation uses MAP_HUGETLB (Linux) or MEM_LARGE_PAGES (Windows) with automatic fallback to regular pages. On Windows, use build.bat --pymalloc-hugepages. At runtime, huge pages must be explicitly enabled by setting the PYTHON_PYMALLOC_HUGEPAGES environment variable to 1. (Contributed by Pablo Galindo Salgado in 144319.)

• Annotating anonymous mmap usage is now supported if the Linux kernel supports PR_SET_VMA_ANON_NAME <PR_SET_VMA(2const)> (Linux 5.17 or newer). Annotations are visible in /proc/<pid>/maps if the kernel supports the feature and -X dev <-X> is passed to Python, or Python is built in debug mode <debug-build>. (Contributed by Donghee Na in 141770.)

• CPython is now built with frame pointers enabled by default (831). Pass --without-frame-pointers to opt out.

  Authors of C extensions and native libraries built with custom build systems should ensure the unwind chain is intact. This is usually done by adding -fno-omit-frame-pointer and similar flags to CFLAGS. See --without-frame-pointers documentation for the specific flags Python uses.

  (Contributed by Pablo Galindo Salgado and Savannah Ostrowski in 149201.)

Porting to Python 3.15

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

• sqlite3.Connection APIs have been cleaned up.

  • All parameters of sqlite3.connect except database are now keyword-only.
  • The first three parameters of methods ~sqlite3.Connection.create_function and ~sqlite3.Connection.create_aggregate are now positional-only.
  • The first parameter of methods ~sqlite3.Connection.set_authorizer, ~sqlite3.Connection.set_progress_handler and ~sqlite3.Connection.set_trace_callback is now positional-only.

  (Contributed by Serhiy Storchaka in 133595.)

• resource.RLIM_INFINITY is now always positive. Passing a negative integer value that corresponded to its old value (such as -1 or -3, depending on platform) to resource.setrlimit and resource.prlimit is now deprecated. (Contributed by Serhiy Storchaka in 137044.)

• mmap.mmap.resize has been removed on platforms that don't support the underlying syscall, instead of raising a SystemError. (Contributed by An Long in 138205.)

• A resource warning is now emitted for an unclosed xml.etree.ElementTree.iterparse iterator if it opened a file. Use its !close method or the contextlib.closing context manager to close it. (Contributed by Osama Abdelkader and Serhiy Storchaka in 140601.)

• If a short option and a single-dash long option are passed to argparse.ArgumentParser.add_argument, dest is now inferred from the single-dash long option. For example, in add_argument('-f', '-foo'), dest is now 'foo' instead of 'f'. Pass an explicit dest argument to preserve the old behavior. (Contributed by Serhiy Storchaka in 138697.)

• Padding of input no longer required in base64.urlsafe_b64decode. Pass a new argument padded=True or use base64.b64decode with argument altchars=b'-_' (this works with older Python versions) to make padding required. (Contributed by Serhiy Storchaka in 73613.)

• Since unittest.TestCase.assertWarns and unittest.TestCase.assertWarnsRegex no longer swallow warnings that do not match the specified category or regex, your tests may start leaking some warnings that were previously masked. Use warning filters to silence them or additional !assertWarns* to catch and check them. (Contributed by Serhiy Storchaka in 143231.)