Skip to content

Latest commit

 

History

History
2744 lines (2042 loc) · 108 KB

3.11.rst

File metadata and controls

2744 lines (2042 loc) · 108 KB
Raw

What's New In Python 3.11

Editor: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 :ref:`changelog <changelog>`.

Summary -- Release highlights

  • Python 3.11 is between 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite. See :ref:`whatsnew311-faster-cpython` for details.

New syntax features:

New built-in features:

New standard library modules:

Interpreter improvements:

New typing features:

Important deprecations, removals and restrictions:

New Features

PEP 657: Fine-grained error locations in tracebacks

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 :class:`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 :term:`bytecode` :ref:`instructions <bytecodes>` with source code location. This information can be retrieved using:

See PEP 657 for more details. (Contributed by Pablo Galindo, Batuhan Taskaya and Ammar Askar in :issue:`43950`.)

Note

This feature requires storing column positions in :ref:`codeobjects`, 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 :option:`-X no_debug_ranges <-X>` command line option or the :envvar:`PYTHONNODEBUGRANGES` environment variable.

PEP 654: Exception Groups and except*

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

See PEP 654 for more details.

(Contributed by Irit Katriel in :issue:`45292`. PEP written by Irit Katriel, Yury Selivanov and Guido van Rossum.)

PEP 678: Exceptions can be enriched with notes

The :meth:`~BaseException.add_note` method is added to :exc:`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.

See PEP 678 for more details.

(Contributed by Irit Katriel in :issue:`45607`. PEP written by Zac Hatfield-Dodds.)

Windows py.exe launcher improvements

