What's New In Python 3.11?

Enhanced 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 dictionary 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

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

PEP 646: Variadic generics?

PEP 484 introduced TypeVar, enabling creation of generics parameterised with a single type. PEP 646 introduces TypeVarTuple, enabling parameterisation with an arbitrary number of types. In other words, a 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 bpo-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?

Required and NotRequired provide a straightforward way to mark whether individual items in a TypedDict must be present. Previously this was only possible using inheritance.

Fields are still required by default, unless the total=False parameter is set. For example, the following specifies a dictionary 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 bpo-47087. PEP written by David Foster.)

PEP 673: Self type?

The new Self annotation provides a simple and intuitive way to annotate methods that return an instance of their class. This behaves the same as the TypeVar-based approach specified in PEP 484 but is more concise and easier to follow.

Common use cases include alternative constructors provided as classmethods and __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))

    ...

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 bpo-46534. PEP written by Pradeep Kumar Srinivasan and James Hilton-Balfe.)

PEP 675: Arbitrary literal string type?

The new 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 bpo-47088. PEP written by Pradeep Kumar Srinivasan and Graham Bleaney.)

PEP 681: Data Class Transforms?

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 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, like this:
@create_model
class CustomerModel:
    id: int
    name: str

c = CustomerModel(id=327, name="John Smith")

See PEP 681 for more details.

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

asyncio?

• Add raw datagram socket functions to the event loop: sock_sendto(), sock_recvfrom() and sock_recvfrom_into(). (Contributed by Alex Gr?nholm in bpo-46805.)

• Add start_tls() method for upgrading existing stream-based connections to TLS. (Contributed by Ian Good in bpo-34975.)

• Add Barrier class to the synchronization primitives of the asyncio library. (Contributed by Yves Duprat and Andrew Svetlov in gh-87518.)

datetime?

• Add datetime.UTC, a convenience alias for datetime.timezone.utc. (Contributed by Kabir Kwatra in gh-91973.)

• datetime.date.fromisoformat(), datetime.time.fromisoformat() and datetime.datetime.fromisoformat() can now be used to parse most ISO 8601 formats (barring only those that support fractional hours and minutes). (Contributed by Paul Ganssle in gh-80010.)

fractions?

• Support PEP 515-style initialization of Fraction from string. (Contributed by Sergey B Kirpichev in bpo-44258.)

• Fraction now implements an __int__ method, so that an isinstance(some_fraction, typing.SupportsInt) check passes. (Contributed by Mark Dickinson in 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.)

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

IDLE and idlelib?

• Apply syntax highlighting to .pyi files. (Contributed by Alex Waygood and Terry Jan Reedy in bpo-45447.)

inspect?

• Add inspect.getmembers_static(): return all members without triggering dynamic lookup via the descriptor protocol. (Contributed by Weipeng Hong in bpo-30533.)

• Add inspect.ismethodwrapper() for checking if the type of an object is a MethodWrapperType. (Contributed by Hakan ?elik in bpo-29418.)

• Change the frame-related functions in the inspect module to return a regular object (that is backwards compatible with the old tuple-like interface) that include the extended PEP 657 position information (end line number, column and end column). The affected functions are: inspect.getframeinfo(), inspect.getouterframes(), inspect.getinnerframes(), inspect.stack() and inspect.trace(). (Contributed by Pablo Galindo in gh-88116)

locale?

• Add locale.getencoding() to get the current locale encoding. It is similar to locale.getpreferredencoding(False) but ignores the Python UTF-8 Mode.

math?

• Add math.exp2(): return 2 raised to the power of x. (Contributed by Gideon Mitchell in bpo-45917.)

• Add math.cbrt(): return the cube root of x. (Contributed by Ajith Ramachandran in bpo-44357.)

• The behaviour of two math.pow() corner cases was changed, for consistency with the IEEE 754 specification. The operations math.pow(0.0, -math.inf) and math.pow(-0.0, -math.inf) now return inf. Previously they raised ValueError. (Contributed by Mark Dickinson in bpo-44339.)

• The math.nan value is now always available. (Contributed by Victor Stinner in 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 Dong-hee Na in bpo-44611.)

pathlib?

• glob() and rglob() return only directories if pattern ends with a pathname components separator: sep or altsep. (Contributed by Eisuke Kawasima in bpo-22276 and bpo-33392.)

re?

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

shutil?

• Add optional parameter dir_fd in shutil.rmtree(). (Contributed by Serhiy Storchaka in bpo-46245.)

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?

• You can now disable the authorizer by passing None to set_authorizer(). (Contributed by Erlend E. Aasland in bpo-44491.)

