Les nouveautés de Python 3.11

Éditeur:

Pablo Galindo Salgado

This article explains the new features in Python 3.11, compared to 3.10. Python 3.11 was released on October 24, 2022. For full details, see the changelog.

Résumé – Points forts de la publication

  • Python 3.11 est entre 10 et 60 % plus rapide que Python 3.10. En moyenne, nous avons mesuré une multiplication de la vitesse par 1,25 sur la suite de benchmarks standards. Voir les détails sur Faster CPython.

Nouvelles fonctionnalités de syntaxe :

Nouvelles fonctionnalités natives :

Nouveaux modules de bibliothèque standard :

Améliorations de l'interpréteur :

Nouvelles fonctionnalités de typage :

Important deprecations, removals and restrictions:

Nouvelles fonctionnalités

PEP 657 : amélioration de l'emplacement des erreurs dans les traces d'appels

When printing tracebacks, the interpreter will now point to the exact expression that caused the error, instead of just the line. For example:

Traceback (most recent call last):
  File "distance.py", line 11, in <module>
    print(manhattan_distance(p1, p2))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "distance.py", line 6, in manhattan_distance
    return abs(point_1.x - point_2.x) + abs(point_1.y - point_2.y)
                           ^^^^^^^^^
AttributeError: 'NoneType' object has no attribute 'x'

Previous versions of the interpreter would point to just the line, making it ambiguous which object was None. These enhanced errors can also be helpful when dealing with deeply nested dict objects and multiple function calls:

Traceback (most recent call last):
  File "query.py", line 37, in <module>
    magic_arithmetic('foo')
  File "query.py", line 18, in magic_arithmetic
    return add_counts(x) / 25
           ^^^^^^^^^^^^^
  File "query.py", line 24, in add_counts
    return 25 + query_user(user1) + query_user(user2)
                ^^^^^^^^^^^^^^^^^
  File "query.py", line 32, in query_user
    return 1 + query_count(db, response['a']['b']['c']['user'], retry=True)
                               ~~~~~~~~~~~~~~~~~~^^^^^
TypeError: 'NoneType' object is not subscriptable

As well as complex arithmetic expressions:

Traceback (most recent call last):
  File "calculation.py", line 54, in <module>
    result = (x / y / z) * (a / b / c)
              ~~~~~~^~~
ZeroDivisionError: division by zero

Additionally, the information used by the enhanced traceback feature is made available via a general API, that can be used to correlate bytecode instructions with source code location. This information can be retrieved using:

Voir la PEP 657 pour plus de détails (contribution de Pablo Galindo, Batuhan Taskaya et Ammar Askar dans bpo-43950).

Note

This feature requires storing column positions in Objets code, which may result in a small increase in interpreter memory usage and disk usage for compiled Python files. To avoid storing the extra information and deactivate printing the extra traceback information, use the -X no_debug_ranges command line option or the PYTHONNODEBUGRANGES environment variable.

PEP 654 : Groupes d'exception et except*

PEP 654 introduces language features that enable a program to raise and handle multiple unrelated exceptions simultaneously. The builtin types ExceptionGroup and BaseExceptionGroup make it possible to group exceptions and raise them together, and the new except* syntax generalizes except to match subgroups of exception groups.

Voir PEP 654 pour plus de détails.

(Contributed by Irit Katriel in bpo-45292. PEP written by Irit Katriel, Yury Selivanov and Guido van Rossum.)

PEP 678: Exceptions can be enriched with notes

The add_note() method is added to BaseException. It can be used to enrich exceptions with context information that is not available at the time when the exception is raised. The added notes appear in the default traceback.

Voir PEP 678 pour plus de détails.

(Contributed by Irit Katriel in bpo-45607. PEP written by Zac Hatfield-Dodds.)

Améliorations du lanceur Windows py.exe

The copy of the Lanceur Python pour Windows included with Python 3.11 has been significantly updated. It now supports company/tag syntax as defined in PEP 514 using the -V:<company>/<tag> argument instead of the limited -<major>.<minor>. This allows launching distributions other than PythonCore, the one hosted on python.org.

When using -V: selectors, either company or tag can be omitted, but all installs will be searched. For example, -V:OtherPython/ will select the "best" tag registered for OtherPython, while -V:3.11 or -V:/3.11 will select the "best" distribution with tag 3.11.

When using the legacy -<major>, -<major>.<minor>, -<major>-<bitness> or -<major>.<minor>-<bitness> arguments, all existing behaviour should be preserved from past versions, and only releases from PythonCore will be selected. However, the -64 suffix now implies "not 32-bit" (not necessarily x86-64), as there are multiple supported 64-bit platforms. 32-bit runtimes are detected by checking the runtime's tag for a -32 suffix. All releases of Python since 3.5 have included this in their 32-bit builds.

Autres changements au langage

  • Added a -P command line option and a PYTHONSAFEPATH environment variable, which disable the automatic prepending to sys.path of the script's directory when running a script, or the current directory when using -c and -m. This ensures only stdlib and installed modules are picked up by import, and avoids unintentionally or maliciously shadowing modules with those in a local (and typically user-writable) directory. (Contributed by Victor Stinner in gh-57684.)

  • A "z" option was added to the Mini-langage de spécification de format that coerces negative to positive zero after rounding to the format precision. See PEP 682 for more details. (Contributed by John Belmonte in gh-90153.)

  • Bytes are no longer accepted on sys.path. Support broke sometime between Python 3.2 and 3.6, with no one noticing until after Python 3.10.0 was released. In addition, bringing back support would be problematic due to interactions between -b and sys.path_importer_cache when there is a mixture of str and bytes keys. (Contributed by Thomas Grainger in gh-91181.)

Autres changements à l'implémentation de CPython

  • The special methods __complex__() for complex and __bytes__() for bytes are implemented to support the typing.SupportsComplex and typing.SupportsBytes protocols. (Contributed by Mark Dickinson and Donghee Na in bpo-24234.)

  • siphash13 is added as a new internal hashing algorithm. It has similar security properties as siphash24, but it is slightly faster for long inputs. str, bytes, and some other types now use it as the default algorithm for hash(). PEP 552 hash-based .pyc files now use siphash13 too. (Contributed by Inada Naoki in bpo-29410.)

  • When an active exception is re-raised by a raise statement with no parameters, the traceback attached to this exception is now always sys.exc_info()[1].__traceback__. This means that changes made to the traceback in the current except clause are reflected in the re-raised exception. (Contributed by Irit Katriel in bpo-45711.)

  • The interpreter state's representation of handled exceptions (aka exc_info or _PyErr_StackItem) now only has the exc_value field; exc_type and exc_traceback have been removed, as they can be derived from exc_value. (Contributed by Irit Katriel in bpo-45711.)

  • A new command line option, AppendPath, has been added for the Windows installer. It behaves similarly to PrependPath, but appends the install and scripts directories instead of prepending them. (Contributed by Bastian Neuburger in bpo-44934.)

  • The PyConfig.module_search_paths_set field must now be set to 1 for initialization to use PyConfig.module_search_paths to initialize sys.path. Otherwise, initialization will recalculate the path and replace any values added to module_search_paths.

  • The output of the --help option now fits in 50 lines/80 columns. Information about Python environment variables and -X options is now available using the respective --help-env and --help-xoptions flags, and with the new --help-all. (Contributed by Éric Araujo in bpo-46142.)

  • Converting between int and str in bases other than 2 (binary), 4, 8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now raises a ValueError if the number of digits in string form is above a limit to avoid potential denial of service attacks due to the algorithmic complexity. This is a mitigation for CVE 2020-10735. This limit can be configured or disabled by environment variable, command line flag, or sys APIs. See the integer string conversion length limitation documentation. The default limit is 4300 digits in string form.

