- Release
- Date
This article explains the new features in Python 3.11, compared to 3.10.
For full details, see the changelog <changelog>
.
Note
Prerelease users should be aware that this document is currently in draft form. It will be updated substantially as Python 3.11 moves towards release, so it's worth checking back even after reading earlier versions.
- Python 3.11 is up to 10-60% faster than Python 3.10. On average, we measured a 1.22x speedup on the standard benchmark suite. See Faster CPython for details.
New syntax features:
654
: Exception Groups andexcept*
. (Contributed by Irit Katriel in45292
.)
New typing features:
646
: Variadic generics.655
: Marking individual TypedDict items as required or potentially-missing.673
:Self
type.675
: Arbitrary literal string type.
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 657
for more details. (Contributed by Pablo Galindo, Batuhan Taskaya and Ammar Askar in 43950
.)
Note
This feature requires storing column positions in code objects which may result in a small increase of disk usage of compiled Python files or interpreter memory usage. To avoid storing the extra information and/or deactivate printing the extra traceback information, the -X
no_debug_ranges
command line flag or the PYTHONNODEBUGRANGES
environment variable can be used.
The information used by the enhanced traceback feature is made available as a general API that can be used to correlate bytecode instructions with source code. This information can be retrieved using:
- The
codeobject.co_positions
method in Python. - The :c
PyCode_Addr2Location
function in the C-API.
The -X
no_debug_ranges
option and the environment variable PYTHONNODEBUGRANGES
can be used to disable this feature.
See 657
for more details. (Contributed by Pablo Galindo, Batuhan Taskaya and Ammar Askar in 43950
.)
The add_note
method was added to BaseException
. It can be used to enrich exceptions with context information which is not available at the time when the exception is raised. The notes added appear in the default traceback. See 678
for more details. (Contributed by Irit Katriel in 45607
.)
This section covers major changes affecting 484
type hints and the typing
module.
484
introduced ~typing.TypeVar
, enabling creation of generics parameterised with a single type. 646
introduces ~typing.TypeVarTuple
, enabling parameterisation with an arbitrary number of types. In other words, a ~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 646
for more details.
(Contributed by Matthew Rahtz in 43224
, with contributions by Serhiy Storchaka and Jelle Zijlstra. PEP written by Mark Mendoza, Matthew Rahtz, Pradeep Kumar Srinivasan, and Vincent Siles.)
~typing.Required
and ~typing.NotRequired
provide a straightforward way to mark whether individual items in a ~typing.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 655
for more details.
(Contributed by David Foster and Jelle Zijlstra in 47087
. PEP written by David Foster.)
The new ~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 ~typing.TypeVar
-based approach specified in 484
but is more concise and easier to follow.
Common use cases include alternative constructors provided as classmethods and ~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))
...
~typing.Self
can also be used to annotate method parameters or attributes of the same type as their enclosing class.
See 673
for more details.
(Contributed by James Hilton-Balfe in 46534
. PEP written by Pradeep Kumar Srinivasan and James Hilton-Balfe.)
The new ~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 675
for more details.
(Contributed by Jelle Zijlstra in 47088
. PEP written by Pradeep Kumar Srinivasan and Graham Bleaney.)
The new ~typing.dataclass_transform
annotation may be used to decorate a function that is itself a decorator, a class, or a metaclass. The presence of @dataclass_transform()
tells a static type checker that the decorated function, class, or metaclass performs runtime "magic" that transforms a class, endowing it with 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 681
for more details.
(Contributed by Jelle Zijlstra in 91860
. PEP written by Erik De Bonte and Eric Traut.)
- Starred expressions can be used in
for statements<for>
. (See46725
for more details.) - Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous. (Contributed by Serhiy Storchaka in
33346
.) - A
TypeError
is now raised instead of anAttributeError
incontextlib.ExitStack.enter_context
andcontextlib.AsyncExitStack.enter_async_context
for objects which do not support thecontext manager
orasynchronous context manager
protocols correspondingly. (Contributed by Serhiy Storchaka in44471
.) - A
TypeError
is now raised instead of anAttributeError
inwith
andasync with
statements for objects which do not support thecontext manager
orasynchronous context manager
protocols correspondingly. (Contributed by Serhiy Storchaka in12022
.) - Added
object.__getstate__
which provides the default implementation of the__getstate__()
method.Copying <copy>
andpickling <pickle>
instances of subclasses of builtin typesbytearray
,set
,frozenset
,collections.OrderedDict
,collections.deque
,weakref.WeakSet
, anddatetime.tzinfo
now copies and pickles instance attributes implemented asslots <__slots__>
. (Contributed by Serhiy Storchaka in26579
.)
- Special methods
complex.__complex__
andbytes.__bytes__
are implemented to supporttyping.SupportsComplex
andtyping.SupportsBytes
protocols. (Contributed by Mark Dickinson and Dong-hee Na in24234
.) siphash13
is added as a new internal hashing algorithms. It has similar security properties assiphash24
but it is slightly faster for long inputs.str
,bytes
, and some other types now use it as default algorithm forhash
.552
hash-based pyc files now usesiphash13
, too. (Contributed by Inada Naoki in29410
.)- When an active exception is re-raised by a
raise
statement with no parameters, the traceback attached to this exception is now alwayssys.exc_info()[1].__traceback__
. This means that changes made to the traceback in the currentexcept
clause are reflected in the re-raised exception. (Contributed by Irit Katriel in45711
.) - The interpreter state's representation of handled exceptions (a.k.a exc_info, or _PyErr_StackItem) now has only the
exc_value
field,exc_type
andexc_traceback
have been removed as their values can be derived fromexc_value
. (Contributed by Irit Katriel in45711
.) - A new command line option for the Windows installer
AppendPath
has been added. It behaves similiar toPrependPath
but appends the install and scripts directories instead of prepending them. (Contributed by Bastian Neuburger in44934
.)
- A new module,
tomllib
, was added for parsing TOML. (Contributed by Taneli Hukkinen in40059
.) wsgiref.types
, containing WSGI-specific types for static type checking, was added. (Contributed by Sebastian Rittau in42012
.)
- Add raw datagram socket functions to the event loop:
~asyncio.AbstractEventLoop.sock_sendto
,~asyncio.AbstractEventLoop.sock_recvfrom
and~asyncio.AbstractEventLoop.sock_recvfrom_into
. (Contributed by Alex Grönholm in46805
.) - Add
~asyncio.streams.StreamWriter.start_tls
method for upgrading existing stream-based connections to TLS. (Contributed by Ian Good in34975
.)
- Support PEP 515-style initialization of
~fractions.Fraction
from string. (Contributed by Sergey B Kirpichev in44258
.) ~fractions.Fraction
now implements an__int__
method, so that anisinstance(some_fraction, typing.SupportsInt)
check passes. (Contributed by Mark Dickinson in44547
.)
functools.singledispatch
now supportstypes.UnionType
andtyping.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
46014
.)
hashlib.blake2b
andhashlib.blake2s
now prefer libb2 over Python's vendored copy. (Contributed by Christian Heimes in47095
.)- 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. Thehashlib
module prefers optimized SHA3 and SHAKE implementations from OpenSSL. The change affects only installations without OpenSSL support. (Contributed by Christian Heimes in47098
.)
- Apply syntax highlighting to .pyi files. (Contributed by Alex Waygood and Terry Jan Reedy in
45447
.)
- Add
inspect.getmembers_static
: return all members without triggering dynamic lookup via the descriptor protocol. (Contributed by Weipeng Hong in30533
.) - Add
inspect.ismethodwrapper
for checking if the type of an object is a~types.MethodWrapperType
. (Contributed by Hakan Çelik in29418
.) - 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 extended657
position information (end line number, column and end column). The affected functions are:inspect.getframeinfo
,inspect.getouterframes
,inspect.getinnerframes
,inspect.stack
andinspect.trace
. (Contributed by Pablo Galindo in88116
)
- Add
locale.getencoding
to get the current locale encoding. It is similar tolocale.getpreferredencoding(False)
but ignores thePython UTF-8 Mode <utf8-mode>
.
- Add
math.exp2
: return 2 raised to the power of x. (Contributed by Gideon Mitchell in45917
.) - Add
math.cbrt
: return the cube root of x. (Contributed by Ajith Ramachandran in44357
.) - The behaviour of two
math.pow
corner cases was changed, for consistency with the IEEE 754 specification. The operationsmath.pow(0.0, -math.inf)
andmath.pow(-0.0, -math.inf)
now returninf
. Previously they raisedValueError
. (Contributed by Mark Dickinson in44339
.) - The
math.nan
value is now always available. (Contributed by Victor Stinner in46917
.)
- A new function
operator.call
has been added, such thatoperator.call(obj, *args, **kwargs) == obj(*args, **kwargs)
. (Contributed by Antony Lee in44019
.)
- On Windows,
os.urandom
now usesBCryptGenRandom()
, instead ofCryptGenRandom()
which is deprecated. (Contributed by Dong-hee Na in44611
.)
~pathlib.Path.glob
and~pathlib.Path.rglob
return only directories if pattern ends with a pathname components separator:~os.sep
or~os.altsep
. (Contributed by Eisuke Kawasima in22276
and33392
.)
- Atomic grouping (
(?>...)
) and possessive quantifiers (*+
,++
,?+
,{m,n}+
) are now supported in regular expressions. (Contributed by Jeffrey C. Jacobs and Serhiy Storchaka in433030
.)
- Add optional parameter dir_fd in
shutil.rmtree
. (Contributed by Serhiy Storchaka in46245
.)
- Add CAN Socket support for NetBSD. (Contributed by Thomas Klausner in
30512
.) ~socket.create_connection
has an option to raise, in case of failure to connect, anExceptionGroup
containing all errors instead of only raising the last error. (Contributed by Irit Katriel in29980
).
- You can now disable the authorizer by passing
None
to~sqlite3.Connection.set_authorizer
. (Contributed by Erlend E. Aasland in44491
.) - Collation name
~sqlite3.Connection.create_collation
can now contain any Unicode character. Collation names with invalid characters now raiseUnicodeEncodeError
instead ofsqlite3.ProgrammingError
. (Contributed by Erlend E. Aasland in44688
.) sqlite3
exceptions now include the SQLite extended error code as~sqlite3.Error.sqlite_errorcode
and the SQLite error name as~sqlite3.Error.sqlite_errorname
. (Contributed by Aviv Palivoda, Daniel Shahaf, and Erlend E. Aasland in16379
and24139
.)- Add
~sqlite3.Connection.setlimit
and~sqlite3.Connection.getlimit
tosqlite3.Connection
for setting and getting SQLite limits by connection basis. (Contributed by Erlend E. Aasland in45243
.) sqlite3
now setssqlite3.threadsafety
based on the default threading mode the underlying SQLite library has been compiled with. (Contributed by Erlend E. Aasland in45613
.)sqlite3
C callbacks now use unraisable exceptions if callback tracebacks are enabled. Users can now register anunraisable hook handler <sys.unraisablehook>
to improve their debug experience. (Contributed by Erlend E. Aasland in45828
.)- Fetch across rollback no longer raises
~sqlite3.InterfaceError
. Instead we leave it to the SQLite library to handle these cases. (Contributed by Erlend E. Aasland in44092
.) - Add
~sqlite3.Connection.serialize
and~sqlite3.Connection.deserialize
tosqlite3.Connection
for serializing and deserializing databases. (Contributed by Erlend E. Aasland in41930
.) - Add
~sqlite3.Connection.create_window_function
tosqlite3.Connection
for creating aggregate window functions. (Contributed by Erlend E. Aasland in34916
.) - Add
~sqlite3.Connection.blobopen
tosqlite3.Connection
.sqlite3.Blob
allows incremental I/O operations on blobs. (Contributed by Aviv Palivoda and Erlend E. Aasland in24905
)
sys.exc_info
now derives thetype
andtraceback
fields from thevalue
(the exception instance), so when an exception is modified while it is being handled, the changes are reflected in the results of subsequent calls toexc_info
. (Contributed by Irit Katriel in45711
.)- Add
sys.exception
which returns the active exception instance (equivalent tosys.exc_info()[1]
). (Contributed by Irit Katriel in46328
.)
- Two new
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 modifysysconfig.get_preferred_scheme
. Third party code that creates new virtual environments should use the new venv installation scheme to determine the paths, as doesvenv
. (Contributed by Miro Hrončok in45413
.)
- On Unix, if the
sem_clockwait()
function is available in the C library (glibc 2.30 and newer), thethreading.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 in41710
.)
- On Unix,
time.sleep
now uses theclock_nanosleep()
ornanosleep()
function, if available, which has a resolution of 1 nanosecond (10-9 seconds), rather than usingselect()
which has a resolution of 1 microsecond (10-6 seconds). (Contributed by Benjamin Szőke and Victor Stinner in21302
.) - 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 in21302
and45429
.)
For major changes, see new-feat-related-type-hints-311
.
- Add
typing.assert_never
andtyping.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 anAssertionError
. (Contributed by Jelle Zijlstra in90633
.) - 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 in90572
.) - 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 in90638
.) - 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 in91154
.) - The
typing.final
decorator now sets the__final__
attributed on the decorated object. (Contributed by Jelle Zijlstra in90500
.) - 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 in89263
.) ~typing.NamedTuple
subclasses can be generic. (Contributed by Serhiy Storchaka in43923
.)
- The Unicode database has been updated to version 14.0.0. (
45190
).
- When new Python virtual environments are created, the venv
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 in45413
.)
warnings.catch_warnings
now accepts arguments forwarnings.simplefilter
, providing a more concise way to locally ignore warnings or convert them to errors. (Contributed by Zac Hatfield-Dodds in47074
.)
- 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
28080
.)
- On FreeBSD, the
F_DUP2FD
andF_DUP2FD_CLOEXEC
flags respectively are supported, the former equals todup2
usage while the latter set theFD_CLOEXEC
flag in addition.
- Compiler now optimizes simple C-style formatting with literal format containing only format codes
%s
,%r
and%a
and makes it as fast as corresponding f-string expression. (Contributed by Serhiy Storchaka in28307
.) - "Zero-cost" exceptions are implemented. The cost of
try
statements is almost eliminated when no exception is raised. (Contributed by Mark Shannon in40222
.) - Pure ASCII strings are now normalized in constant time by
unicodedata.normalize
. (Contributed by Dong-hee Na in44987
.) math
functions~math.comb
and~math.perm
are now up to 10 times or more faster for large arguments (the speed up is larger for larger k). (Contributed by Serhiy Storchaka in37295
.)- Dict don't store hash value when all inserted keys are Unicode objects. This reduces dict size. For example,
sys.getsizeof(dict.fromkeys("abcdefg"))
becomes 272 bytes from 352 bytes on 64bit platform. (Contributed by Inada Naoki in46845
.) 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.
CPython 3.11 is on average 1.22x faster than CPython 3.10 when measured with the pyperformance benchmark suite, and compiled with GCC on Ubuntu Linux. Depending on your workload, the speedup could be up to 10-60% faster.
This project focuses on two major areas in Python: faster startup and faster runtime. Other optimizations not under this project are listed in Optimizations.
Python caches bytecode in the __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 code objects (and bytecode) are statically allocated by the interpreter. This reduces the steps in module execution process to this:
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 numerous issues.)
Python frames are created whenever Python calls a Python function. This frame holds execution information. 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 required by debuggers. 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 44590
.)
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. This speeds up most of such calls. In simple recursive functions like fibonacci or factorial, a 1.7x speedup was observed. This also means recursive functions can recurse significantly deeper (if the user increases the recursion limit). We measured a 1-3% improvement in pyperformance.
(Contributed by Pablo Galindo and Mark Shannon in 45256
.)
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. This reduces the overhead during execution.
Python will only specialize when it sees code that is "hot" (executed multiple times). This prevents Python from wasting time for 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. This allows specialization to adapt to new circumstances.
(PEP written by Mark Shannon, with ideas inspired by Stefan Brunthaler. See 659
for more information.)
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, Dong-hee Na, Brandt Bucher, Dennis Sweeney |
Subscript | a[i] |
Subscripting container types such as Subscripting custom |
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 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 |
- Objects now require less memory due to lazily created object namespaces. Their namespace dictionaries now also share keys more freely. (Contributed Mark Shannon in
45340
and40116
.) - 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
45711
.)
A: You don't have to change your code. Write Pythonic code that follows common best practices. The Faster CPython project optimizes for common code patterns we observe.
Q: Will CPython 3.11 use more memory?
A: Maybe not. We don't expect memory use to exceed 20% more than 3.10. This is offset by memory optimizations for frame objects and object dictionaries as mentioned above.
Q: I don't see any speedups in my workload. Why?
A: 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 speedup. 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!
Q: Is there a JIT compiler?
A: No. We're still exploring other optimizations.
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.
- Replaced all numeric
BINARY_*
andINPLACE_*
instructions with a singleBINARY_OP
implementation. - Replaced the three call instructions:
CALL_FUNCTION
,CALL_FUNCTION_KW
andCALL_METHOD
withPUSH_NULL
,PRECALL
,CALL
, andKW_NAMES
. This decouples the argument shifting for methods from the handling of keyword arguments and allows better specialization of calls. - Removed
COPY_DICT_WITHOUT_KEYS
andGEN_START
. MATCH_CLASS
andMATCH_KEYS
no longer push an additional boolean value indicating whether the match succeeded or failed. Instead, they indicate failure withNone
(where a tuple of extracted values would otherwise be).- Replace several stack manipulation instructions (
DUP_TOP
,DUP_TOP_TWO
,ROT_TWO
,ROT_THREE
,ROT_FOUR
, andROT_N
) with newCOPY
andSWAP
instructions. - Replaced
JUMP_IF_NOT_EXC_MATCH
byCHECK_EXC_MATCH
which performs the check but does not jump. - Replaced
JUMP_IF_NOT_EG_MATCH
byCHECK_EG_MATCH
which performs the check but does not jump. - Replaced
JUMP_ABSOLUTE
by the relativeJUMP_BACKWARD
. - Added
JUMP_BACKWARD_NO_INTERRUPT
, which is used in certain loops where it is undesirable to handle interrupts. - Replaced
POP_JUMP_IF_TRUE
andPOP_JUMP_IF_FALSE
by the relativePOP_JUMP_FORWARD_IF_TRUE
,POP_JUMP_BACKWARD_IF_TRUE
,POP_JUMP_FORWARD_IF_FALSE
andPOP_JUMP_BACKWARD_IF_FALSE
. - Added
POP_JUMP_FORWARD_IF_NOT_NONE
,POP_JUMP_BACKWARD_IF_NOT_NONE
,POP_JUMP_FORWARD_IF_NONE
andPOP_JUMP_BACKWARD_IF_NONE
opcodes to speed up conditional jumps. JUMP_IF_TRUE_OR_POP
andJUMP_IF_FALSE_OR_POP
are now relative rather than absolute.
- Octal escapes with value larger than
0o377
now produce aDeprecationWarning
. In a future Python version they will be aSyntaxWarning
and eventually aSyntaxError
. (Contributed by Serhiy Storchaka in81548
.) - The
lib2to3
package and2to3
tool are now deprecated and may not be able to parse Python 3.10 or newer. See the617
(New PEG parser for CPython). (Contributed by Victor Stinner in40360
.) - Undocumented modules
sre_compile
,sre_constants
andsre_parse
are now deprecated. (Contributed by Serhiy Storchaka in47152
.) webbrowser.MacOSX
is deprecated and will be removed in Python 3.13. It is untested and undocumented and also not used by webbrowser itself. (Contributed by Dong-hee Na in42255
.)- The behavior of returning a value from a
~unittest.TestCase
and~unittest.IsolatedAsyncioTestCase
test methods (other than the defaultNone
value), is now deprecated. Deprecated the following
unittest
functions, scheduled for removal in Python 3.13:unittest.findTestCases
unittest.makeSuite
unittest.getTestCaseNames
Use
~unittest.TestLoader
method instead:unittest.TestLoader.loadTestsFromModule
unittest.TestLoader.loadTestsFromTestCase
unittest.TestLoader.getTestCaseNames
(Contributed by Erlend E. Aasland in
5846
.)- The
turtle.RawTurtle.settiltangle
is deprecated since Python 3.1, it now emits a deprecation warning and will be removed in Python 3.13. Useturtle.RawTurtle.tiltangle
instead (it was earlier incorrectly marked as deprecated, its docstring is now corrected). (Contributed by Hugo van Kemenade in45837
.) - The delegation of
int
to__trunc__
is now deprecated. Callingint(a)
whentype(a)
implements__trunc__
but not__int__
or__index__
now raises aDeprecationWarning
. (Contributed by Zackery Spytz in44977
.) The following have been deprecated in
configparser
since Python 3.2. Their deprecation warnings have now been updated to note they will removed in Python 3.12:- the
configparser.SafeConfigParser
class - the
configparser.ParsingError.filename
property - the
configparser.ParsingError.readfp
method
(Contributed by Hugo van Kemenade in
45173
.)- the
configparser.LegacyInterpolation
has been deprecated in the docstring since Python 3.2. It now emits aDeprecationWarning
and will be removed in Python 3.13. Useconfigparser.BasicInterpolation
orconfigparser.ExtendedInterpolation
instead. (Contributed by Hugo van Kemenade in46607
.)- The
locale.getdefaultlocale
function is deprecated and will be removed in Python 3.13. Uselocale.setlocale
,locale.getpreferredencoding(False) <locale.getpreferredencoding>
andlocale.getlocale
functions instead. (Contributed by Victor Stinner in46659
.) - The
asynchat
,asyncore
andsmtpd
modules have been deprecated since at least Python 3.6. Their documentation and deprecation warnings have now been updated to note they will removed in Python 3.12 (594
). (Contributed by Hugo van Kemenade in47022
.) 594
led to the deprecations of the following modules which are slated for removal in Python 3.13:aifc
audioop
cgi
cgitb
chunk
crypt
imghdr
mailcap
msilib
nis
nntplib
ossaudiodev
pipes
sndhdr
spwd
sunau
telnetlib
uu
xdrlib
(Contributed by Brett Cannon in
47061
and Victor Stinner in68966
.)- More strict rules will be applied now applied for numerical group references and group names in regular expressions in future Python versions. Only sequence of ASCII digits will be now accepted as a numerical reference. The group name in bytes patterns and replacement strings could only contain ASCII letters and digits and underscore. For now, a deprecation warning is raised for such syntax. (Contributed by Serhiy Storchaka in
91760
.)
smtpd.MailmanProxy
is now removed as it is unusable without an external module,mailman
. (Contributed by Dong-hee Na in35800
.)The
binhex
module, deprecated in Python 3.9, is now removed. The followingbinascii
functions, deprecated in Python 3.9, are now also removed:a2b_hqx()
,b2a_hqx()
;rlecode_hqx()
,rledecode_hqx()
.
The
binascii.crc_hqx
function remains available.(Contributed by Victor Stinner in
45085
.)- The distutils
bdist_msi
command, deprecated in Python 3.9, is now removed. Usebdist_wheel
(wheel packages) instead. (Contributed by Hugo van Kemenade in45124
.) - 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 optionSO_REUSEADDR
in UDP. (Contributed by Hugo van Kemenade in45129
.) - Removed
__getitem__
methods ofxml.dom.pulldom.DOMEventStream
,wsgiref.util.FileWrapper
andfileinput.FileInput
, deprecated since Python 3.9. (Contributed by Hugo van Kemenade in45132
.) The following deprecated functions and methods are removed in the
gettext
module:~gettext.lgettext
,~gettext.ldgettext
,~gettext.lngettext
and~gettext.ldngettext
.Function
~gettext.bind_textdomain_codeset
, methods~gettext.NullTranslations.output_charset
and~gettext.NullTranslations.set_output_charset
, and the codeset parameter of functions~gettext.translation
and~gettext.install
are also removed, since they are only used for thel*gettext()
functions. (Contributed by Dong-hee Na and Serhiy Storchaka in44235
.)- The
@asyncio.coroutine <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. Useasync def
instead. (Contributed by Illia Volochii in43216
.) asyncio.coroutines.CoroWrapper
used for wrapping legacy generator-based coroutine objects in the debug mode. (Contributed by Illia Volochii in43216
.)- Removed the deprecated
split()
method of_tkinter.TkappType
. (Contributed by Erlend E. Aasland in38371
.) Removed from the
inspect
module:- the
getargspec
function, deprecated since Python 3.0; useinspect.signature
orinspect.getfullargspec
instead. - the
formatargspec
function, deprecated since Python 3.5; use theinspect.signature
function andSignature
object directly. - the undocumented
Signature.from_builtin
andSignature.from_function
functions, deprecated since Python 3.5; use theSignature.from_callable() <inspect.Signature.from_callable>
method instead.
(Contributed by Hugo van Kemenade in
45320
.)- the
- Remove 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
23882
.) - Remove
__class_getitem__
method frompathlib.PurePath
, because it was not used and added by mistake in previous versions. (Contributed by Nikita Sobolev in46483
.) - Remove the undocumented private
float.__set_format__()
method, previously known asfloat.__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 in46852
.)
This section lists previously described changes and other bugfixes that may require changes to your code.
- Prohibited passing non-
concurrent.futures.ThreadPoolExecutor
executors toloop.set_default_executor
following a deprecation in Python 3.8. (Contributed by Illia Volochii in43234
.) open
,io.open
,codecs.open
andfileinput.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. Thenewline parameter <open-newline-parameter>
ofopen
controls how universal newlines works. (Contributed by Victor Stinner in37330
.)- The
pdb
module now reads the.pdbrc
configuration file with the'utf-8'
encoding. (Contributed by Srinivas Reddy Thatiparthy (శ్రీనివాస్ రెడ్డి తాటిపర్తి) in41137
.) - 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
expressions-value-comparisons
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
: Thecalendar.LocaleTextCalendar
andcalendar.LocaleHTMLCalendar
classes now uselocale.getlocale
, instead of usinglocale.getdefaultlocale
, if no locale is specified. (Contributed by Victor Stinner in46659
.)- 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 in47066
.) 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 in35859
.)- 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, aValueError
is raised. (Contributed by Raymond Hettinger in40465
.)
- Building Python now requires a C11 compiler without optional C11 features. (Contributed by Victor Stinner in
46656
.) - Building Python now requires support of IEEE 754 floating point numbers. (Contributed by Victor Stinner in
46917
.) - CPython can now be built with the ThinLTO option via
--with-lto=thin
. (Contributed by Dong-hee Na and Brett Holman in44340
.) - libpython is no longer linked against libcrypt. (Contributed by Mike Gilbert in
45433
.) - Building Python now requires a C99
<math.h>
header file providing the following functions:copysign()
,hypot()
,isfinite()
,isinf()
,isnan()
,round()
. (Contributed by Victor Stinner in45440
.) - Building Python now requires a C99
<math.h>
header file providing aNAN
constant, or the__builtin_nan()
built-in function. (Contributed by Victor Stinner in46640
.) - Building Python now requires support for floating point Not-a-Number (NaN): remove the
Py_NO_NAN
macro. (Contributed by Victor Stinner in46656
.) - 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 in45522
) Modules/Setup
andModules/makesetup
have been improved and tied up. Extension modules can now be built throughmakesetup
. All except some test modules can be linked statically into main binary or library. (Contributed by Brett Cannon and Christian Heimes in45548
,45570
,45571
, and43974
.)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 libs, and uuid flags are detected bypkg-config
(when available). (Contributed by Christian Heimes and Erlend Egeberg Aasland in45847
,45747
, and45763
.)Note
Use the environment variables
TCLTK_CFLAGS
andTCLTK_LIBS
to manually specify the location of Tcl/Tk headers and libraries. Theconfigure
options--with-tcltk-includes
and--with-tcltk-libs
have been removed.- CPython now has experimental support for cross compiling to WebAssembly platform
wasm32-emscripten
. The effort is inspired by previous work like Pyodide. (Contributed by Christian Heimes and Ethan Smith in40280
.) - 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 withSIZEOF_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) thePYLONG_BITS_IN_DIGIT
variable inPC/pyconfig.h
, but this option may be removed at some point in the future. (Contributed by Mark Dickinson in45569
.) - The
tkinter
package now requires Tcl/Tk version 8.5.12 or newer. (Contributed by Serhiy Storchaka in46996
.)
- :c
PyErr_SetExcInfo()
no longer uses thetype
andtraceback
arguments, the interpreter now derives those values from the exception instance (thevalue
argument). The function still steals references of all three arguments. (Contributed by Irit Katriel in45711
.) - :c
PyErr_GetExcInfo()
now derives thetype
andtraceback
fields of the result from the exception instance (thevalue
field). (Contributed by Irit Katriel in45711
.) - :c
_frozen
has a newis_package
field to indicate whether or not the frozen module is a package. Previously, a negative value in thesize
field was the indicator. Now only non-negative values be used forsize
. (Contributed by Kumar Aditya in46608
.) - :c
_PyFrameEvalFunction
now takes_PyInterpreterFrame*
as its second parameter, instead ofPyFrameObject*
. See523
for more details of how to use this function pointer type. - :c
PyCode_New
and :cPyCode_NewWithPosOnlyArgs
now take an additionalexception_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 thereplace
method. - :c
PyCodeObject
no longer has aco_code
field. Instead, usePyObject_GetAttrString(code_object, "co_code")
or :cPyCode_GetCode
to get the underlying bytes object. (Contributed by Brandt Bucher in46841
and Ken Jin in92154
.)
- Add a new :c
PyType_GetName
function to get type's short name. (Contributed by Hai Shi in42035
.) - Add a new :c
PyType_GetQualName
function to get type's qualified name. (Contributed by Hai Shi in42035
.) - Add new :c
PyThreadState_EnterTracing
and :cPyThreadState_LeaveTracing
functions to the limited C API to suspend and resume tracing and profiling. (Contributed by Victor Stinner in43760
.) - Added the :c
Py_Version
constant which bears the same value as :cPY_VERSION_HEX
. (Contributed by Gabriele N. Tornetta in43931
.) :c
Py_buffer
and APIs are now part of the limited API and the stable ABI:- :c
PyObject_CheckBuffer
- :c
PyObject_GetBuffer
- :c
PyBuffer_GetPointer
- :c
PyBuffer_SizeFromFormat
- :c
PyBuffer_ToContiguous
- :c
PyBuffer_FromContiguous
- :c
PyBuffer_CopyData
- :c
PyBuffer_IsContiguous
- :c
PyBuffer_FillContiguousStrides
- :c
PyBuffer_FillInfo
- :c
PyBuffer_Release
- :c
PyMemoryView_FromBuffer
- :c
~PyBufferProcs.bf_getbuffer
and :c~PyBufferProcs.bf_releasebuffer
type slots
(Contributed by Christian Heimes in
45459
.)- :c
- Added the :c
PyType_GetModuleByDef
function, used to get the module in which a method was defined, in cases where this information is not available directly (via :cPyCMethod
). (Contributed by Petr Viktorin in46613
.) - Add new functions to pack and unpack C double (serialize and deserialize): :c
PyFloat_Pack2
, :cPyFloat_Pack4
, :cPyFloat_Pack8
, :cPyFloat_Unpack2
, :cPyFloat_Unpack4
and :cPyFloat_Unpack8
. (Contributed by Victor Stinner in46906
.) - Add new functions to get frame object attributes: :c
PyFrame_GetBuiltins
, :cPyFrame_GetGenerator
, :cPyFrame_GetGlobals
, :cPyFrame_GetLasti
. - Added two new functions to get and set the active exception instance: :c
PyErr_GetHandledException
and :cPyErr_SetHandledException
. These are alternatives to :cPyErr_SetExcInfo()
and :cPyErr_GetExcInfo()
which work with the legacy 3-tuple representation of exceptions. (Contributed by Irit Katriel in46343
.)
The old trashcan macros (
Py_TRASHCAN_SAFE_BEGIN
/Py_TRASHCAN_SAFE_END
) are now deprecated. They should be replaced by the new macrosPy_TRASHCAN_BEGIN
andPy_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 :c
PyType_Ready
function now raises an error if a type is defined with thePy_TPFLAGS_HAVE_GC
flag set but has no traverse function (:cPyTypeObject.tp_traverse
). (Contributed by Victor Stinner in44263
.) - Heap types with the
Py_TPFLAGS_IMMUTABLETYPE
flag can now inherit the590
vectorcall protocol. Previously, this was only possible forstatic types <static-types>
. (Contributed by Erlend E. Aasland in43908
) Since :c
Py_TYPE()
is changed to a inline static function,Py_TYPE(obj) = new_type
must be replaced withPy_SET_TYPE(obj, new_type)
: see the :cPy_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
39573
.)Since :c
Py_SIZE()
is changed to a inline static function,Py_SIZE(obj) = new_size
must be replaced withPy_SET_SIZE(obj, new_size)
: see the :cPy_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
39573
.)<Python.h>
no longer includes the header files<stdlib.h>
,<stdio.h>
,<errno.h>
and<string.h>
when thePy_LIMITED_API
macro is set to0x030b0000
(Python 3.11) or higher. C extensions should explicitly include the header files after#include <Python.h>
. (Contributed by Victor Stinner in45434
.)- The non-limited API files
cellobject.h
,classobject.h
,code.h
,context.h
,funcobject.h
,genobject.h
andlongintrepr.h
have been moved to theInclude/cpython
directory. Moreover, theeval.h
header file was removed. These files must not be included directly, as they are already included inPython.h
:Include Files <api-includes>
. If they have been included directly, consider includingPython.h
instead. (Contributed by Victor Stinner in35134
.) - The :c
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 in46007
.)
The :c
PyFrameObject
structure members have been removed from the public C API.While the documentation notes that the :c
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.
:c
PyFrameObject
fields:f_back
: use :cPyFrame_GetBack
.f_blockstack
: removed.f_builtins
: use :cPyFrame_GetBuiltins
.f_code
: use :cPyFrame_GetCode
.f_gen
: use :cPyFrame_GetGenerator
.f_globals
: use :cPyFrame_GetGlobals
.f_iblock
: removed.f_lasti
: use :cPyFrame_GetLasti
. Code usingf_lasti
withPyCode_Addr2Line()
should use :cPyFrame_GetLineNumber
instead; it may be faster.f_lineno
: use :cPyFrame_GetLineNumber
f_locals
: use :cPyFrame_GetLocals
.f_stackdepth
: removed.f_state
: no public API (renamed tof_frame.f_state
).f_trace
: no public API.f_trace_lines
: usePyObject_GetAttrString((PyObject*)frame, "f_trace_lines")
.f_trace_opcodes
: usePyObject_GetAttrString((PyObject*)frame, "f_trace_opcodes")
.f_localsplus
: no public API (renamed tof_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 :cPyFrame_GetBack
function must be called instead.Debuggers that accessed the
f_locals
directly must call :cPyFrame_GetLocals
instead. They no longer need to call :cPyFrame_FastToLocalsWithError
or :cPyFrame_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 :c
PyThreadState
structure members:frame
: removed, use :cPyThreadState_GetFrame
(function added to Python 3.9 by40429
). Warning: the function returns astrong reference
, need to call :cPy_XDECREF
.tracing
: changed, use :cPyThreadState_EnterTracing
and :cPyThreadState_LeaveTracing
(functions added to Python 3.11 by43760
).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()
andPyThreadState_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.
Deprecate the following functions to configure the Python initialization:
- :c
PySys_AddWarnOptionUnicode
- :c
PySys_AddWarnOption
- :c
PySys_AddXOption
- :c
PySys_HasWarnOptions
- :c
Py_SetPath
- :c
Py_SetProgramName
- :c
Py_SetPythonHome
- :c
Py_SetStandardStreamEncoding
- :c
_Py_SetProgramFullPath
Use the new :c
PyConfig
API of thePython Initialization Configuration <init-config>
instead (587
). (Contributed by Victor Stinner in44113
.)- :c
- Deprecate the
ob_shash
member of the :cPyBytesObject
. Use :cPyObject_Hash
instead. (Contributed by Inada Naoki in46864
.)
- :c
PyFrame_BlockSetup
and :cPyFrame_BlockPop
have been removed. (Contributed by Mark Shannon in40222
.) 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
45412
.)- Remove
Py_UNICODE_COPY()
andPy_UNICODE_FILL()
macros, deprecated since Python 3.3. UsePyUnicode_CopyCharacters()
ormemcpy()
(wchar_t*
string), andPyUnicode_Fill()
functions instead. (Contributed by Victor Stinner in41123
.) - 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 in45434
.) - Remove the
Py_FORCE_DOUBLE()
macro. It was used by thePy_IS_INFINITY()
macro. (Contributed by Victor Stinner in45440
.) The following items are no longer available when :c
Py_LIMITED_API
is defined:- :c
PyMarshal_WriteLongToFile
- :c
PyMarshal_WriteObjectToFile
- :c
PyMarshal_ReadObjectFromString
- :c
PyMarshal_WriteObjectToString
- the
Py_MARSHAL_VERSION
macro
These are not part of the
limited API <stable-abi-list>
.(Contributed by Victor Stinner in
45474
.)- :c
- Exclude :c
PyWeakref_GET_OBJECT
from the limited C API. It never worked since the :cPyWeakReference
structure is opaque in the limited C API. (Contributed by Victor Stinner in35134
.) - 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 thePyTypeObject.tp_members
member instead. (Contributed by Victor Stinner in40170
.) - Remove the
HAVE_PY_SET_53BIT_PRECISION
macro (moved to the internal C API). (Contributed by Victor Stinner in45412
.)