• Collation name create_collation() can now contain any Unicode character. Collation names with invalid characters now raise UnicodeEncodeError instead of sqlite3.ProgrammingError. (Contributed by Erlend E. Aasland in bpo-44688.)

• sqlite3 exceptions now include the SQLite extended error code as sqlite_errorcode and the SQLite error name as sqlite_errorname. (Contributed by Aviv Palivoda, Daniel Shahaf, and Erlend E. Aasland in bpo-16379 and bpo-24139.)

• Add setlimit() and getlimit() to sqlite3.Connection for setting and getting SQLite limits by connection basis. (Contributed by Erlend E. Aasland in bpo-45243.)

• sqlite3 now sets sqlite3.threadsafety based on the default threading mode the underlying SQLite library has been compiled with. (Contributed by Erlend E. Aasland in bpo-45613.)

• sqlite3 C callbacks now use unraisable exceptions if callback tracebacks are enabled. Users can now register an unraisable hook handler to improve their debug experience. (Contributed by Erlend E. Aasland in bpo-45828.)

• Fetch across rollback no longer raises InterfaceError. Instead we leave it to the SQLite library to handle these cases. (Contributed by Erlend E. Aasland in bpo-44092.)

• Add serialize() and deserialize() to sqlite3.Connection for serializing and deserializing databases. (Contributed by Erlend E. Aasland in bpo-41930.)

• Add create_window_function() to sqlite3.Connection for creating aggregate window functions. (Contributed by Erlend E. Aasland in bpo-34916.)

• Add blobopen() to sqlite3.Connection. sqlite3.Blob allows incremental I/O operations on blobs. (Contributed by Aviv Palivoda and Erlend E. Aasland in bpo-24905)

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

• Add sys.exception() which returns the active exception instance (equivalent to sys.exc_info()[1]). (Contributed by Irit Katriel in bpo-46328.)

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

sysconfig?

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

threading?

• On Unix, if the sem_clockwait() function is available in the C library (glibc 2.30 and newer), the threading.Lock.acquire() method now uses the monotonic clock (time.CLOCK_MONOTONIC) for the timeout, rather than using the system clock (time.CLOCK_REALTIME), to not be affected by system clock changes. (Contributed by Victor Stinner in bpo-41710.)

time?

• On Unix, 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 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, Dong-hee Na, Eryk Sun and Victor Stinner in bpo-21302 and bpo-45429.)

typing?

For major changes, see 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 Abey 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.)

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

unicodedata?

• The Unicode database has been updated to version 14.0.0. (bpo-45190).

unittest?

• Added methods enterContext() and enterClassContext() of class TestCase, method enterAsyncContext() of class IsolatedAsyncioTestCase and function unittest.enterModuleContext(). (Contributed by Serhiy Storchaka in bpo-45046.)

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?

• warnings.catch_warnings() now accepts arguments for warnings.simplefilter(), providing a more concise way to locally ignore warnings or convert them to errors. (Contributed by Zac Hatfield-Dodds in bpo-47074.)

zipfile?

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

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.

Faster Startup?

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

Statically allocated code object -> Evaluate

Faster Runtime?

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

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

FAQ?

About?

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.

Changes in the Python API?

• Prohibited passing non-concurrent.futures.ThreadPoolExecutor executors to loop.set_default_executor() following a deprecation in Python 3.8. (Contributed by Illia Volochii in bpo-43234.)

• open(), io.open(), codecs.open() and fileinput.FileInput no longer accept 'U' ("universal newline") in the file mode. This flag was deprecated since Python 3.3. In Python 3, the "universal newline" is used by default when a file is open in text mode. The newline parameter of open() controls how universal newlines works. (Contributed by Victor Stinner in bpo-37330.)

• The pdb module now reads the .pdbrc configuration file with the 'utf-8' encoding. (Contributed by Srinivas Reddy Thatiparthy (?????????? ?????? ?????????) in bpo-41137.)

• When sorting using tuples as keys, the order of the result may differ from earlier releases if the tuple elements don't define a total ordering (see 值比較 for information on total ordering). It's generally true that the result of sorting simply isn't well-defined in the absence of a total ordering on list elements.

• calendar: The calendar.LocaleTextCalendar and calendar.LocaleHTMLCalendar classes now use locale.getlocale(), instead of using locale.getdefaultlocale(), if no locale is specified. (Contributed by Victor Stinner in bpo-46659.)

• Global inline flags (e.g. (?i)) can now only be used at the start of the regular expressions. Using them not at the start of expression was deprecated since Python 3.6. (Contributed by Serhiy Storchaka in bpo-47066.)

• re module: Fix a few long-standing bugs where, in rare cases, capturing group could get wrong result. So the result may be different than before. (Contributed by Ma Lin in bpo-35859.)