Nouveaux modules

Modules améliorés

asyncio

contextlib

  • Added non parallel-safe chdir() context manager to change the current working directory and then restore it on exit. Simple wrapper around chdir(). (Contributed by Filipe Laíns in bpo-25625)

dataclasses

  • Change field default mutability check, allowing only defaults which are hashable instead of any object which is not an instance of dict, list or set. (Contributed by Eric V. Smith in bpo-44674.)

datetime

enum

  • Renamed EnumMeta to EnumType (EnumMeta kept as an alias).

  • Added StrEnum, with members that can be used as (and must be) strings.

  • Added ReprEnum, which only modifies the __repr__() of members while returning their literal values (rather than names) for __str__() and __format__() (used by str(), format() and f-strings).

  • Changed Enum.__format__() (the default for format(), str.format() and f-strings) to always produce the same result as Enum.__str__(): for enums inheriting from ReprEnum it will be the member's value; for all other enums it will be the enum and member name (e.g. Color.RED).

  • Added a new boundary class parameter to Flag enums and the FlagBoundary enum with its options, to control how to handle out-of-range flag values.

  • Added the verify() enum decorator and the EnumCheck enum with its options, to check enum classes against several specific constraints.

  • Added the member() and nonmember() decorators, to ensure the decorated object is/is not converted to an enum member.

  • Added the property() decorator, which works like property() except for enums. Use this instead of types.DynamicClassAttribute().

  • Added the global_enum() enum decorator, which adjusts __repr__() and __str__() to show values as members of their module rather than the enum class. For example, 're.ASCII' for the ASCII member of re.RegexFlag rather than 'RegexFlag.ASCII'.

  • Enhanced Flag to support len(), iteration and in/not in on its members. For example, the following now works: len(AFlag(3)) == 2 and list(AFlag(3)) == (AFlag.ONE, AFlag.TWO)

  • Changed Enum and Flag so that members are now defined before __init_subclass__() is called; dir() now includes methods, etc., from mixed-in data types.

  • Changed Flag to only consider primary values (power of two) canonical while composite values (3, 6, 10, etc.) are considered aliases; inverted flags are coerced to their positive equivalent.

fcntl

  • On FreeBSD, the F_DUP2FD and F_DUP2FD_CLOEXEC flags respectively are supported, the former equals to dup2 usage while the latter set the FD_CLOEXEC flag in addition.

fractions

  • Prise en charge de l'initialisation de Fraction à partir d'une chaîne suivant le style de la PEP 515 (contribution de Sergey B Kirpichev dans bpo-44258).

  • Fraction implémente maintenant la méthode __int__, ce qui permet au test isinstance(ma_fraction, typing.SupportsInt) de passer avec succès (contribution de Mark Dickinson dans bpo-44547).

functools

  • functools.singledispatch() now supports types.UnionType and typing.Union as annotations to the dispatch argument.:

    >>> from functools import singledispatch
>>> @singledispatch
... def fun(arg, verbose=False):
...     if verbose:
...         print("Let me just say,", end=" ")
...     print(arg)
...
>>> @fun.register
... def _(arg: int | float, verbose=False):
...     if verbose:
...         print("Strength in numbers, eh?", end=" ")
...     print(arg)
...
>>> from typing import Union
>>> @fun.register
... def _(arg: Union[list, set], verbose=False):
...     if verbose:
...         print("Enumerate this:")
...     for i, elem in enumerate(arg):
...         print(i, elem)
...

    (Contributed by Yurii Karabas in bpo-46014.)

gzip

  • The gzip.compress() function is now faster when used with the mtime=0 argument as it delegates the compression entirely to a single zlib.compress() operation. There is one side effect of this change: The gzip file header contains an "OS" byte in its header. That was traditionally always set to a value of 255 representing "unknown" by the gzip module. Now, when using compress() with mtime=0, it may be set to a different value by the underlying zlib C library Python was linked against. (See gh-112346 for details on the side effect.)

hashlib

  • hashlib.blake2b() and hashlib.blake2s() now prefer libb2 over Python's vendored copy. (Contributed by Christian Heimes in bpo-47095.)

  • The internal _sha3 module with SHA3 and SHAKE algorithms now uses tiny_sha3 instead of the Keccak Code Package to reduce code and binary size. The hashlib module prefers optimized SHA3 and SHAKE implementations from OpenSSL. The change affects only installations without OpenSSL support. (Contributed by Christian Heimes in bpo-47098.)

  • Add hashlib.file_digest(), a helper function for efficient hashing of files or file-like objects. (Contributed by Christian Heimes in gh-89313.)