The copy of the :ref:`launcher` included with Python 3.11 has been significantly updated. It now supports company/tag syntax as defined in PEP 514 using the :samp:`-V:{<company>}/{<tag>}` argument instead of the limited :samp:`-{<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 :samp:`-{<major>}`, :samp:`-{<major>}.{<minor>}`, :samp:`-{<major>}-{<bitness>}` or :samp:`-{<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.

New Features Related to Type Hints

This section covers major changes affecting PEP 484 type hints and the :mod:`typing` module.

PEP 646: Variadic generics

PEP 484 previously introduced :data:`~typing.TypeVar`, enabling creation of generics parameterised with a single type. PEP 646 adds :data:`~typing.TypeVarTuple`, enabling parameterisation with an arbitrary number of types. In other words, a :data:`~typing.TypeVarTuple` is a variadic type variable, enabling variadic generics.

This enables a wide variety of use cases. In particular, it allows the type of array-like structures in numerical computing libraries such as NumPy and TensorFlow to be parameterised with the array shape. Static type checkers will now be able to catch shape-related bugs in code that uses these libraries.

See PEP 646 for more details.

(Contributed by Matthew Rahtz in :issue:`43224`, with contributions by Serhiy Storchaka and Jelle Zijlstra. PEP written by Mark Mendoza, Matthew Rahtz, Pradeep Kumar Srinivasan, and Vincent Siles.)

PEP 655: Marking individual TypedDict items as required or not-required

:data:`~typing.Required` and :data:`~typing.NotRequired` provide a straightforward way to mark whether individual items in a :class:`~typing.TypedDict` must be present. Previously, this was only possible using inheritance.

All fields are still required by default, unless the total parameter is set to False, in which case all fields are still not-required by default. For example, the following specifies a :class:`!TypedDict` with one required and one not-required key:

class Movie(TypedDict):
   title: str
   year: NotRequired[int]

m1: Movie = {"title": "Black Panther", "year": 2018}  # OK
m2: Movie = {"title": "Star Wars"}  # OK (year is not required)
m3: Movie = {"year": 2022}  # ERROR (missing required field title)

The following definition is equivalent:

class Movie(TypedDict, total=False):
   title: Required[str]
   year: int

See PEP 655 for more details.

(Contributed by David Foster and Jelle Zijlstra in :issue:`47087`. PEP written by David Foster.)

PEP 673: Self type

The new :data:`~typing.Self` annotation provides a simple and intuitive way to annotate methods that return an instance of their class. This behaves the same as the :class:`~typing.TypeVar`-based approach :pep:`specified in PEP 484 <484#annotating-instance-and-class-methods>`, but is more concise and easier to follow.

Common use cases include alternative constructors provided as :func:`classmethod <classmethod>`s, and :meth:`~object.__enter__` methods that return self:

class MyLock:
    def __enter__(self) -> Self:
        self.lock()
        return self

    ...

class MyInt:
    @classmethod
    def fromhex(cls, s: str) -> Self:
        return cls(int(s, 16))

    ...

:data:`~typing.Self` can also be used to annotate method parameters or attributes of the same type as their enclosing class.

See PEP 673 for more details.

(Contributed by James Hilton-Balfe in :issue:`46534`. PEP written by Pradeep Kumar Srinivasan and James Hilton-Balfe.)

PEP 675: Arbitrary literal string type

The new :data:`~typing.LiteralString` annotation may be used to indicate that a function parameter can be of any literal string type. This allows a function to accept arbitrary literal string types, as well as strings created from other literal strings. Type checkers can then enforce that sensitive functions, such as those that execute SQL statements or shell commands, are called only with static arguments, providing protection against injection attacks.

For example, a SQL query function could be annotated as follows:

def run_query(sql: LiteralString) -> ...
    ...

def caller(
    arbitrary_string: str,
    query_string: LiteralString,
    table_name: LiteralString,
) -> None:
    run_query("SELECT * FROM students")       # ok
    run_query(query_string)                   # ok
    run_query("SELECT * FROM " + table_name)  # ok
    run_query(arbitrary_string)               # type checker error
    run_query(                                # type checker error
        f"SELECT * FROM students WHERE name = {arbitrary_string}"
    )

See PEP 675 for more details.

(Contributed by Jelle Zijlstra in :issue:`47088`. PEP written by Pradeep Kumar Srinivasan and Graham Bleaney.)

PEP 681: Data class transforms

:data:`~typing.dataclass_transform` may be used to decorate a class, metaclass, or a function that is itself a decorator. The presence of @dataclass_transform() tells a static type checker that the decorated object performs runtime "magic" that transforms a class, giving it :func:`dataclass <dataclasses.dataclass>`-like behaviors.

For example:

# The create_model decorator is defined by a library.
@typing.dataclass_transform()
def create_model(cls: Type[T]) -> Type[T]:
    cls.__init__ = ...
    cls.__eq__ = ...
    cls.__ne__ = ...
    return cls

# The create_model decorator can now be used to create new model classes:
@create_model
class CustomerModel:
    id: int
    name: str

c = CustomerModel(id=327, name="Eric Idle")

See PEP 681 for more details.

(Contributed by Jelle Zijlstra in :gh:`91860`. PEP written by Erik De Bonte and Eric Traut.)

PEP 563 may not be the future

PEP 563 Postponed Evaluation of Annotations (the from __future__ import annotations :ref:`future statement <future>`) that was originally planned for release in Python 3.10 has been put on hold indefinitely. See this message from the Steering Council for more information.

Other Language Changes

Other CPython Implementation Changes

New Modules

Improved Modules

asyncio

contextlib

dataclasses

datetime

enum

fcntl

fractions

functools

  • :func:`functools.singledispatch` now supports :data:`types.UnionType` and :data:`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 :issue:`46014`.)

gzip

  • The :func:`gzip.compress` function is now faster when used with the mtime=0 argument as it delegates the compression entirely to a single :func:`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 :mod:`gzip` module. Now, when using :func:`~gzip.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

IDLE and idlelib

  • Apply syntax highlighting to .pyi files. (Contributed by Alex Waygood and Terry Jan Reedy in :issue:`45447`.)
  • Include prompts when saving Shell with inputs and outputs. (Contributed by Terry Jan Reedy in :gh:`95191`.)

inspect

locale

logging

math

operator

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

os

pathlib

re

  • Atomic grouping ((?>...)) and possessive quantifiers (*+, ++, ?+, {m,n}+) are now supported in regular expressions. (Contributed by Jeffrey C. Jacobs and Serhiy Storchaka in :issue:`433030`.)

shutil

socket

sqlite3

string

sys

sysconfig

  • Three new :ref:`installation schemes <installation_paths>` (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 :func:`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 :mod:`venv`. (Contributed by Miro Hrončok in :issue:`45413`.)

tempfile

threading

time

  • On Unix, :func:`time.sleep` now uses the clock_nanosleep() or nanosleep() function, if available, which has a resolution of 1 nanosecond (10-9 seconds), rather than using select() which has a resolution of 1 microsecond (10-6 seconds). (Contributed by Benjamin Szőke and Victor Stinner in :issue:`21302`.)
  • On Windows 8.1 and newer, :func:`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 :issue:`21302` and :issue:`45429`.)

tkinter

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

traceback

typing

For major changes, see :ref:`new-feat-related-type-hints-311`.

unicodedata

  • The Unicode database has been updated to version 14.0.0. (Contributed by Benjamin Peterson in :issue:`45190`).

unittest

venv

  • When new Python virtual environments are created, the venv :ref:`sysconfig installation scheme <installation_paths>` 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 :issue:`45413`.)

warnings

zipfile

Optimizations

This section covers specific optimizations independent of the :ref:`whatsnew311-faster-cpython` project, which is covered in its own section.

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: :ref:`whatsnew311-faster-startup` and :ref:`whatsnew311-faster-runtime`. Optimizations not covered by this project are listed separately under :ref:`whatsnew311-optimizations`.

Faster Startup

Frozen imports / Static code objects

Python caches :term:`bytecode` in the :ref:`__pycache__ <tut-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 :ref:`codeobjects` (and bytecode) are statically allocated by the interpreter. This reduces the steps in module execution process to:

Statically allocated code object -> Evaluate

Interpreter startup is now 10-15% faster in Python 3.11. This has a big impact for short-running programs using 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 :ref:`frame objects <frame-objects>` are now created only when requested by debuggers or by Python introspection functions such as :func:`sys._getframe` and :func:`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 :issue:`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 :func:`sys.setrecursionlimit`). We measured a 1-3% improvement in pyperformance.