• The population parameter of random.sample() must be a sequence. Automatic conversion of sets to lists is no longer supported. If the sample size is larger than the population size, a ValueError is raised. (Contributed by Raymond Hettinger in bpo-40465.)

New Features?

• Add a new PyType_GetName() function to get type's short name. (Contributed by Hai Shi in bpo-42035.)

• Add a new PyType_GetQualName() function to get type's qualified name. (Contributed by Hai Shi in bpo-42035.)

• Add new PyThreadState_EnterTracing() and PyThreadState_LeaveTracing() functions to the limited C API to suspend and resume tracing and profiling. (Contributed by Victor Stinner in bpo-43760.)

• Added the Py_Version constant which bears the same value as PY_VERSION_HEX. (Contributed by Gabriele N. Tornetta in bpo-43931.)

• Py_buffer and APIs are now part of the limited API and the stable ABI:

  • PyObject_CheckBuffer()

  • PyObject_GetBuffer()

  • PyBuffer_GetPointer()

  • PyBuffer_SizeFromFormat()

  • PyBuffer_ToContiguous()

  • PyBuffer_FromContiguous()

  • PyBuffer_CopyData()

  • PyBuffer_IsContiguous()

  • PyBuffer_FillContiguousStrides()

  • PyBuffer_FillInfo()

  • PyBuffer_Release()

  • PyMemoryView_FromBuffer()

  • bf_getbuffer and bf_releasebuffer type slots

  (Contributed by Christian Heimes in bpo-45459.)

• Added the PyType_GetModuleByDef function, used to get the module in which a method was defined, in cases where this information is not available directly (via PyCMethod). (Contributed by Petr Viktorin in bpo-46613.)

• Add new functions to pack and unpack C double (serialize and deserialize): PyFloat_Pack2(), PyFloat_Pack4(), PyFloat_Pack8(), PyFloat_Unpack2(), PyFloat_Unpack4() and PyFloat_Unpack8(). (Contributed by Victor Stinner in bpo-46906.)

• Add new functions to get frame object attributes: PyFrame_GetBuiltins(), PyFrame_GetGenerator(), PyFrame_GetGlobals(), PyFrame_GetLasti().

• Added two new functions to get and set the active exception instance: PyErr_GetHandledException() and PyErr_SetHandledException(). These are alternatives to PyErr_SetExcInfo() and PyErr_GetExcInfo() which work with the legacy 3-tuple representation of exceptions. (Contributed by Irit Katriel in bpo-46343.)

• Added the PyConfig.safe_path member. (Contributed by Victor Stinner in gh-57684.)

Porting to Python 3.11?

• 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 a co_code field. Instead, use PyObject_GetAttrString(code_object, "co_code") or PyCode_GetCode() to get the underlying bytes object. (Contributed by Brandt Bucher in bpo-46841 and Ken Jin in gh-92154.)

• 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_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 8
  #  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 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:

  • f_back: use PyFrame_GetBack().

  • f_blockstack: removed.

  • f_builtins: use PyFrame_GetBuiltins().

  • f_code: use PyFrame_GetCode().

  • f_gen: use PyFrame_GetGenerator().

  • f_globals: use PyFrame_GetGlobals().

  • f_iblock: removed.

  • f_lasti: use PyFrame_GetLasti(). Code using f_lasti with PyCode_Addr2Line() should use PyFrame_GetLineNumber() instead; it may be faster.

  • f_lineno: use PyFrame_GetLineNumber()

  • f_locals: use PyFrame_GetLocals().

  • f_stackdepth: removed.

  • f_state: no public API (renamed to f_frame.f_state).

  • f_trace: no public API.

  • f_trace_lines: use PyObject_GetAttrString((PyObject*)frame, "f_trace_lines").

  • f_trace_opcodes: use PyObject_GetAttrString((PyObject*)frame, "f_trace_opcodes").

  • f_localsplus: no public API (renamed to f_frame.localsplus).

  • f_valuestack: removed.

  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:

  • frame: removed, use PyThreadState_GetFrame() (function added to Python 3.9 by bpo-40429). Warning: the function returns a strong reference, need to call Py_XDECREF().

  • tracing: changed, use PyThreadState_EnterTracing() and PyThreadState_LeaveTracing() (functions added to Python 3.11 by bpo-43760).

  • recursion_depth: removed, use (tstate->recursion_limit - tstate->recursion_remaining) instead.

  • stackcheck_counter: removed.

  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.

Deprecated?

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

Removed?

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

  • PyMarshal_WriteLongToFile()

  • PyMarshal_WriteObjectToFile()

  • PyMarshal_ReadObjectFromString()

  • PyMarshal_WriteObjectToString()

  • the Py_MARSHAL_VERSION macro

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