IDLE et idlelib

  • Applique la coloration syntaxique aux fichiers .pyi (contribution d'Alex Waygood et de Terry Jan Reedy dans bpo-45447).

  • Include prompts when saving Shell with inputs and outputs. (Contributed by Terry Jan Reedy in gh-95191.)

inspect

locale

logging

math

  • Ajout de math.exp2() : renvoie 2 élevé à la puissance x (contribution de Gideon Mitchell dans bpo-45917).

  • Ajout de math.cbrt() : renvoie la racine cubique de x (contribution d'Ajith Ramachandran dans bpo-44357).

  • Le comportement de math.pow() dans deux cas particuliers a été changé pour être cohérent avec la spécification IEEE 754. Les opérations math.pow(0.0, -math.inf) et math.pow(-0.0, -math.inf) renvoient maintenant inf. Elles levaient précédemment ValueError (contribution de Mark Dickinson dans bpo-44339).

  • La valeur math.nan est maintenant toujours disponible (contribution de Victor Stinner dans bpo-46917).

operator

  • A new function operator.call has been added, such that operator.call(obj, *args, **kwargs) == obj(*args, **kwargs). (Contributed by Antony Lee in bpo-44019.)

os

  • On Windows, os.urandom() now uses BCryptGenRandom(), instead of CryptGenRandom() which is deprecated. (Contributed by Donghee Na in bpo-44611.)

pathlib

re

  • Le groupement atomique ((?>...)) et les quantificateurs possessifs (*+, ++, ?+, {m,n}+) sont maintenant pris en charge dans les expressions régulières (contribution de Jeffrey C. Jacobs et de Serhiy Storchaka dans bpo-433030).

shutils

socket

  • Add CAN Socket support for NetBSD. (Contributed by Thomas Klausner in bpo-30512.)

  • create_connection() has an option to raise, in case of failure to connect, an ExceptionGroup containing all errors instead of only raising the last error. (Contributed by Irit Katriel in bpo-29980.)

sqlite3

string

sys

  • sys.exc_info() now derives the type and traceback fields from the value (the exception instance), so when an exception is modified while it is being handled, the changes are reflected in the results of subsequent calls to exc_info(). (Contributed by Irit Katriel in bpo-45711.)

  • Ajout de sys.exception() qui renvoie l'instance de l'exception active (équivalent à sys.exc_info()[1]) (contribution d'Irit Katriel dans bpo-46328).

  • Add the sys.flags.safe_path flag. (Contributed by Victor Stinner in gh-57684.)

sysconfig

  • Three new installation schemes (posix_venv, nt_venv and venv) were added and are used when Python creates new virtual environments or when it is running from a virtual environment. The first two schemes (posix_venv and nt_venv) are OS-specific for non-Windows and Windows, the venv is essentially an alias to one of them according to the OS Python runs on. This is useful for downstream distributors who modify sysconfig.get_preferred_scheme(). Third party code that creates new virtual environments should use the new venv installation scheme to determine the paths, as does venv. (Contributed by Miro Hrončok in bpo-45413.)

tempfile

threading

time

  • Sur Unix, time.sleep() utilise maintenant une des fonctions clock_nanosleep() ou nanosleep(), quand elles sont disponibles, qui ont une résolution de 1 nanoseconde (10-9 secondes), plutôt que d'utiliser select() qui a une résolution de 1 microseconde (10-6 secondes) (contribution de Benjamin Szőke et de Victor Stinner dans bpo-21302).

  • On Windows 8.1 and newer, time.sleep() now uses a waitable timer based on high-resolution timers which has a resolution of 100 nanoseconds (10-7 seconds). Previously, it had a resolution of 1 millisecond (10-3 seconds). (Contributed by Benjamin Szőke, Donghee Na, Eryk Sun and Victor Stinner in bpo-21302 and bpo-45429.)

tkinter

  • Added method info_patchlevel() which returns the exact version of the Tcl library as a named tuple similar to sys.version_info. (Contributed by Serhiy Storchaka in gh-91827.)

traceback

typing

Pour les modifications majeures, voir New Features Related to Type Hints.

  • Add typing.assert_never() and typing.Never. typing.assert_never() is useful for asking a type checker to confirm that a line of code is not reachable. At runtime, it raises an AssertionError. (Contributed by Jelle Zijlstra in gh-90633.)

  • Add typing.reveal_type(). This is useful for asking a type checker what type it has inferred for a given expression. At runtime it prints the type of the received value. (Contributed by Jelle Zijlstra in gh-90572.)

  • Add typing.assert_type(). This is useful for asking a type checker to confirm that the type it has inferred for a given expression matches the given type. At runtime it simply returns the received value. (Contributed by Jelle Zijlstra in gh-90638.)

  • typing.TypedDict types can now be generic. (Contributed by Samodya Abeysiriwardane in gh-89026.)

  • NamedTuple types can now be generic. (Contributed by Serhiy Storchaka in bpo-43923.)

  • Allow subclassing of typing.Any. This is useful for avoiding type checker errors related to highly dynamic class, such as mocks. (Contributed by Shantanu Jain in gh-91154.)

  • The typing.final() decorator now sets the __final__ attributed on the decorated object. (Contributed by Jelle Zijlstra in gh-90500.)

  • The typing.get_overloads() function can be used for introspecting the overloads of a function. typing.clear_overloads() can be used to clear all registered overloads of a function. (Contributed by Jelle Zijlstra in gh-89263.)

  • The __init__() method of Protocol subclasses is now preserved. (Contributed by Adrian Garcia Badarasco in gh-88970.)

  • The representation of empty tuple types (Tuple[()]) is simplified. This affects introspection, e.g. get_args(Tuple[()]) now evaluates to () instead of ((),). (Contributed by Serhiy Storchaka in gh-91137.)

  • Loosen runtime requirements for type annotations by removing the callable check in the private typing._type_check function. (Contributed by Gregory Beauregard in gh-90802.)

  • typing.get_type_hints() now supports evaluating strings as forward references in PEP 585 generic aliases. (Contributed by Niklas Rosenstein in gh-85542.)

  • typing.get_type_hints() no longer adds Optional to parameters with None as a default. (Contributed by Nikita Sobolev in gh-90353.)

  • typing.get_type_hints() now supports evaluating bare stringified ClassVar annotations. (Contributed by Gregory Beauregard in gh-90711.)

  • typing.no_type_check() no longer modifies external classes and functions. It also now correctly marks classmethods as not to be type checked. (Contributed by Nikita Sobolev in gh-90729.)

unicodedata

  • The Unicode database has been updated to version 14.0.0. (Contributed by Benjamin Peterson in bpo-45190).

unittest

venv

  • When new Python virtual environments are created, the venv sysconfig installation scheme is used to determine the paths inside the environment. When Python runs in a virtual environment, the same installation scheme is the default. That means that downstream distributors can change the default sysconfig install scheme without changing behavior of virtual environments. Third party code that also creates new virtual environments should do the same. (Contributed by Miro Hrončok in bpo-45413.)

warnings

zipfile

  • Added support for specifying member name encoding for reading metadata in a ZipFile's directory and file headers. (Contributed by Stephen J. Turnbull and Serhiy Storchaka in bpo-28080.)

  • Added ZipFile.mkdir() for creating new directories inside ZIP archives. (Contributed by Sam Ezeh in gh-49083.)

  • Added stem, suffix and suffixes to zipfile.Path. (Contributed by Miguel Brito in gh-88261.)

Optimisations

This section covers specific optimizations independent of the Faster CPython project, which is covered in its own section.

  • The compiler now optimizes simple printf-style % formatting on string literals containing only the format codes %s, %r and %a and makes it as fast as a corresponding f-string expression. (Contributed by Serhiy Storchaka in bpo-28307.)

  • Integer division (//) is better tuned for optimization by compilers. It is now around 20% faster on x86-64 when dividing an int by a value smaller than 2**30. (Contributed by Gregory P. Smith and Tim Peters in gh-90564.)

  • sum() is now nearly 30% faster for integers smaller than 2**30. (Contributed by Stefan Behnel in gh-68264.)

  • Resizing lists is streamlined for the common case, speeding up list.append() by ≈15% and simple list comprehensions by up to 20-30% (Contributed by Dennis Sweeney in gh-91165.)

  • Dictionaries don't store hash values when all keys are Unicode objects, decreasing dict size. For example, sys.getsizeof(dict.fromkeys("abcdefg")) is reduced from 352 bytes to 272 bytes (23% smaller) on 64-bit platforms. (Contributed by Inada Naoki in bpo-46845.)

  • Using asyncio.DatagramProtocol is now orders of magnitude faster when transferring large files over UDP, with speeds over 100 times higher for a ≈60 MiB file. (Contributed by msoxzw in gh-91487.)

  • math functions comb() and perm() are now ≈10 times faster for large arguments (with a larger speedup for larger k). (Contributed by Serhiy Storchaka in bpo-37295.)

  • The statistics functions mean(), variance() and stdev() now consume iterators in one pass rather than converting them to a list first. This is twice as fast and can save substantial memory. (Contributed by Raymond Hettinger in gh-90415.)

  • unicodedata.normalize() now normalizes pure-ASCII strings in constant time. (Contributed by Donghee Na in bpo-44987.)

Faster CPython

CPython 3.11 is an average of 25% faster than CPython 3.10 as measured with the pyperformance benchmark suite, when compiled with GCC on Ubuntu Linux. Depending on your workload, the overall speedup could be 10-60%.

This project focuses on two major areas in Python: Faster Startup and Faster Runtime. Optimizations not covered by this project are listed separately under Optimisations.

Faster Startup

Frozen imports / Static code objects

Python caches bytecode in the __pycache__ directory to speed up module loading.

Previously in 3.10, Python module execution looked like this:

Read __pycache__ -> Unmarshal -> Heap allocated code object -> Evaluate

In Python 3.11, the core modules essential for Python startup are "frozen". This means that their Objets code (and bytecode) are statically allocated by the interpreter. This reduces the steps in module execution process to:

Statically allocated code object -> Evaluate

Le lancement de l'interpréteur est 10 à 15 % plus rapide dans la version 3.11. Cela a un grand impact pour les programmes courts utilisant Python.

(Contributed by Eric Snow, Guido van Rossum and Kumar Aditya in many issues.)

Faster Runtime

Cheaper, lazy Python frames

Python frames, holding execution information, are created whenever Python calls a Python function. The following are new frame optimizations:

  • Streamlined the frame creation process.

  • Avoided memory allocation by generously re-using frame space on the C stack.

  • Streamlined the internal frame struct to contain only essential information. Frames previously held extra debugging and memory management information.

Old-style frame objects are now created only when requested by debuggers or by Python introspection functions such as sys._getframe() and inspect.currentframe(). For most user code, no frame objects are created at all. As a result, nearly all Python functions calls have sped up significantly. We measured a 3-7% speedup in pyperformance.

(Contributed by Mark Shannon in bpo-44590.)

Inlined Python function calls

During a Python function call, Python will call an evaluating C function to interpret that function's code. This effectively limits pure Python recursion to what's safe for the C stack.

In 3.11, when CPython detects Python code calling another Python function, it sets up a new frame, and "jumps" to the new code inside the new frame. This avoids calling the C interpreting function altogether.

Most Python function calls now consume no C stack space, speeding them up. In simple recursive functions like fibonacci or factorial, we observed a 1.7x speedup. This also means recursive functions can recurse significantly deeper (if the user increases the recursion limit with sys.setrecursionlimit()). We measured a 1-3% improvement in pyperformance.

(Contributed by Pablo Galindo and Mark Shannon in bpo-45256.)

PEP 659: Specializing Adaptive Interpreter

PEP 659 is one of the key parts of the Faster CPython project. The general idea is that while Python is a dynamic language, most code has regions where objects and types rarely change. This concept is known as type stability.

At runtime, Python will try to look for common patterns and type stability in the executing code. Python will then replace the current operation with a more specialized one. This specialized operation uses fast paths available only to those use cases/types, which generally outperform their generic counterparts. This also brings in another concept called inline caching, where Python caches the results of expensive operations directly in the bytecode.

The specializer will also combine certain common instruction pairs into one superinstruction, reducing the overhead during execution.

Python will only specialize when it sees code that is "hot" (executed multiple times). This prevents Python from wasting time on run-once code. Python can also de-specialize when code is too dynamic or when the use changes. Specialization is attempted periodically, and specialization attempts are not too expensive, allowing specialization to adapt to new circumstances.

(PEP written by Mark Shannon, with ideas inspired by Stefan Brunthaler. See PEP 659 for more information. Implementation by Mark Shannon and Brandt Bucher, with additional help from Irit Katriel and Dennis Sweeney.)

Operation

Form

Specialization

Operation speedup (up to)

Contributor(s)

Binary operations

x + x

x - x

x * x

Binary add, multiply and subtract for common types such as int, float and str take custom fast paths for their underlying types.

10%

Mark Shannon, Donghee Na, Brandt Bucher, Dennis Sweeney

Subscript

a[i]

Subscripting container types such as list, tuple and dict directly index the underlying data structures.

Subscripting custom __getitem__() is also inlined similar to Inlined Python function calls.

10-25%

Irit Katriel, Mark Shannon

Store subscript

a[i] = z

Similar to subscripting specialization above.

10-25%

Dennis Sweeney

Appels

f(arg)

C(arg)

Calls to common builtin (C) functions and types such as len() and str directly call their underlying C version. This avoids going through the internal calling convention.

20%

Mark Shannon, Ken Jin

Load global variable

print

len

The object's index in the globals/builtins namespace is cached. Loading globals and builtins require zero namespace lookups.

[1]

Mark Shannon

Load attribute

o.attr

Similar to loading global variables. The attribute's index inside the class/object's namespace is cached. In most cases, attribute loading will require zero namespace lookups.

[2]

Mark Shannon

Load methods for call

o.meth()

The actual address of the method is cached. Method loading now has no namespace lookups -- even for classes with long inheritance chains.

10-20%

Ken Jin, Mark Shannon

Store attribute

o.attr = z

Similar to load attribute optimization.

2% in pyperformance

Mark Shannon

Unpack Sequence

*seq

Specialized for common containers such as list and tuple. Avoids internal calling convention.

8%

Brandt Bucher

Misc

  • Objects now require less memory due to lazily created object namespaces. Their namespace dictionaries now also share keys more freely. (Contributed Mark Shannon in bpo-45340 and bpo-40116.)

  • "Zero-cost" exceptions are implemented, eliminating the cost of try statements when no exception is raised. (Contributed by Mark Shannon in bpo-40222.)

  • A more concise representation of exceptions in the interpreter reduced the time required for catching an exception by about 10%. (Contributed by Irit Katriel in bpo-45711.)

  • re's regular expression matching engine has been partially refactored, and now uses computed gotos (or "threaded code") on supported platforms. As a result, Python 3.11 executes the pyperformance regular expression benchmarks up to 10% faster than Python 3.10. (Contributed by Brandt Bucher in gh-91404.)

FAQ

How should I write my code to utilize these speedups?

Write Pythonic code that follows common best practices; you don't have to change your code. The Faster CPython project optimizes for common code patterns we observe.

Will CPython 3.11 use more memory?

Maybe not; we don't expect memory use to exceed 20% higher than 3.10. This is offset by memory optimizations for frame objects and object dictionaries as mentioned above.

I don't see any speedups in my workload. Why?

Certain code won't have noticeable benefits. If your code spends most of its time on I/O operations, or already does most of its computation in a C extension library like NumPy, there won't be significant speedups. This project currently benefits pure-Python workloads the most.

Furthermore, the pyperformance figures are a geometric mean. Even within the pyperformance benchmarks, certain benchmarks have slowed down slightly, while others have sped up by nearly 2x!

Is there a JIT compiler?

No. We're still exploring other optimizations.

À propos

Faster CPython explores optimizations for CPython. The main team is funded by Microsoft to work on this full-time. Pablo Galindo Salgado is also funded by Bloomberg LP to work on the project part-time. Finally, many contributors are volunteers from the community.

CPython bytecode changes

The bytecode now contains inline cache entries, which take the form of the newly-added CACHE instructions. Many opcodes expect to be followed by an exact number of caches, and instruct the interpreter to skip over them at runtime. Populated caches can look like arbitrary instructions, so great care should be taken when reading or modifying raw, adaptive bytecode containing quickened data.

New opcodes

Replaced opcodes

Replaced Opcode(s)

New Opcode(s)

Notes
BINARY_*
INPLACE_*

BINARY_OP

Replaced all numeric binary/in-place opcodes with a single opcode
CALL_FUNCTION
CALL_FUNCTION_KW
CALL_METHOD
CALL
KW_NAMES
PRECALL
PUSH_NULL

Decouples argument shifting for methods from handling of keyword arguments; allows better specialization of calls
DUP_TOP
DUP_TOP_TWO
ROT_TWO
ROT_THREE
ROT_FOUR
ROT_N
COPY
SWAP

Stack manipulation instructions
JUMP_IF_NOT_EXC_MATCH
CHECK_EXC_MATCH

Now performs check but doesn't jump
JUMP_ABSOLUTE
POP_JUMP_IF_FALSE
POP_JUMP_IF_TRUE
JUMP_BACKWARD
POP_JUMP_BACKWARD_IF_*
POP_JUMP_FORWARD_IF_*

See [3]; TRUE, FALSE, NONE and NOT_NONE variants for each direction
SETUP_WITH
SETUP_ASYNC_WITH

BEFORE_WITH

with block setup

Changed/removed opcodes

  • Changed MATCH_CLASS and MATCH_KEYS to no longer push an additional boolean value to indicate success/failure. Instead, None is pushed on failure in place of the tuple of extracted values.

  • Changed opcodes that work with exceptions to reflect them now being represented as one item on the stack instead of three (see gh-89874).

  • Removed COPY_DICT_WITHOUT_KEYS, GEN_START, POP_BLOCK, SETUP_FINALLY and YIELD_FROM.

Obsolescence

Cette section liste les API Python qui sont devenues obsolètes dans la version 3.11.

Deprecated C APIs are listed separately.

Language/Builtins

  • Chaining classmethod descriptors (introduced in bpo-19072) is now deprecated. It can no longer be used to wrap other descriptors such as property. The core design of this feature was flawed and caused a number of downstream problems. To "pass-through" a classmethod, consider using the __wrapped__ attribute that was added in Python 3.10. (Contributed by Raymond Hettinger in gh-89519.)

  • Octal escapes in string and bytes literals with values larger than 0o377 (255 in decimal) now produce a DeprecationWarning. In a future Python version, they will raise a SyntaxWarning and eventually a SyntaxError. (Contributed by Serhiy Storchaka in gh-81548.)

  • The delegation of int() to __trunc__() is now deprecated. Calling int(a) when type(a) implements __trunc__() but not __int__() or __index__() now raises a DeprecationWarning. (Contributed by Zackery Spytz in bpo-44977.)

Modules

  • PEP 594 led to the deprecations of the following modules slated for removal in Python 3.13:

    aifc

    chunk

    msilib

    pipes

    telnetlib

    audioop

    crypt

    nis

    sndhdr

    uu

    cgi

    imghdr

    nntplib

    spwd

    xdrlib

    cgitb

    mailcap

    ossaudiodev

    sunau

    (Contributed by Brett Cannon in bpo-47061 and Victor Stinner in gh-68966.)

  • The asynchat, asyncore and smtpd modules have been deprecated since at least Python 3.6. Their documentation and deprecation warnings have now been updated to note they will be removed in Python 3.12. (Contributed by Hugo van Kemenade in bpo-47022.)

  • The lib2to3 package and 2to3 tool are now deprecated and may not be able to parse Python 3.10 or newer. See PEP 617, introducing the new PEG parser, for details. (Contributed by Victor Stinner in bpo-40360.)

  • Undocumented modules sre_compile, sre_constants and sre_parse are now deprecated. (Contributed by Serhiy Storchaka in bpo-47152.)

Bibliothèque Standard

Pending Removal in Python 3.12

Les API Python suivantes sont devenues obsolètes dans des versions précédentes, et seront supprimées dans la version 3.12.

C APIs pending removal are listed separately.

  • The asynchat module

  • The asyncore module

  • The entire distutils package

  • The imp module

  • The typing.io namespace

  • The typing.re namespace

  • cgi.log()

  • importlib.find_loader()

  • importlib.abc.Loader.module_repr()

  • importlib.abc.MetaPathFinder.find_module()

  • importlib.abc.PathEntryFinder.find_loader()

  • importlib.abc.PathEntryFinder.find_module()

  • importlib.machinery.BuiltinImporter.find_module()

  • importlib.machinery.BuiltinLoader.module_repr()

  • importlib.machinery.FileFinder.find_loader()

  • importlib.machinery.FileFinder.find_module()

  • importlib.machinery.FrozenImporter.find_module()

  • importlib.machinery.FrozenLoader.module_repr()

  • importlib.machinery.PathFinder.find_module()

  • importlib.machinery.WindowsRegistryFinder.find_module()

  • importlib.util.module_for_loader()

  • importlib.util.set_loader_wrapper()

  • importlib.util.set_package_wrapper()

  • pkgutil.ImpImporter

  • pkgutil.ImpLoader

  • pathlib.Path.link_to()

  • sqlite3.enable_shared_cache()

  • sqlite3.OptimizedUnicode()

  • PYTHONTHREADDEBUG environment variable

  • The following deprecated aliases in unittest:

    Deprecated alias

    Method Name

    Deprecated in

    failUnless

    assertTrue()

    3.1

    failIf

    assertFalse()

    3.1

    failUnlessEqual

    assertEqual()

    3.1

    failIfEqual

    assertNotEqual()

    3.1

    failUnlessAlmostEqual

    assertAlmostEqual()

    3.1

    failIfAlmostEqual

    assertNotAlmostEqual()

    3.1

    failUnlessRaises

    assertRaises()

    3.1

    assert_

    assertTrue()

    3.2

    assertEquals

    assertEqual()

    3.2

    assertNotEquals

    assertNotEqual()

    3.2

    assertAlmostEquals

    assertAlmostEqual()

    3.2

    assertNotAlmostEquals

    assertNotAlmostEqual()

    3.2

    assertRegexpMatches

    assertRegex()

    3.2

    assertRaisesRegexp

    assertRaisesRegex()

    3.2

    assertNotRegexpMatches

    assertNotRegex()

    3.5

Retraits

Cette section liste les API Python qui ont été supprimées dans la version 3.11.

Removed C APIs are listed separately.

  • Removed the @asyncio.coroutine() decorator enabling legacy generator-based coroutines to be compatible with async / await code. The function has been deprecated since Python 3.8 and the removal was initially scheduled for Python 3.10. Use async def instead. (Contributed by Illia Volochii in bpo-43216.)

  • Removed asyncio.coroutines.CoroWrapper used for wrapping legacy generator-based coroutine objects in the debug mode. (Contributed by Illia Volochii in bpo-43216.)

  • Due to significant security concerns, the reuse_address parameter of asyncio.loop.create_datagram_endpoint(), disabled in Python 3.9, is now entirely removed. This is because of the behavior of the socket option SO_REUSEADDR in UDP. (Contributed by Hugo van Kemenade in bpo-45129.)

  • Removed the binhex module, deprecated in Python 3.9. Also removed the related, similarly-deprecated binascii functions:

    • binascii.a2b_hqx()

    • binascii.b2a_hqx()

    • binascii.rlecode_hqx()

    • binascii.rldecode_hqx()

    The binascii.crc_hqx() function remains available.

    (Contributed by Victor Stinner in bpo-45085.)

  • Removed the distutils bdist_msi command deprecated in Python 3.9. Use bdist_wheel (wheel packages) instead. (Contributed by Hugo van Kemenade in bpo-45124.)

  • Removed the __getitem__() methods of xml.dom.pulldom.DOMEventStream, wsgiref.util.FileWrapper and fileinput.FileInput, deprecated since Python 3.9. (Contributed by Hugo van Kemenade in bpo-45132.)

  • Removed the deprecated gettext functions lgettext(), ldgettext(), lngettext() and ldngettext(). Also removed the bind_textdomain_codeset() function, the NullTranslations.output_charset() and NullTranslations.set_output_charset() methods, and the codeset parameter of translation() and install(), since they are only used for the l*gettext() functions. (Contributed by Donghee Na and Serhiy Storchaka in bpo-44235.)

  • Removed from the inspect module:

    (Contributed by Hugo van Kemenade in bpo-45320.)

  • Removed the __class_getitem__() method from pathlib.PurePath, because it was not used and added by mistake in previous versions. (Contributed by Nikita Sobolev in bpo-46483.)

  • Removed the MailmanProxy class in the smtpd module, as it is unusable without the external mailman package. (Contributed by Donghee Na in bpo-35800.)

  • Removed the deprecated split() method of _tkinter.TkappType. (Contributed by Erlend E. Aasland in bpo-38371.)

  • Removed namespace package support from unittest discovery. It was introduced in Python 3.4 but has been broken since Python 3.7. (Contributed by Inada Naoki in bpo-23882.)

  • Removed the undocumented private float.__set_format__() method, previously known as float.__setformat__() in Python 3.7. Its docstring said: "You probably don't want to use this function. It exists mainly to be used in Python's test suite." (Contributed by Victor Stinner in bpo-46852.)

  • The --experimental-isolated-subinterpreters configure flag (and corresponding EXPERIMENTAL_ISOLATED_SUBINTERPRETERS macro) have been removed.

  • Pynche --- The Pythonically Natural Color and Hue Editor --- has been moved out of Tools/scripts and is being developed independently from the Python source tree.

Portage vers Python 3.11

Cette section liste les modifications précédemment décrites et d'autres corrections de bogues dans l'API Python qui pourraient nécessiter des modifications dans votre code.

Porting notes for the C API are listed separately.

Changements à la compilation

  • CPython now has PEP 11 Tier 3 support for cross compiling to the WebAssembly platforms Emscripten (wasm32-unknown-emscripten, i.e. Python in the browser) and WebAssembly System Interface (WASI) (wasm32-unknown-wasi). The effort is inspired by previous work like Pyodide. These platforms provide a limited subset of POSIX APIs; Python standard libraries features and modules related to networking, processes, threading, signals, mmap, and users/groups are not available or don't work. (Emscripten contributed by Christian Heimes and Ethan Smith in gh-84461 and WASI contributed by Christian Heimes in gh-90473; platforms promoted in gh-95085)

  • Building CPython now requires:

  • The Py_NO_NAN macro has been removed. Since CPython now requires IEEE 754 floats, NaN values are always available. (Contributed by Victor Stinner in bpo-46656.)

  • The tkinter package now requires Tcl/Tk version 8.5.12 or newer. (Contributed by Serhiy Storchaka in bpo-46996.)

  • Build dependencies, compiler flags, and linker flags for most stdlib extension modules are now detected by configure. libffi, libnsl, libsqlite3, zlib, bzip2, liblzma, libcrypt, Tcl/Tk, and uuid flags are detected by pkg-config (when available). tkinter now requires a pkg-config command to detect development settings for Tcl/Tk headers and libraries. (Contributed by Christian Heimes and Erlend Egeberg Aasland in bpo-45847, bpo-45747, and bpo-45763.)

  • libpython is no longer linked against libcrypt. (Contributed by Mike Gilbert in bpo-45433.)

  • CPython can now be built with the ThinLTO option via passing thin to --with-lto, i.e. --with-lto=thin. (Contributed by Donghee Na and Brett Holman in bpo-44340.)

  • Freelists for object structs can now be disabled. A new configure option --without-freelists can be used to disable all freelists except empty tuple singleton. (Contributed by Christian Heimes in bpo-45522.)

  • Modules/Setup and Modules/makesetup have been improved and tied up. Extension modules can now be built through makesetup. All except some test modules can be linked statically into a main binary or library. (Contributed by Brett Cannon and Christian Heimes in bpo-45548, bpo-45570, bpo-45571, and bpo-43974.)

    Note

    Use the environment variables TCLTK_CFLAGS and TCLTK_LIBS to manually specify the location of Tcl/Tk headers and libraries. The configure options --with-tcltk-includes and --with-tcltk-libs have been removed.

    On RHEL 7 and CentOS 7 the development packages do not provide tcl.pc and tk.pc; use TCLTK_LIBS="-ltk8.5 -ltkstub8.5 -ltcl8.5". The directory Misc/rhel7 contains .pc files and instructions on how to build Python with RHEL 7's and CentOS 7's Tcl/Tk and OpenSSL.

  • CPython will now use 30-bit digits by default for the Python int implementation. Previously, the default was to use 30-bit digits on platforms with SIZEOF_VOID_P >= 8, and 15-bit digits otherwise. It's still possible to explicitly request use of 15-bit digits via either the --enable-big-digits option to the configure script or (for Windows) the PYLONG_BITS_IN_DIGIT variable in PC/pyconfig.h, but this option may be removed at some point in the future. (Contributed by Mark Dickinson in bpo-45569.)

Changements à l'API C

Nouvelles fonctionnalités

Portage vers Python 3.11

  • Some macros have been converted to static inline functions to avoid macro pitfalls. The change should be mostly transparent to users, as the replacement functions will cast their arguments to the expected types to avoid compiler warnings due to static type checks. However, when the limited C API is set to >=3.11, these casts are not done, and callers will need to cast arguments to their expected types. See PEP 670 for more details. (Contributed by Victor Stinner and Erlend E. Aasland in gh-89653.)

  • PyErr_SetExcInfo() no longer uses the type and traceback arguments, the interpreter now derives those values from the exception instance (the value argument). The function still steals references of all three arguments. (Contributed by Irit Katriel in bpo-45711.)

  • PyErr_GetExcInfo() now derives the type and traceback fields of the result from the exception instance (the value field). (Contributed by Irit Katriel in bpo-45711.)

  • _frozen has a new is_package field to indicate whether or not the frozen module is a package. Previously, a negative value in the size field was the indicator. Now only non-negative values be used for size. (Contributed by Kumar Aditya in bpo-46608.)

  • _PyFrameEvalFunction() now takes _PyInterpreterFrame* as its second parameter, instead of PyFrameObject*. See PEP 523 for more details of how to use this function pointer type.

  • PyCode_New() and PyCode_NewWithPosOnlyArgs() now take an additional exception_table argument. Using these functions should be avoided, if at all possible. To get a custom code object: create a code object using the compiler, then get a modified version with the replace method.

  • PyCodeObject no longer has the co_code, co_varnames, co_cellvars and co_freevars fields. Instead, use PyCode_GetCode(), PyCode_GetVarnames(), PyCode_GetCellvars() and PyCode_GetFreevars() respectively to access them via the C API. (Contributed by Brandt Bucher in bpo-46841 and Ken Jin in gh-92154 and gh-94936.)

  • The old trashcan macros (Py_TRASHCAN_SAFE_BEGIN/Py_TRASHCAN_SAFE_END) are now deprecated. They should be replaced by the new macros Py_TRASHCAN_BEGIN and Py_TRASHCAN_END.

    A tp_dealloc function that has the old macros, such as:

    static void
mytype_dealloc(mytype *p)
{
    PyObject_GC_UnTrack(p);
    Py_TRASHCAN_SAFE_BEGIN(p);
    ...
    Py_TRASHCAN_SAFE_END
}

    should migrate to the new macros as follows:

    static void
mytype_dealloc(mytype *p)
{
    PyObject_GC_UnTrack(p);
    Py_TRASHCAN_BEGIN(p, mytype_dealloc)
    ...
    Py_TRASHCAN_END
}

    Note that Py_TRASHCAN_BEGIN has a second argument which should be the deallocation function it is in.

    To support older Python versions in the same codebase, you can define the following macros and use them throughout the code (credit: these were copied from the mypy codebase):

    #if PY_VERSION_HEX >= 0x03080000
#  define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_BEGIN(op, dealloc)
#  define CPy_TRASHCAN_END(op) Py_TRASHCAN_END
#else
#  define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_SAFE_BEGIN(op)
#  define CPy_TRASHCAN_END(op) Py_TRASHCAN_SAFE_END(op)
#endif

  • The PyType_Ready() function now raises an error if a type is defined with the Py_TPFLAGS_HAVE_GC flag set but has no traverse function (PyTypeObject.tp_traverse). (Contributed by Victor Stinner in bpo-44263.)

  • Heap types with the Py_TPFLAGS_IMMUTABLETYPE flag can now inherit the PEP 590 vectorcall protocol. Previously, this was only possible for static types. (Contributed by Erlend E. Aasland in bpo-43908)

  • Since Py_TYPE() is changed to a inline static function, Py_TYPE(obj) = new_type must be replaced with Py_SET_TYPE(obj, new_type): see the Py_SET_TYPE() function (available since Python 3.9). For backward compatibility, this macro can be used:

    #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)
static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
{ ob->ob_type = type; }
#define Py_SET_TYPE(ob, type) _Py_SET_TYPE((PyObject*)(ob), type)
#endif

    (Contributed by Victor Stinner in bpo-39573.)

  • Since Py_SIZE() is changed to a inline static function, Py_SIZE(obj) = new_size must be replaced with Py_SET_SIZE(obj, new_size): see the Py_SET_SIZE() function (available since Python 3.9). For backward compatibility, this macro can be used:

    #if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE)
static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
{ ob->ob_size = size; }
#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size)
#endif

    (Contributed by Victor Stinner in bpo-39573.)

  • <Python.h> no longer includes the header files <stdlib.h>, <stdio.h>, <errno.h> and <string.h> when the Py_LIMITED_API macro is set to 0x030b0000 (Python 3.11) or higher. C extensions should explicitly include the header files after #include <Python.h>. (Contributed by Victor Stinner in bpo-45434.)

  • The non-limited API files cellobject.h, classobject.h, code.h, context.h, funcobject.h, genobject.h and longintrepr.h have been moved to the Include/cpython directory. Moreover, the eval.h header file was removed. These files must not be included directly, as they are already included in Python.h: Include Files. If they have been included directly, consider including Python.h instead. (Contributed by Victor Stinner in bpo-35134.)

  • The PyUnicode_CHECK_INTERNED() macro has been excluded from the limited C API. It was never usable there, because it used internal structures which are not available in the limited C API. (Contributed by Victor Stinner in bpo-46007.)

  • The following frame functions and type are now directly available with #include <Python.h>, it's no longer needed to add #include <frameobject.h>:

    (Contributed by Victor Stinner in gh-93937.)

  • The PyFrameObject structure members have been removed from the public C API.

    While the documentation notes that the PyFrameObject fields are subject to change at any time, they have been stable for a long time and were used in several popular extensions.

    In Python 3.11, the frame struct was reorganized to allow performance optimizations. Some fields were removed entirely, as they were details of the old implementation.

    PyFrameObject fields:

    The Python frame object is now created lazily. A side effect is that the f_back member must not be accessed directly, since its value is now also computed lazily. The PyFrame_GetBack() function must be called instead.

    Debuggers that accessed the f_locals directly must call PyFrame_GetLocals() instead. They no longer need to call PyFrame_FastToLocalsWithError() or PyFrame_LocalsToFast(), in fact they should not call those functions. The necessary updating of the frame is now managed by the virtual machine.

    Code defining PyFrame_GetCode() on Python 3.8 and older:

    #if PY_VERSION_HEX < 0x030900B1
static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)
{
    Py_INCREF(frame->f_code);
    return frame->f_code;
}
#endif

    Code defining PyFrame_GetBack() on Python 3.8 and older:

    #if PY_VERSION_HEX < 0x030900B1
static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)
{
    Py_XINCREF(frame->f_back);
    return frame->f_back;
}
#endif

    Or use the pythoncapi_compat project to get these two functions on older Python versions.

  • Changes of the PyThreadState structure members:

    Code defining PyThreadState_GetFrame() on Python 3.8 and older:

    #if PY_VERSION_HEX < 0x030900B1
static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)
{
    Py_XINCREF(tstate->frame);
    return tstate->frame;
}
#endif

    Code defining PyThreadState_EnterTracing() and PyThreadState_LeaveTracing() on Python 3.10 and older:

    #if PY_VERSION_HEX < 0x030B00A2
static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
{
    tstate->tracing++;
#if PY_VERSION_HEX >= 0x030A00A1
    tstate->cframe->use_tracing = 0;
#else
    tstate->use_tracing = 0;
#endif
}

static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
{
    int use_tracing = (tstate->c_tracefunc != NULL || tstate->c_profilefunc != NULL);
    tstate->tracing--;
#if PY_VERSION_HEX >= 0x030A00A1
    tstate->cframe->use_tracing = use_tracing;
#else
    tstate->use_tracing = use_tracing;
#endif
}
#endif

    Or use the pythoncapi-compat project to get these functions on old Python functions.

  • Distributors are encouraged to build Python with the optimized Blake2 library libb2.

  • The PyConfig.module_search_paths_set field must now be set to 1 for initialization to use PyConfig.module_search_paths to initialize sys.path. Otherwise, initialization will recalculate the path and replace any values added to module_search_paths.

  • PyConfig_Read() no longer calculates the initial search path, and will not fill any values into PyConfig.module_search_paths. To calculate default paths and then modify them, finish initialization and use PySys_GetObject() to retrieve sys.path as a Python list object and modify it directly.

Obsolescence

  • Deprecate the following functions to configure the Python initialization:

    • PySys_AddWarnOptionUnicode()

    • PySys_AddWarnOption()

    • PySys_AddXOption()

    • PySys_HasWarnOptions()

    • PySys_SetArgvEx()

    • PySys_SetArgv()

    • PySys_SetPath()

    • Py_SetPath()

    • Py_SetProgramName()

    • Py_SetPythonHome()

    • Py_SetStandardStreamEncoding()

    • _Py_SetProgramFullPath()

    Use the new PyConfig API of the Python Initialization Configuration instead (PEP 587). (Contributed by Victor Stinner in gh-88279.)

  • Deprecate the ob_shash member of the PyBytesObject. Use PyObject_Hash() instead. (Contributed by Inada Naoki in bpo-46864.)

Pending Removal in Python 3.12

The following C APIs have been deprecated in earlier Python releases, and will be removed in Python 3.12.

  • PyUnicode_AS_DATA()

  • PyUnicode_AS_UNICODE()

  • PyUnicode_AsUnicodeAndSize()

  • PyUnicode_AsUnicode()

  • PyUnicode_FromUnicode()

  • PyUnicode_GET_DATA_SIZE()

  • PyUnicode_GET_SIZE()

  • PyUnicode_GetSize()

  • PyUnicode_IS_COMPACT()

  • PyUnicode_IS_READY()

  • PyUnicode_READY()

  • PyUnicode_WSTR_LENGTH()

  • _PyUnicode_AsUnicode()

  • PyUnicode_WCHAR_KIND

  • PyUnicodeObject

  • PyUnicode_InternImmortal()

Retraits

  • PyFrame_BlockSetup() and PyFrame_BlockPop() have been removed. (Contributed by Mark Shannon in bpo-40222.)

  • Remove the following math macros using the errno variable:

    • Py_ADJUST_ERANGE1()

    • Py_ADJUST_ERANGE2()

    • Py_OVERFLOWED()

    • Py_SET_ERANGE_IF_OVERFLOW()

    • Py_SET_ERRNO_ON_MATH_ERROR()

    (Contributed by Victor Stinner in bpo-45412.)

  • Remove Py_UNICODE_COPY() and Py_UNICODE_FILL() macros, deprecated since Python 3.3. Use PyUnicode_CopyCharacters() or memcpy() (wchar_t* string), and PyUnicode_Fill() functions instead. (Contributed by Victor Stinner in bpo-41123.)

  • Remove the pystrhex.h header file. It only contains private functions. C extensions should only include the main <Python.h> header file. (Contributed by Victor Stinner in bpo-45434.)

  • Remove the Py_FORCE_DOUBLE() macro. It was used by the Py_IS_INFINITY() macro. (Contributed by Victor Stinner in bpo-45440.)

  • The following items are no longer available when Py_LIMITED_API is defined:

    These are not part of the limited API.

    (Contributed by Victor Stinner in bpo-45474.)

  • Exclude PyWeakref_GET_OBJECT() from the limited C API. It never worked since the PyWeakReference structure is opaque in the limited C API. (Contributed by Victor Stinner in bpo-35134.)

  • Remove the PyHeapType_GET_MEMBERS() macro. It was exposed in the public C API by mistake, it must only be used by Python internally. Use the PyTypeObject.tp_members member instead. (Contributed by Victor Stinner in bpo-40170.)

  • Remove the HAVE_PY_SET_53BIT_PRECISION macro (moved to the internal C API). (Contributed by Victor Stinner in bpo-45412.)

  • Remove the Py_UNICODE encoder APIs, as they have been deprecated since Python 3.3, are little used and are inefficient relative to the recommended alternatives.

    The removed functions are:

    • PyUnicode_Encode()

    • PyUnicode_EncodeASCII()

    • PyUnicode_EncodeLatin1()

    • PyUnicode_EncodeUTF7()

    • PyUnicode_EncodeUTF8()

    • PyUnicode_EncodeUTF16()

    • PyUnicode_EncodeUTF32()

    • PyUnicode_EncodeUnicodeEscape()

    • PyUnicode_EncodeRawUnicodeEscape()

    • PyUnicode_EncodeCharmap()

    • PyUnicode_TranslateCharmap()

    • PyUnicode_EncodeDecimal()

    • PyUnicode_TransformDecimalToASCII()

    See PEP 624 for details and migration guidance. (Contributed by Inada Naoki in bpo-44029.)

Notable changes in 3.11.4

tarfile

  • The extraction methods in tarfile, and shutil.unpack_archive(), have a new a filter argument that allows limiting tar features than may be surprising or dangerous, such as creating files outside the destination directory. See Extraction filters for details. In Python 3.12, use without the filter argument will show a DeprecationWarning. In Python 3.14, the default will switch to 'data'. (Contributed by Petr Viktorin in PEP 706.)

Notable changes in 3.11.5

OpenSSL

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