(Contributed by Pablo Galindo and Mark Shannon in :issue:`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 :term:`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 :class:`int`, :class:`float` and :class:`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 :class:`list`, :class:`tuple` and :class:`dict` directly index the underlying data structures.

Subscripting custom :meth:`~object.__getitem__` is also inlined similar to :ref:`inline-calls`.

 10-25% Irit Katriel, Mark Shannon
Store subscript a[i] = z Similar to subscripting specialization above. 10-25% Dennis Sweeney
Calls

f(arg)

C(arg)

 Calls to common builtin (C) functions and types such as :func:`len` and :class:`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 :class:`list` and :class:`tuple`. Avoids internal calling convention. 8% Brandt Bucher
[1]A similar optimization already existed since Python 3.8. 3.11 specializes for more forms and reduces some overhead.
[2]A similar optimization already existed since Python 3.10. 3.11 specializes for more forms. Furthermore, all attribute loads should be sped up by :issue:`45947`.

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 :issue:`45340` and :issue:`40116`.)
  • "Zero-cost" exceptions are implemented, eliminating the cost of :keyword:`try` statements when no exception is raised. (Contributed by Mark Shannon in :issue:`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 :issue:`45711`.)
  • :mod:`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.

About

Faster CPython explores optimizations for :term:`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 :opcode:`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
:opcode:`BINARY_OP` Replaced all numeric binary/in-place opcodes with a single opcode
Decouples argument shifting for methods from handling of keyword arguments; allows better specialization of calls
Stack manipulation instructions
Now performs check but doesn't jump
See [3]; TRUE, FALSE, NONE and NOT_NONE variants for each direction
:opcode:`BEFORE_WITH` :keyword:`with` block setup
[3]All jump opcodes are now relative, including the existing :opcode:`!JUMP_IF_TRUE_OR_POP` and :opcode:`!JUMP_IF_FALSE_OR_POP`. The argument is now an offset from the current instruction rather than an absolute location.

Changed/removed opcodes

Deprecated

This section lists Python APIs that have been deprecated in Python 3.11.

Deprecated C APIs are :ref:`listed separately <whatsnew311-c-api-deprecated>`.

Language/Builtins

Modules

Standard Library

Pending Removal in Python 3.12

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

C APIs pending removal are :ref:`listed separately <whatsnew311-c-api-pending-removal>`.

Removed

This section lists Python APIs that have been removed in Python 3.11.

Removed C APIs are :ref:`listed separately <whatsnew311-c-api-removed>`.

Porting to Python 3.11

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

Porting notes for the C API are :ref:`listed separately <whatsnew311-c-api-porting>`.

Build Changes

C API Changes

New Features

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

  • :c:func:`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 :issue:`45711`.)

  • :c:func:`PyErr_GetExcInfo()` now derives the type and traceback fields of the result from the exception instance (the value field). (Contributed by Irit Katriel in :issue:`45711`.)

  • :c:struct:`_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 :issue:`46608`.)

  • :c:func:`_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.

  • :c:func:`!PyCode_New` and :c:func:`!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.

  • :c:type:`PyCodeObject` no longer has the co_code, co_varnames, co_cellvars and co_freevars fields. Instead, use :c:func:`PyCode_GetCode`, :c:func:`PyCode_GetVarnames`, :c:func:`PyCode_GetCellvars` and :c:func:`PyCode_GetFreevars` respectively to access them via the C API. (Contributed by Brandt Bucher in :issue:`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 :c:func:`PyType_Ready` function now raises an error if a type is defined with the :c:macro:`Py_TPFLAGS_HAVE_GC` flag set but has no traverse function (:c:member:`PyTypeObject.tp_traverse`). (Contributed by Victor Stinner in :issue:`44263`.)

  • Heap types with the :c:macro:`Py_TPFLAGS_IMMUTABLETYPE` flag can now inherit the PEP 590 vectorcall protocol. Previously, this was only possible for :ref:`static types <static-types>`. (Contributed by Erlend E. Aasland in :issue:`43908`)

  • Since :c:func:`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 :c:func:`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 :issue:`39573`.)

  • Since :c:func:`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 :c:func:`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 :issue:`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 :issue:`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: :ref:`Include Files <api-includes>`. If they have been included directly, consider including Python.h instead. (Contributed by Victor Stinner in :issue:`35134`.)

  • The :c:func:`!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 :issue:`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`.)

Deprecated

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.

Removed

Notable changes in 3.11.4

tarfile

Notable changes in 3.11.5

OpenSSL

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