What’s New In Python 3.11

What’s New In Python 3.11¶
- Editor:
Pablo Galindo Salgado
This article explains the new features in Python 3.11, compared to 3.10. Python 3.11 was released on October 24, 2022. For full details, see the changelog.
Summary – Release highlights¶
Python 3.11 is between 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite. See Faster CPython for details.
New syntax features:
New built-in features:
New standard library modules:
Interpreter improvements:
New
-P
command line option andPYTHONSAFEPATH
environment variable to disable automatically prepending potentially unsafe paths tosys.path
New typing features:
Important deprecations, removals and restrictions:
PEP 594: Many legacy standard library modules have been deprecated and will be removed in Python 3.13
New Features¶
PEP 657: Fine-grained error locations in tracebacks¶
When printing tracebacks, the interpreter will now point to the exact expression that caused the error, instead of just the line. For example:
Traceback (most recent call last):
File "distance.py", line 11, in <module>
print(manhattan_distance(p1, p2))
^^^^^^^^^^^^^^^^^^^^^^^^^^
File "distance.py", line 6, in manhattan_distance
return abs(point_1.x - point_2.x) + abs(point_1.y - point_2.y)
^^^^^^^^^
AttributeError: 'NoneType' object has no attribute 'x'
Previous versions of the interpreter would point to just the line, making it
ambiguous which object was None
. These enhanced errors can also be helpful
when dealing with deeply nested dict
objects and multiple function calls:
Traceback (most recent call last):
File "query.py", line 37, in <module>
magic_arithmetic('foo')
File "query.py", line 18, in magic_arithmetic
return add_counts(x) / 25
^^^^^^^^^^^^^
File "query.py", line 24, in add_counts
return 25 + query_user(user1) + query_user(user2)
^^^^^^^^^^^^^^^^^
File "query.py", line 32, in query_user
return 1 + query_count(db, response['a']['b']['c']['user'], retry=True)
~~~~~~~~~~~~~~~~~~^^^^^
TypeError: 'NoneType' object is not subscriptable
As well as complex arithmetic expressions:
Traceback (most recent call last):
File "calculation.py", line 54, in <module>
result = (x / y / z) * (a / b / c)
~~~~~~^~~
ZeroDivisionError: division by zero
Additionally, the information used by the enhanced traceback feature is made available via a general API, that can be used to correlate bytecode instructions with source code location. This information can be retrieved using:
The
codeobject.co_positions()
method in Python.The
PyCode_Addr2Location()
function in the C API.
See PEP 657 for more details. (Contributed by Pablo Galindo, Batuhan Taskaya and Ammar Askar in bpo-43950.)
Note
This feature requires storing column positions in Code Objects,
which may result in a small increase in interpreter memory usage
and disk usage for compiled Python files.
To avoid storing the extra information
and deactivate printing the extra traceback information,
use the -X no_debug_ranges
command line option
or the PYTHONNODEBUGRANGES
environment variable.
PEP 654: Exception Groups and except*
¶
PEP 654 introduces language features that enable a program
to raise and handle multiple unrelated exceptions simultaneously.
The builtin types ExceptionGroup
and BaseExceptionGroup
make it possible to group exceptions and raise them together,
and the new except*
syntax generalizes
except
to match subgroups of exception groups.
See PEP 654 for more details.
(Contributed by Irit Katriel in bpo-45292. PEP written by Irit Katriel, Yury Selivanov and Guido van Rossum.)
PEP 678: Exceptions can be enriched with notes¶
The add_note()
method is added to BaseException
.
It can be used to enrich exceptions with context information
that is not available at the time when the exception is raised.
The added notes appear in the default traceback.
See PEP 678 for more details.
(Contributed by Irit Katriel in bpo-45607. PEP written by Zac Hatfield-Dodds.)
Windows py.exe
launcher improvements¶
The copy of the Python install manager included with Python 3.11 has been significantly
updated. It now supports company/tag syntax as defined in PEP 514 using the
-V:<company>/<tag>
argument instead of the limited -<major>.<minor>
.
This allows launching distributions other than PythonCore
,
the one hosted on python.org.
When using -V:
selectors, either company or tag can be omitted, but all
installs will be searched. For example, -V:OtherPython/
will select the
“best” tag registered for OtherPython
, while -V:3.11
or -V:/3.11
will select the “best” distribution with tag 3.11
.
When using the legacy -<major>
, -<major>.<minor>
,
-<major>-<bitness>
or -<major>.<minor>-<bitness>
arguments,
all existing behaviour should be preserved from past versions,
and only releases from PythonCore
will be selected.
However, the -64
suffix now implies “not 32-bit” (not necessarily x86-64),
as there are multiple supported 64-bit platforms.
32-bit runtimes are detected by checking the runtime’s tag for a -32
suffix.
All releases of Python since 3.5 have included this in their 32-bit builds.
Other Language Changes¶
Starred unpacking expressions can now be used in
for
statements. (See bpo-46725 for more details.)Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous in this case. (Contributed by Serhiy Storchaka in bpo-33346.)
A
TypeError
is now raised instead of anAttributeError
inwith
statements andcontextlib.ExitStack.enter_context()
for objects that do not support the context manager protocol, and inasync with
statements andcontextlib.AsyncExitStack.enter_async_context()
for objects not supporting the asynchronous context manager protocol. (Contributed by Serhiy Storchaka in bpo-12022 and bpo-44471.)Added
object.__getstate__()
, which provides the default implementation of the__getstate__()
method.copy
ing andpickle
ing instances of subclasses of builtin typesbytearray
,set
,frozenset
,collections.OrderedDict
,collections.deque
,weakref.WeakSet
, anddatetime.tzinfo
now copies and pickles instance attributes implemented as slots. This change has an unintended side effect: It trips up a small minority of existing Python projects not expectingobject.__getstate__()
to exist. See the later comments on gh-70766 for discussions of what workarounds such code may need. (Contributed by Serhiy Storchaka in bpo-26579.)
Added a
-P
command line option and aPYTHONSAFEPATH
environment variable, which disable the automatic prepending tosys.path
of the script’s directory when running a script, or the current directory when using-c
and-m
. This ensures only stdlib and installed modules are picked up byimport
, and avoids unintentionally or maliciously shadowing modules with those in a local (and typically user-writable) directory. (Contributed by Victor Stinner in gh-57684.)A
"z"
option was added to the Format Specification Mini-Language that coerces negative to positive zero after rounding to the format precision. See PEP 682 for more details. (Contributed by John Belmonte in gh-90153.)Bytes are no longer accepted on
sys.path
. Support broke sometime between Python 3.2 and 3.6, with no one noticing until after Python 3.10.0 was released. In addition, bringing back support would be problematic due to interactions between-b
andsys.path_importer_cache
when there is a mixture ofstr
andbytes
keys. (Contributed by Thomas Grainger in gh-91181.)
Other CPython Implementation Changes¶
The special methods
__complex__()
forcomplex
and__bytes__()
forbytes
are implemented to support thetyping.SupportsComplex
andtyping.SupportsBytes
protocols. (Contributed by Mark Dickinson and Donghee Na in bpo-24234.)siphash13
is added as a new internal hashing algorithm. It has similar security properties assiphash24
, but it is slightly faster for long inputs.str
,bytes
, and some other types now use it as the default algorithm forhash()
. PEP 552 hash-based .pyc files now usesiphash13
too. (Contributed by Inada Naoki in bpo-29410.)When an active exception is re-raised by a
raise
statement with no parameters, the traceback attached to this exception is now 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 in bpo-45711.)The interpreter state’s representation of handled exceptions (aka
exc_info
or_PyErr_StackItem
) now only has theexc_value
field;exc_type
andexc_traceback
have been removed, as they can be derived fromexc_value
. (Contributed by Irit Katriel in bpo-45711.)A new command line option,
AppendPath
, has been added for the Windows installer. It behaves similarly toPrependPath
, but appends the install and scripts directories instead of prepending them. (Contributed by Bastian Neuburger in bpo-44934.)The
PyConfig.module_search_paths_set
field must now be set to1
for initialization to usePyConfig.module_search_paths
to initializesys.path
. Otherwise, initialization will recalculate the path and replace any values added tomodule_search_paths
.The output of the
--help
option now fits in 50 lines/80 columns. Information about Python environment variables and-X
options is now available using the respective--help-env
and--help-xoptions
flags, and with the new--help-all
. (Contributed by Éric Araujo in bpo-46142.)Converting between
int
andstr
in bases other than 2 (binary), 4, 8 (octal), 16 (hexadecimal), or 32 such as base 10 (decimal) now raises aValueError
if the number of digits in string form is above a limit to avoid potential denial of service attacks due to the algorithmic complexity. This is a mitigation for CVE 2020-10735. This limit can be configured or disabled by environment variable, command line flag, orsys
APIs. See the integer string conversion length limitation documentation. The default limit is 4300 digits in string form.
New Modules¶
Improved Modules¶
asyncio¶
Added the
TaskGroup
class, an asynchronous context manager holding a group of tasks that will wait for all of them upon exit. For new code this is recommended over usingcreate_task()
andgather()
directly. (Contributed by Yury Selivanov and others in gh-90908.)Added
timeout()
, an asynchronous context manager for setting a timeout on asynchronous operations. For new code this is recommended over usingwait_for()
directly. (Contributed by Andrew Svetlov in gh-90927.)Added the
Runner
class, which exposes the machinery used byrun()
. (Contributed by Andrew Svetlov in gh-91218.)Added the
Barrier
class to the synchronization primitives in the asyncio library, and the relatedBrokenBarrierError
exception. (Contributed by Yves Duprat and Andrew Svetlov in gh-87518.)Added keyword argument all_errors to
asyncio.loop.create_connection()
so that multiple connection errors can be raised as anExceptionGroup
.Added the
asyncio.StreamWriter.start_tls()
method for upgrading existing stream-based connections to TLS. (Contributed by Ian Good in bpo-34975.)Added raw datagram socket functions to the event loop:
sock_sendto()
,sock_recvfrom()
andsock_recvfrom_into()
. These have implementations inSelectorEventLoop
andProactorEventLoop
. (Contributed by Alex Grönholm in bpo-46805.)Added
cancelling()
anduncancel()
methods toTask
. These are primarily intended for internal use, notably byTaskGroup
.
contextlib¶
dataclasses¶
datetime¶
Add
datetime.UTC
, a convenience alias fordatetime.timezone.utc
. (Contributed by Kabir Kwatra in gh-91973.)datetime.date.fromisoformat()
,datetime.time.fromisoformat()
anddatetime.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.)
enum¶
Renamed
EnumMeta
toEnumType
(EnumMeta
kept as an alias).Added
StrEnum
, with members that can be used as (and must be) strings.Added
ReprEnum
, which only modifies the__repr__()
of members while returning their literal values (rather than names) for__str__()
and__format__()
(used bystr()
,format()
and f-strings).Changed
Enum.__format__()
(the default forformat()
,str.format()
and f-strings) to always produce the same result asEnum.__str__()
: for enums inheriting fromReprEnum
it will be the member’s value; for all other enums it will be the enum and member name (e.g.Color.RED
).Added a new boundary class parameter to
Flag
enums and theFlagBoundary
enum with its options, to control how to handle out-of-range flag values.Added the
verify()
enum decorator and theEnumCheck
enum with its options, to check enum classes against several specific constraints.Added the
member()
andnonmember()
decorators, to ensure the decorated object is/is not converted to an enum member.Added the
property()
decorator, which works likeproperty()
except for enums. Use this instead oftypes.DynamicClassAttribute()
.Added the
global_enum()
enum decorator, which adjusts__repr__()
and__str__()
to show values as members of their module rather than the enum class. For example,'re.ASCII'
for theASCII
member ofre.RegexFlag
rather than'RegexFlag.ASCII'
.Enhanced
Flag
to supportlen()
, iteration andin
/not in
on its members. For example, the following now works:len(AFlag(3)) == 2 and list(AFlag(3)) == (AFlag.ONE, AFlag.TWO)
Changed
Enum
andFlag
so that members are now defined before__init_subclass__()
is called;dir()
now includes methods, etc., from mixed-in data types.Changed
Flag
to only consider primary values (power of two) canonical while composite values (3
,6
,10
, etc.) are considered aliases; inverted flags are coerced to their positive equivalent.
fcntl¶
On FreeBSD, the
F_DUP2FD
andF_DUP2FD_CLOEXEC
flags respectively are supported, the former equals todup2
usage while the latter set theFD_CLOEXEC
flag in addition.
fractions¶
functools¶
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 bpo-46014.)
gzip¶
The
gzip.compress()
function is now faster when used with the mtime=0 argument as it delegates the compression entirely to a singlezlib.compress()
operation. There is one side effect of this change: The gzip file header contains an “OS” byte in its header. That was traditionally always set to a value of 255 representing “unknown” by thegzip
module. Now, when usingcompress()
with mtime=0, it may be set to a different value by the underlying zlib C library Python was linked against. (See gh-112346 for details on the side effect.)
hashlib¶
hashlib.blake2b()
andhashlib.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. Thehashlib
module prefers optimized SHA3 and SHAKE implementations from OpenSSL. The change affects only installations without OpenSSL support. (Contributed by Christian Heimes in bpo-47098.)Add
hashlib.file_digest()
, a helper function for efficient hashing of files or file-like objects. (Contributed by Christian Heimes in gh-89313.)
IDLE and idlelib¶
inspect¶
Add
getmembers_static()
to return all members without triggering dynamic lookup via the descriptor protocol. (Contributed by Weipeng Hong in bpo-30533.)Add
ismethodwrapper()
for checking if the type of an object is aMethodWrapperType
. (Contributed by Hakan Çelik in bpo-29418.)Change the frame-related functions in the
inspect
module to return newFrameInfo
andTraceback
class instances (backwards compatible with the previous named tuple-like interfaces) that includes the extended PEP 657 position information (end line number, column and end column). The affected functions are:(Contributed by Pablo Galindo in gh-88116.)
locale¶
Add
locale.getencoding()
to get the current locale encoding. It is similar tolocale.getpreferredencoding(False)
but ignores the Python UTF-8 Mode.
logging¶
Added
getLevelNamesMapping()
to return a mapping from logging level names (e.g.'CRITICAL'
) to the values of their corresponding Logging Levels (e.g.50
, by default). (Contributed by Andrei Kulakovin in gh-88024.)Added a
createSocket()
method toSysLogHandler
, to matchSocketHandler.createSocket()
. It is called automatically during handler initialization and when emitting an event, if there is no active socket. (Contributed by Kirill Pinchuk in gh-88457.)
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 operationsmath.pow(0.0, -math.inf)
andmath.pow(-0.0, -math.inf)
now returninf
. Previously they raisedValueError
. (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 thatoperator.call(obj, *args, **kwargs) == obj(*args, **kwargs)
. (Contributed by Antony Lee in bpo-44019.)
os¶
On Windows,
os.urandom()
now usesBCryptGenRandom()
, instead ofCryptGenRandom()
which is deprecated. (Contributed by Donghee Na in bpo-44611.)
pathlib¶
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, anExceptionGroup
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
toset_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 raiseUnicodeEncodeError
instead ofsqlite3.ProgrammingError
. (Contributed by Erlend E. Aasland in bpo-44688.)sqlite3
exceptions now include the SQLite extended error code assqlite_errorcode
and the SQLite error name assqlite_errorname
. (Contributed by Aviv Palivoda, Daniel Shahaf, and Erlend E. Aasland in bpo-16379 and bpo-24139.)Add
setlimit()
andgetlimit()
tosqlite3.Connection
for setting and getting SQLite limits by connection basis. (Contributed by Erlend E. Aasland in bpo-45243.)sqlite3
now setssqlite3.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 anunraisable 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()
anddeserialize()
tosqlite3.Connection
for serializing and deserializing databases. (Contributed by Erlend E. Aasland in bpo-41930.)Add
create_window_function()
tosqlite3.Connection
for creating aggregate window functions. (Contributed by Erlend E. Aasland in bpo-34916.)Add
blobopen()
tosqlite3.Connection
.sqlite3.Blob
allows incremental I/O operations on blobs. (Contributed by Aviv Palivoda and Erlend E. Aasland in bpo-24905.)
string¶
Add
get_identifiers()
andis_valid()
tostring.Template
, which respectively return all valid placeholders, and whether any invalid placeholders are present. (Contributed by Ben Kehoe in gh-90465.)
sys¶
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 in bpo-45711.)Add
sys.exception()
which returns the active exception instance (equivalent tosys.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¶
Three new installation schemes (posix_venv, nt_venv and venv) were added and are used when Python creates new virtual environments or when it is running from a virtual environment. The first two schemes (posix_venv and nt_venv) are OS-specific for non-Windows and Windows, the venv is essentially an alias to one of them according to the OS Python runs on. This is useful for downstream distributors who modify
sysconfig.get_preferred_scheme()
. Third party code that creates new virtual environments should use the new venv installation scheme to determine the paths, as doesvenv
. (Contributed by Miro Hrončok in bpo-45413.)
tempfile¶
SpooledTemporaryFile
objects now fully implement the methods ofio.BufferedIOBase
orio.TextIOBase
(depending on file mode). This lets them work correctly with APIs that expect file-like objects, such as compression modules. (Contributed by Carey Metcalfe in gh-70363.)
threading¶
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 in bpo-41710.)
time¶
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 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, Donghee Na, Eryk Sun and Victor Stinner in bpo-21302 and bpo-45429.)
tkinter¶
Added method
info_patchlevel()
which returns the exact version of the Tcl library as a named tuple similar tosys.version_info
. (Contributed by Serhiy Storchaka in gh-91827.)
traceback¶
Add
traceback.StackSummary.format_frame_summary()
to allow users to override which frames appear in the traceback, and how they are formatted. (Contributed by Ammar Askar in bpo-44569.)Add
traceback.TracebackException.print()
, which prints the formattedTracebackException
instance to a file. (Contributed by Irit Katriel in bpo-33809.)
typing¶
For major changes, see New Features Related to Type Hints.
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 in gh-90633.)Add
typing.reveal_type()
. This is useful for asking a type checker what type it has inferred for a given expression. At runtime it prints the type of the received value. (Contributed by Jelle Zijlstra in gh-90572.)Add
typing.assert_type()
. This is useful for asking a type checker to confirm that the type it has inferred for a given expression matches the given type. At runtime it simply returns the received value. (Contributed by Jelle Zijlstra in gh-90638.)typing.TypedDict
types can now be generic. (Contributed by Samodya Abeysiriwardane in gh-89026.)NamedTuple
types can now be generic. (Contributed by Serhiy Storchaka in bpo-43923.)Allow subclassing of
typing.Any
. This is useful for avoiding type checker errors related to highly dynamic class, such as mocks. (Contributed by Shantanu Jain in gh-91154.)The
typing.final()
decorator now sets the__final__
attributed on the decorated object. (Contributed by Jelle Zijlstra in gh-90500.)The
typing.get_overloads()
function can be used for introspecting the overloads of a function.typing.clear_overloads()
can be used to clear all registered overloads of a function. (Contributed by Jelle Zijlstra in gh-89263.)The
__init__()
method ofProtocol
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 addsOptional
to parameters withNone
as a default. (Contributed by Nikita Sobolev in gh-90353.)typing.get_type_hints()
now supports evaluating bare stringifiedClassVar
annotations. (Contributed by Gregory Beauregard in gh-90711.)typing.no_type_check()
no longer modifies external classes and functions. It also now correctly marks classmethods as not to be type checked. (Contributed by Nikita Sobolev in gh-90729.)
unicodedata¶
The Unicode database has been updated to version 14.0.0. (Contributed by Benjamin Peterson in bpo-45190).
unittest¶
Added methods
enterContext()
andenterClassContext()
of classTestCase
, methodenterAsyncContext()
of classIsolatedAsyncioTestCase
and functionunittest.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 forwarnings.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 a
ZipFile
’s directory and file headers. (Contributed by Stephen J. Turnbull and Serhiy Storchaka in bpo-28080.)Added
ZipFile.mkdir()
for creating new directories inside ZIP archives. (Contributed by Sam Ezeh in gh-49083.)Added
stem
,suffix
andsuffixes
tozipfile.Path
. (Contributed by Miguel Brito in gh-88261.)
Optimizations¶
This section covers specific optimizations independent of the Faster CPython project, which is covered in its own section.
The compiler now optimizes simple printf-style % formatting on string literals containing only the format codes
%s
,%r
and%a
and makes it as fast as a corresponding f-string expression. (Contributed by Serhiy Storchaka in bpo-28307.)Integer division (
//
) is better tuned for optimization by compilers. It is now around 20% faster on x86-64 when dividing anint
by a value smaller than2**30
. (Contributed by Gregory P. Smith and Tim Peters in gh-90564.)sum()
is now nearly 30% faster for integers smaller than2**30
. (Contributed by Stefan Behnel in gh-68264.)Resizing lists is streamlined for the common case, speeding up
list.append()
by ≈15% and simple list comprehensions by up to 20-30% (Contributed by Dennis Sweeney in gh-91165.)Dictionaries don’t store hash values when all keys are Unicode objects, decreasing
dict
size. For example,sys.getsizeof(dict.fromkeys("abcdefg"))
is reduced from 352 bytes to 272 bytes (23% smaller) on 64-bit platforms. (Contributed by Inada Naoki in bpo-46845.)Using
asyncio.DatagramProtocol
is now orders of magnitude faster when transferring large files over UDP, with speeds over 100 times higher for a ≈60 MiB file. (Contributed by msoxzw in gh-91487.)math
functionscomb()
andperm()
are now ≈10 times faster for large arguments (with a larger speedup for larger k). (Contributed by Serhiy Storchaka in bpo-37295.)The
statistics
functionsmean()
,variance()
andstdev()
now consume iterators in one pass rather than converting them to alist
first. This is twice as fast and can save substantial memory. (Contributed by Raymond Hettinger in gh-90415.)unicodedata.normalize()
now normalizes pure-ASCII strings in constant time. (Contributed by Donghee Na in bpo-44987.)
Faster CPython¶
CPython 3.11 is an average of 25% faster than CPython 3.10 as measured with the pyperformance benchmark suite, when compiled with GCC on Ubuntu Linux. Depending on your workload, the overall speedup could be 10-60%.
This project focuses on two major areas in Python: Faster Startup and Faster Runtime. Optimizations not covered by this project are listed separately under Optimizations.
Faster Startup¶
Frozen imports / Static code objects¶
Python caches bytecode in the __pycache__ directory to speed up module loading.
Previously in 3.10, Python module execution looked like this:
Read __pycache__ -> Unmarshal -> Heap allocated code object -> Evaluate
In Python 3.11, the core modules essential for Python startup are “frozen”. This means that their Code Objects (and bytecode) are statically allocated by the interpreter. This reduces the steps in module execution process to:
Statically allocated code object -> Evaluate
Interpreter startup is now 10-15% faster in Python 3.11. This has a big impact for short-running programs using Python.
(Contributed by Eric Snow, Guido van Rossum and Kumar Aditya in many issues.)
Faster Runtime¶
Cheaper, lazy Python frames¶
Python frames, holding execution information, are created whenever Python calls a Python function. The following are new frame optimizations:
Streamlined the frame creation process.
Avoided memory allocation by generously re-using frame space on the C stack.
Streamlined the internal frame struct to contain only essential information. Frames previously held extra debugging and memory management information.
Old-style frame objects
are now created only when requested by debuggers
or by Python introspection functions such as sys._getframe()
and
inspect.currentframe()
. For most user code, no frame objects are
created at all. As a result, nearly all Python functions calls have sped
up significantly. We measured a 3-7% speedup in pyperformance.
(Contributed by Mark Shannon in bpo-44590.)
Inlined Python function calls¶
During a Python function call, Python will call an evaluating C function to interpret that function’s code. This effectively limits pure Python recursion to what’s safe for the C stack.
In 3.11, when CPython detects Python code calling another Python function, it sets up a new frame, and “jumps” to the new code inside the new frame. This avoids calling the C interpreting function altogether.
Most Python function calls now consume no C stack space, speeding them up.
In simple recursive functions like fibonacci or
factorial, we observed a 1.7x speedup. This also means recursive functions
can recurse significantly deeper
(if the user increases the recursion limit with sys.setrecursionlimit()
).
We measured a 1-3% improvement in pyperformance.
(Contributed by Pablo Galindo and Mark Shannon in bpo-45256.)
PEP 659: Specializing Adaptive Interpreter¶
PEP 659 is one of the key parts of the Faster CPython project. The general idea is that while Python is a dynamic language, most code has regions where objects and types rarely change. This concept is known as type stability.
At runtime, Python will try to look for common patterns and type stability in the executing code. Python will then replace the current operation with a more specialized one. This specialized operation uses fast paths available only to those use cases/types, which generally outperform their generic counterparts. This also brings in another concept called inline caching, where Python caches the results of expensive operations directly in the bytecode.
The specializer will also combine certain common instruction pairs into one superinstruction, reducing the overhead during execution.
Python will only specialize when it sees code that is “hot” (executed multiple times). This prevents Python from wasting time on run-once code. Python can also de-specialize when code is too dynamic or when the use changes. Specialization is attempted periodically, and specialization attempts are not too expensive, allowing specialization to adapt to new circumstances.
(PEP written by Mark Shannon, with ideas inspired by Stefan Brunthaler. See PEP 659 for more information. Implementation by Mark Shannon and Brandt Bucher, with additional help from Irit Katriel and Dennis Sweeney.)
Operation |
Form |
Specialization |
Operation speedup (up to) |
Contributor(s) |
|---|---|---|---|---|
Binary operations |
|
Binary add, multiply and subtract for common types
such as |
10% |
Mark Shannon, Donghee Na, Brandt Bucher, Dennis Sweeney |
Subscript |
|
Subscripting container types such as Subscripting custom |
10-25% |
Irit Katriel, Mark Shannon |
Store subscript |
|
Similar to subscripting specialization above. |
10-25% |
Dennis Sweeney |
Calls |
|
Calls to common builtin (C) functions and types such
as |
20% |
Mark Shannon, Ken Jin |
Load global variable |
|
The object’s index in the globals/builtins namespace is cached. Loading globals and builtins require zero namespace lookups. |
Mark Shannon |
|
Load attribute |
|
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. |
Mark Shannon |
|
Load methods for call |
|
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 |
|
Similar to load attribute optimization. |
2% in pyperformance |
Mark Shannon |
Unpack Sequence |
|
Specialized for common containers such as
|
8% |
Brandt Bucher |
Misc¶
Objects now require less memory due to lazily created object namespaces. Their namespace dictionaries now also share keys more freely. (Contributed Mark Shannon in bpo-45340 and bpo-40116.)
“Zero-cost” exceptions are implemented, eliminating the cost of
try
statements when no exception is raised. (Contributed by Mark Shannon in bpo-40222.)A more concise representation of exceptions in the interpreter reduced the time required for catching an exception by about 10%. (Contributed by Irit Katriel in bpo-45711.)
re
’s regular expression matching engine has been partially refactored, and now uses computed gotos (or “threaded code”) on supported platforms. As a result, Python 3.11 executes the pyperformance regular expression benchmarks up to 10% faster than Python 3.10. (Contributed by Brandt Bucher in gh-91404.)
FAQ¶
How should I write my code to utilize these speedups?¶
Write Pythonic code that follows common best practices; you don’t have to change your code. The Faster CPython project optimizes for common code patterns we observe.
Will CPython 3.11 use more memory?¶
Maybe not; we don’t expect memory use to exceed 20% higher than 3.10. This is offset by memory optimizations for frame objects and object dictionaries as mentioned above.
I don’t see any speedups in my workload. Why?¶
Certain code won’t have noticeable benefits. If your code spends most of its time on I/O operations, or already does most of its computation in a C extension library like NumPy, there won’t be significant speedups. This project currently benefits pure-Python workloads the most.
Furthermore, the pyperformance figures are a geometric mean. Even within the pyperformance benchmarks, certain benchmarks have slowed down slightly, while others have sped up by nearly 2x!
Is there a JIT compiler?¶
No. We’re still exploring other optimizations.
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.
CPython bytecode changes¶
The bytecode now contains inline cache entries,
which take the form of the newly-added CACHE
instructions.
Many opcodes expect to be followed by an exact number of caches,
and instruct the interpreter to skip over them at runtime.
Populated caches can look like arbitrary instructions,
so great care should be taken when reading or modifying
raw, adaptive bytecode containing quickened data.
New opcodes¶
ASYNC_GEN_WRAP
,RETURN_GENERATOR
andSEND
, used in generators and co-routines.COPY_FREE_VARS
, which avoids needing special caller-side code for closures.JUMP_BACKWARD_NO_INTERRUPT
, for use in certain loops where handling interrupts is undesirable.MAKE_CELL
, to create Cell Objects.CHECK_EG_MATCH
andPREP_RERAISE_STAR
, to handle the new exception groups and except* added in PEP 654.PUSH_EXC_INFO
, for use in exception handlers.RESUME
, a no-op, for internal tracing, debugging and optimization checks.
Replaced opcodes¶
Replaced Opcode(s) |
New Opcode(s) |
Notes |
|---|---|---|
BINARY_* INPLACE_* |
Replaced all numeric binary/in-place opcodes with a single opcode |
|
CALL_FUNCTION CALL_FUNCTION_KW CALL_METHOD |
Decouples argument shifting for methods from handling of keyword arguments; allows better specialization of calls |
|
DUP_TOP DUP_TOP_TWO ROT_TWO ROT_THREE ROT_FOUR ROT_N |
Stack manipulation instructions |
|
JUMP_IF_NOT_EXC_MATCH |
Now performs check but doesn’t jump |
|
JUMP_ABSOLUTE POP_JUMP_IF_FALSE POP_JUMP_IF_TRUE |
See [3];
|
|
SETUP_WITH SETUP_ASYNC_WITH |
|
|
All jump opcodes are now relative, including the
existing JUMP_IF_TRUE_OR_POP
and JUMP_IF_FALSE_OR_POP
.
The argument is now an offset from the current instruction
rather than an absolute location.
Changed/removed opcodes¶
Changed
MATCH_CLASS
andMATCH_KEYS
to no longer push an additional boolean value to indicate success/failure. Instead,None
is pushed on failure in place of the tuple of extracted values.Changed opcodes that work with exceptions to reflect them now being represented as one item on the stack instead of three (see gh-89874).
Removed
COPY_DICT_WITHOUT_KEYS
,GEN_START
,POP_BLOCK
,SETUP_FINALLY
andYIELD_FROM
.
Deprecated¶
This section lists Python APIs that have been deprecated in Python 3.11.
Deprecated C APIs are listed separately.
Language/Builtins¶
Chaining
classmethod
descriptors (introduced in bpo-19072) is now deprecated. It can no longer be used to wrap other descriptors such asproperty
. The core design of this feature was flawed and caused a number of downstream problems. To “pass-through” aclassmethod
, consider using the__wrapped__
attribute that was added in Python 3.10. (Contributed by Raymond Hettinger in gh-89519.)Octal escapes in string and bytes literals with values larger than
0o377
(255 in decimal) now produce aDeprecationWarning
. In a future Python version, they will raise aSyntaxWarning
and eventually aSyntaxError
. (Contributed by Serhiy Storchaka in gh-81548.)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 in bpo-44977.)
Modules¶
PEP 594 led to the deprecations of the following modules slated for removal in Python 3.13:
aifc
chunk
msilib
pipes
telnetlib
audioop
crypt
nis
sndhdr
uu
cgi
imghdr
nntplib
spwd
xdrlib
cgitb
mailcap
ossaudiodev
sunau
(Contributed by Brett Cannon in bpo-47061 and Victor Stinner in gh-68966.)
The
asynchat
,asyncore
andsmtpd
modules have been deprecated since at least Python 3.6. Their documentation and deprecation warnings have now been updated to note they will be removed in Python 3.12. (Contributed by Hugo van Kemenade in bpo-47022.)The
lib2to3
package and2to3
tool are now deprecated and may not be able to parse Python 3.10 or newer. See PEP 617, introducing the new PEG parser, for details. (Contributed by Victor Stinner in bpo-40360.)Undocumented modules
sre_compile
,sre_constants
andsre_parse
are now deprecated. (Contributed by Serhiy Storchaka in bpo-47152.)
Standard Library¶
The following have been deprecated in
configparser
since Python 3.2. Their deprecation warnings have now been updated to note they will be removed in Python 3.12:the
configparser.SafeConfigParser
classthe
configparser.ParsingError.filename
propertythe
configparser.RawConfigParser.readfp()
method
(Contributed by Hugo van Kemenade in bpo-45173.)
configparser.LegacyInterpolation
has been deprecated in the docstring since Python 3.2, and is not listed in theconfigparser
documentation. It now emits aDeprecationWarning
and will be removed in Python 3.13. Useconfigparser.BasicInterpolation
orconfigparser.ExtendedInterpolation
instead. (Contributed by Hugo van Kemenade in bpo-46607.)The older set of
importlib.resources
functions were deprecated in favor of the replacements added in Python 3.9 and will be removed in a future Python version, due to not supporting resources located within package subdirectories:importlib.resources.contents()
importlib.resources.is_resource()
importlib.resources.open_binary()
importlib.resources.open_text()
importlib.resources.read_binary()
importlib.resources.read_text()
importlib.resources.path()
The
locale.getdefaultlocale()
function is deprecated and will be removed in Python 3.15. Uselocale.setlocale()
,locale.getpreferredencoding(False)
andlocale.getlocale()
functions instead. (Contributed by Victor Stinner in gh-90817.)The
locale.resetlocale()
function is deprecated and will be removed in Python 3.13. Uselocale.setlocale(locale.LC_ALL, "")
instead. (Contributed by Victor Stinner in gh-90817.)Stricter rules will now be applied for numerical group references and group names in regular expressions. Only sequences of ASCII digits will now be accepted as a numerical reference, and the group name in
bytes
patterns and replacement strings can only contain ASCII letters, digits and underscores. For now, a deprecation warning is raised for syntax violating these rules. (Contributed by Serhiy Storchaka in gh-91760.)In the
re
module, there.template()
function and the correspondingre.TEMPLATE
andre.T
flags are deprecated, as they were undocumented and lacked an obvious purpose. They will be removed in Python 3.13. (Contributed by Serhiy Storchaka and Miro Hrončok in gh-92728.)turtle.settiltangle()
has been deprecated since Python 3.1; it now emits a deprecation warning and will be removed in Python 3.13. Useturtle.tiltangle()
instead (it was earlier incorrectly marked as deprecated, and its docstring is now corrected). (Contributed by Hugo van Kemenade in bpo-45837.)typing.Text
, which exists solely to provide compatibility support between Python 2 and Python 3 code, is now deprecated. Its removal is currently unplanned, but users are encouraged to usestr
instead wherever possible. (Contributed by Alex Waygood in gh-92332.)The keyword argument syntax for constructing
typing.TypedDict
types is now deprecated. Support will be removed in Python 3.13. (Contributed by Jingchen Ye in gh-90224.)webbrowser.MacOSX
is deprecated and will be removed in Python 3.13. It is untested, undocumented, and not used bywebbrowser
itself. (Contributed by Donghee Na in bpo-42255.)The behavior of returning a value from a
TestCase
andIsolatedAsyncioTestCase
test methods (other than the defaultNone
value) is now deprecated.Deprecated the following not-formally-documented
unittest
functions, scheduled for removal in Python 3.13:unittest.findTestCases()
unittest.makeSuite()
unittest.getTestCaseNames()
Use
TestLoader
methods instead:(Contributed by Erlend E. Aasland in bpo-5846.)
unittest.TestProgram.usageExit()
is marked deprecated, to be removed in 3.13. (Contributed by Carlos Damázio in gh-67048.)
Pending Removal in Python 3.12¶
The following Python APIs have been deprecated in earlier Python releases, and will be removed in Python 3.12.
C APIs pending removal are listed separately.
The
asynchat
moduleThe
asyncore
moduleThe
imp
moduleThe
typing.io
namespaceThe
typing.re
namespacecgi.log()
importlib.find_loader()
importlib.abc.Loader.module_repr()
importlib.abc.MetaPathFinder.find_module()
importlib.abc.PathEntryFinder.find_loader()
importlib.abc.PathEntryFinder.find_module()
importlib.machinery.BuiltinImporter.find_module()
importlib.machinery.BuiltinLoader.module_repr()
importlib.machinery.FileFinder.find_loader()
importlib.machinery.FileFinder.find_module()
importlib.machinery.FrozenImporter.find_module()
importlib.machinery.FrozenLoader.module_repr()
importlib.machinery.PathFinder.find_module()
importlib.machinery.WindowsRegistryFinder.find_module()
importlib.util.module_for_loader()
importlib.util.set_loader_wrapper()
importlib.util.set_package_wrapper()
pkgutil.ImpImporter
pkgutil.ImpLoader
pathlib.Path.link_to()
sqlite3.enable_shared_cache()
sqlite3.OptimizedUnicode()
PYTHONTHREADDEBUG
environment variableThe following deprecated aliases in
unittest
:Deprecated alias
Method Name
Deprecated in
failUnless
3.1
failIf
3.1
failUnlessEqual
3.1
failIfEqual
3.1
failUnlessAlmostEqual
3.1
failIfAlmostEqual
3.1
failUnlessRaises
3.1
assert_
3.2
assertEquals
3.2
assertNotEquals
3.2
assertAlmostEquals
3.2
assertNotAlmostEquals
3.2
assertRegexpMatches
3.2
assertRaisesRegexp
3.2
assertNotRegexpMatches
3.5
Removed¶
This section lists Python APIs that have been removed in Python 3.11.
Removed C APIs are listed separately.
Removed the
@asyncio.coroutine()
decorator enabling legacy generator-based coroutines to be compatible withasync
/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 in bpo-43216.)Removed
asyncio.coroutines.CoroWrapper
used for wrapping legacy generator-based coroutine objects in the debug mode. (Contributed by Illia Volochii in bpo-43216.)Due to significant security concerns, the reuse_address parameter of
asyncio.loop.create_datagram_endpoint()
, disabled in Python 3.9, is now entirely removed. This is because of the behavior of the socket optionSO_REUSEADDR
in UDP. (Contributed by Hugo van Kemenade in bpo-45129.)Removed the
binhex
module, deprecated in Python 3.9. Also removed the related, similarly-deprecatedbinascii
functions:binascii.a2b_hqx()
binascii.b2a_hqx()
binascii.rlecode_hqx()
binascii.rldecode_hqx()
The
binascii.crc_hqx()
function remains available.(Contributed by Victor Stinner in bpo-45085.)
Removed the
distutils
bdist_msi
command deprecated in Python 3.9. Usebdist_wheel
(wheel packages) instead. (Contributed by Hugo van Kemenade in bpo-45124.)Removed the
__getitem__()
methods ofxml.dom.pulldom.DOMEventStream
,wsgiref.util.FileWrapper
andfileinput.FileInput
, deprecated since Python 3.9. (Contributed by Hugo van Kemenade in bpo-45132.)Removed the deprecated
gettext
functionslgettext()
,ldgettext()
,lngettext()
andldngettext()
. Also removed thebind_textdomain_codeset()
function, theNullTranslations.output_charset()
andNullTranslations.set_output_charset()
methods, and the codeset parameter oftranslation()
andinstall()
, since they are only used for thel*gettext()
functions. (Contributed by Donghee Na and Serhiy Storchaka in bpo-44235.)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 or theinspect.Signature
object directly.The undocumented
Signature.from_builtin()
andSignature.from_function()
methods, deprecated since Python 3.5; use theSignature.from_callable()
method instead.
(Contributed by Hugo van Kemenade in bpo-45320.)
Removed the
__class_getitem__()
method frompathlib.PurePath
, because it was not used and added by mistake in previous versions. (Contributed by Nikita Sobolev in bpo-46483.)Removed the
MailmanProxy
class in thesmtpd
module, as it is unusable without the externalmailman
package. (Contributed by Donghee Na in bpo-35800.)Removed the deprecated
split()
method of_tkinter.TkappType
. (Contributed by Erlend E. Aasland in bpo-38371.)Removed namespace package support from
unittest
discovery. It was introduced in Python 3.4 but has been broken since Python 3.7. (Contributed by Inada Naoki in bpo-23882.)Removed the undocumented private
float.__set_format__()
method, previously known 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 in bpo-46852.)The
--experimental-isolated-subinterpreters
configure flag (and correspondingEXPERIMENTAL_ISOLATED_SUBINTERPRETERS
macro) have been removed.Pynche — The Pythonically Natural Color and Hue Editor — has been moved out of
Tools/scripts
and is being developed independently from the Python source tree.
Porting to Python 3.11¶
This section lists previously described changes and other bugfixes in the Python API that may require changes to your Python code.
Porting notes for the C API are listed separately.
open()
,io.open()
,codecs.open()
andfileinput.FileInput
no longer accept'U'
(“universal newline”) in the file mode. In Python 3, “universal newline” mode is used by default whenever a file is opened in text mode, and the'U'
flag has been deprecated since Python 3.3. The newline parameter to these functions controls how universal newlines work. (Contributed by Victor Stinner in bpo-37330.)ast.AST
node positions are now validated when provided tocompile()
and other related functions. If invalid positions are detected, aValueError
will be raised. (Contributed by Pablo Galindo in gh-93351)Prohibited passing non-
concurrent.futures.ThreadPoolExecutor
executors toasyncio.loop.set_default_executor()
following a deprecation in Python 3.8. (Contributed by Illia Volochii in bpo-43234.)calendar
: Thecalendar.LocaleTextCalendar
andcalendar.LocaleHTMLCalendar
classes now uselocale.getlocale()
, instead of usinglocale.getdefaultlocale()
, if no locale is specified. (Contributed by Victor Stinner in bpo-46659.)The
pdb
module now reads the.pdbrc
configuration file with the'UTF-8'
encoding. (Contributed by Srinivas Reddy Thatiparthy (శ్రీనివాస్ రెడ్డి తాటిపర్తి) in bpo-41137.)The population parameter of
random.sample()
must be a sequence, and automatic conversion ofset
s tolist
s is no longer supported. Also, if the sample size is larger than the population size, aValueError
is raised. (Contributed by Raymond Hettinger in bpo-40465.)The random optional parameter of
random.shuffle()
was removed. It was previously an arbitrary random function to use for the shuffle; now,random.random()
(its previous default) will always be used.In
re
Regular Expression Syntax, global inline flags (e.g.(?i)
) can now only be used at the start of regular expressions. Using them elsewhere has been deprecated since Python 3.6. (Contributed by Serhiy Storchaka in bpo-47066.)In the
re
module, several long-standing bugs where fixed that, in rare cases, could cause capture groups to get the wrong result. Therefore, this could change the captured output in these cases. (Contributed by Ma Lin in bpo-35859.)
Build Changes¶
CPython now has PEP 11 Tier 3 support for cross compiling to the WebAssembly platforms Emscripten (
wasm32-unknown-emscripten
, i.e. Python in the browser) and WebAssembly System Interface (WASI) (wasm32-unknown-wasi
). The effort is inspired by previous work like Pyodide. These platforms provide a limited subset of POSIX APIs; Python standard libraries features and modules related to networking, processes, threading, signals, mmap, and users/groups are not available or don’t work. (Emscripten contributed by Christian Heimes and Ethan Smith in gh-84461 and WASI contributed by Christian Heimes in gh-90473; platforms promoted in gh-95085)Building CPython now requires:
The
Py_NO_NAN
macro has been removed. Since CPython now requires IEEE 754 floats, NaN values are always available. (Contributed by Victor Stinner in bpo-46656.)The
tkinter
package now requires Tcl/Tk version 8.5.12 or newer. (Contributed by Serhiy Storchaka in bpo-46996.)Build dependencies, compiler flags, and linker flags for most stdlib extension modules are now detected by configure. libffi, libnsl, libsqlite3, zlib, bzip2, liblzma, libcrypt, Tcl/Tk, and uuid flags are detected by pkg-config (when available).
tkinter
now requires a pkg-config command to detect development settings for Tcl/Tk headers and libraries. (Contributed by Christian Heimes and Erlend Egeberg Aasland in bpo-45847, bpo-45747, and bpo-45763.)libpython is no longer linked against libcrypt. (Contributed by Mike Gilbert in bpo-45433.)
CPython can now be built with the ThinLTO option via passing
thin
to--with-lto
, i.e.--with-lto=thin
. (Contributed by Donghee Na and Brett Holman in bpo-44340.)Freelists for object structs can now be disabled. A new configure option
--without-freelists
can be used to disable all freelists except empty tuple singleton. (Contributed by Christian Heimes in bpo-45522.)Modules/Setup
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 a main binary or library. (Contributed by Brett Cannon and Christian Heimes in bpo-45548, bpo-45570, bpo-45571, and bpo-43974.)Note
Use the environment variables
TCLTK_CFLAGS
andTCLTK_LIBS
to manually specify the location of Tcl/Tk headers and libraries. The configure options--with-tcltk-includes
and--with-tcltk-libs
have been removed.On RHEL 7 and CentOS 7 the development packages do not provide
tcl.pc
andtk.pc
; useTCLTK_LIBS="-ltk8.5 -ltkstub8.5 -ltcl8.5"
. The directoryMisc/rhel7
contains.pc
files and instructions on how to build Python with RHEL 7’s and CentOS 7’s Tcl/Tk and OpenSSL.CPython will now use 30-bit digits by default for the Python
int
implementation. Previously, the default was to use 30-bit digits on platforms 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 in bpo-45569.)
C API Changes¶
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()
andPyThreadState_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 asPY_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:bf_getbuffer
andbf_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 (viaPyCMethod
). (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()
andPyFloat_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()
andPyErr_SetHandledException()
. These are alternatives toPyErr_SetExcInfo()
andPyErr_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¶
Some macros have been converted to static inline functions to avoid macro pitfalls. The change should be mostly transparent to users, as the replacement functions will cast their arguments to the expected types to avoid compiler warnings due to static type checks. However, when the limited C API is set to >=3.11, these casts are not done, and callers will need to cast arguments to their expected types. See PEP 670 for more details. (Contributed by Victor Stinner and Erlend E. Aasland in gh-89653.)
PyErr_SetExcInfo()
no longer uses 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 in bpo-45711.)PyErr_GetExcInfo()
now derives thetype
andtraceback
fields of the result from the exception instance (thevalue
field). (Contributed by Irit Katriel in bpo-45711.)_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 in bpo-46608.)_PyFrameEvalFunction()
now takes_PyInterpreterFrame*
as its second parameter, instead ofPyFrameObject*
. See PEP 523 for more details of how to use this function pointer type.PyCode_New()
andPyCode_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.PyCodeObject
no longer has theco_code
,co_varnames
,co_cellvars
andco_freevars
fields. Instead, usePyCode_GetCode()
,PyCode_GetVarnames()
,PyCode_GetCellvars()
andPyCode_GetFreevars()
respectively to access them via the C API. (Contributed by Brandt Bucher in bpo-46841 and Ken Jin in gh-92154 and gh-94936.)The old trashcan macros (
Py_TRASHCAN_SAFE_BEGIN
/Py_TRASHCAN_SAFE_END
) are now deprecated. They should be replaced by the new 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_VERSION_HEX >= 0x03080000 # define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_BEGIN(op, dealloc) # define CPy_TRASHCAN_END(op) Py_TRASHCAN_END #else # define CPy_TRASHCAN_BEGIN(op, dealloc) Py_TRASHCAN_SAFE_BEGIN(op) # define CPy_TRASHCAN_END(op) Py_TRASHCAN_SAFE_END(op) #endif
The
PyType_Ready()
function now raises an error if a type is defined with thePy_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 withPy_SET_TYPE(obj, new_type)
: see thePy_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 withPy_SET_SIZE(obj, new_size)
: see thePy_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 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 in bpo-45434.)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. If they have been included directly, consider includingPython.h
instead. (Contributed by Victor Stinner in bpo-35134.)The
PyUnicode_CHECK_INTERNED()
macro has been excluded from the limited C API. It was never usable there, because it used internal structures which are not available in the limited C API. (Contributed by Victor Stinner in bpo-46007.)The following frame functions and type are now directly available with
#include <Python.h>
, it’s no longer needed to add#include <frameobject.h>
:(Contributed by Victor Stinner in gh-93937.)
The
PyFrameObject
structure members have been removed from the public C API.While the documentation notes that the
PyFrameObject
fields are subject to change at any time, they have been stable for a long time and were used in several popular extensions.In Python 3.11, the frame struct was reorganized to allow performance optimizations. Some fields were removed entirely, as they were details of the old implementation.
PyFrameObject
fields:f_back
: usePyFrame_GetBack()
.f_blockstack
: removed.f_builtins
: usePyFrame_GetBuiltins()
.f_code
: usePyFrame_GetCode()
.f_gen
: usePyFrame_GetGenerator()
.f_globals
: usePyFrame_GetGlobals()
.f_iblock
: removed.f_lasti
: usePyFrame_GetLasti()
. Code usingf_lasti
withPyCode_Addr2Line()
should usePyFrame_GetLineNumber()
instead; it may be faster.f_lineno
: usePyFrame_GetLineNumber()
f_locals
: usePyFrame_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. ThePyFrame_GetBack()
function must be called instead.Debuggers that accessed the
f_locals
directly must callPyFrame_GetLocals()
instead. They no longer need to callPyFrame_FastToLocalsWithError()
orPyFrame_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, usePyThreadState_GetFrame()
(function added to Python 3.9 by bpo-40429). Warning: the function returns a strong reference, need to callPy_XDECREF()
.tracing
: changed, usePyThreadState_EnterTracing()
andPyThreadState_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()
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.
The
PyConfig.module_search_paths_set
field must now be set to 1 for initialization to usePyConfig.module_search_paths
to initializesys.path
. Otherwise, initialization will recalculate the path and replace any values added tomodule_search_paths
.PyConfig_Read()
no longer calculates the initial search path, and will not fill any values intoPyConfig.module_search_paths
. To calculate default paths and then modify them, finish initialization and usePySys_GetObject()
to retrievesys.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 thePyBytesObject
. UsePyObject_Hash()
instead. (Contributed by Inada Naoki in bpo-46864.)
Pending Removal in Python 3.12¶
The following C APIs have been deprecated in earlier Python releases, and will be removed in Python 3.12.
PyUnicode_AS_DATA()
PyUnicode_AS_UNICODE()
PyUnicode_AsUnicodeAndSize()
PyUnicode_AsUnicode()
PyUnicode_FromUnicode()
PyUnicode_GET_DATA_SIZE()
PyUnicode_GET_SIZE()
PyUnicode_GetSize()
PyUnicode_IS_COMPACT()
PyUnicode_IS_READY()
PyUnicode_WSTR_LENGTH()
_PyUnicode_AsUnicode()
PyUnicode_WCHAR_KIND
PyUnicode_InternImmortal()
Removed¶
PyFrame_BlockSetup()
andPyFrame_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()
andPy_UNICODE_FILL()
macros, deprecated since Python 3.3. UsePyUnicode_CopyCharacters()
ormemcpy()
(wchar_t*
string), andPyUnicode_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 thePy_IS_INFINITY()
macro. (Contributed by Victor Stinner in bpo-45440.)The following items are no longer available when
Py_LIMITED_API
is defined: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 thePyWeakReference
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 thePyTypeObject.tp_members
member instead. (Contributed by Victor Stinner in bpo-40170.)Remove the
HAVE_PY_SET_53BIT_PRECISION
macro (moved to the internal C API). (Contributed by Victor Stinner in bpo-45412.)
Remove the
Py_UNICODE
encoder APIs, as they have been deprecated since Python 3.3, are little used and are inefficient relative to the recommended alternatives.The removed functions are:
PyUnicode_Encode()
PyUnicode_EncodeASCII()
PyUnicode_EncodeLatin1()
PyUnicode_EncodeUTF7()
PyUnicode_EncodeUTF8()
PyUnicode_EncodeUTF16()
PyUnicode_EncodeUTF32()
PyUnicode_EncodeUnicodeEscape()
PyUnicode_EncodeRawUnicodeEscape()
PyUnicode_EncodeCharmap()
PyUnicode_TranslateCharmap()
PyUnicode_EncodeDecimal()
PyUnicode_TransformDecimalToASCII()
See PEP 624 for details and migration guidance. (Contributed by Inada Naoki in bpo-44029.)
Notable changes in 3.11.4¶
tarfile¶
The extraction methods in
tarfile
, andshutil.unpack_archive()
, have a new a filter argument that allows limiting tar features than may be surprising or dangerous, such as creating files outside the destination directory. See Extraction filters for details. In Python 3.12, use without the filter argument will show aDeprecationWarning
. In Python 3.14, the default will switch to'data'
. (Contributed by Petr Viktorin in PEP 706.)
Notable changes in 3.11.5¶
OpenSSL¶
Windows builds and macOS installers from python.org now use OpenSSL 3.0.


String conversion and formatting

String conversion and formatting¶
Functions for number conversion and formatted string output.
-
int PyOS_snprintf(char *str, size_t size, const char *format, ...)¶
- Part of the Stable ABI.
Output not more than size bytes to str according to the format string format and the extra arguments. See the Unix man page snprintf(3).
-
int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)¶
- Part of the Stable ABI.
Output not more than size bytes to str according to the format string format and the variable argument list va. Unix man page vsnprintf(3).
PyOS_snprintf()
and PyOS_vsnprintf()
wrap the Standard C library
functions snprintf()
and vsnprintf()
. Their purpose is to
guarantee consistent behavior in corner cases, which the Standard C functions do
not.
The wrappers ensure that str[size-1]
is always '\0'
upon return. They
never write more than size bytes (including the trailing '\0'
) into str.
Both functions require that str != NULL
, size > 0
, format != NULL
and size < INT_MAX
. Note that this means there is no equivalent to the C99
n = snprintf(NULL, 0, ...)
which would determine the necessary buffer size.
The return value (rv) for these functions should be interpreted as follows:
When
0 <= rv < size
, the output conversion was successful and rv characters were written to str (excluding the trailing'\0'
byte atstr[rv]
).When
rv >= size
, the output conversion was truncated and a buffer withrv + 1
bytes would have been needed to succeed.str[size-1]
is'\0'
in this case.When
rv < 0
, the output conversion failed andstr[size-1]
is'\0'
in this case too, but the rest of str is undefined. The exact cause of the error depends on the underlying platform.
The following functions provide locale-independent string to number conversions.
-
unsigned long PyOS_strtoul(const char *str, char **ptr, int base)¶
- Part of the Stable ABI.
Convert the initial part of the string in
str
to an unsigned long value according to the givenbase
, which must be between2
and36
inclusive, or be the special value0
.Leading white space and case of characters are ignored. If
base
is zero it looks for a leading0b
,0o
or0x
to tell which base. If these are absent it defaults to10
. Base must be 0 or between 2 and 36 (inclusive). Ifptr
is non-NULL
it will contain a pointer to the end of the scan.If the converted value falls out of range of corresponding return type, range error occurs (
errno
is set toERANGE
) andULONG_MAX
is returned. If no conversion can be performed,0
is returned.See also the Unix man page strtoul(3).
Added in version 3.2.
-
long PyOS_strtol(const char *str, char **ptr, int base)¶
- Part of the Stable ABI.
Convert the initial part of the string in
str
to an long value according to the givenbase
, which must be between2
and36
inclusive, or be the special value0
.Same as
PyOS_strtoul()
, but return a long value instead andLONG_MAX
on overflows.See also the Unix man page strtol(3).
Added in version 3.2.
-
double PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_exception)¶
- Part of the Stable ABI.
Convert a string
s
to a double, raising a Python exception on failure. The set of accepted strings corresponds to the set of strings accepted by Python’sfloat()
constructor, except thats
must not have leading or trailing whitespace. The conversion is independent of the current locale.If
endptr
isNULL
, convert the whole string. RaiseValueError
and return-1.0
if the string is not a valid representation of a floating-point number.If endptr is not
NULL
, convert as much of the string as possible and set*endptr
to point to the first unconverted character. If no initial segment of the string is the valid representation of a floating-point number, set*endptr
to point to the beginning of the string, raise ValueError, and return-1.0
.If
s
represents a value that is too large to store in a float (for example,"1e500"
is such a string on many platforms) then ifoverflow_exception
isNULL
returnPy_INFINITY
(with an appropriate sign) and don’t set any exception. Otherwise,overflow_exception
must point to a Python exception object; raise that exception and return-1.0
. In both cases, set*endptr
to point to the first character after the converted value.If any other error occurs during the conversion (for example an out-of-memory error), set the appropriate Python exception and return
-1.0
.Added in version 3.1.
-
char *PyOS_double_to_string(double val, char format_code, int precision, int flags, int *ptype)¶
- Part of the Stable ABI.
Convert a double val to a string using supplied format_code, precision, and flags.
format_code must be one of
'e'
,'E'
,'f'
,'F'
,'g'
,'G'
or'r'
. For'r'
, the supplied precision must be 0 and is ignored. The'r'
format code specifies the standardrepr()
format.flags can be zero or more of the following values or-ed together:
-
Py_DTSF_SIGN¶
Always precede the returned string with a sign character, even if val is non-negative.
-
Py_DTSF_ADD_DOT_0¶
Ensure that the returned string will not look like an integer.
-
Py_DTSF_ALT¶
Apply “alternate” formatting rules. See the documentation for the
PyOS_snprintf()
'#'
specifier for details.
-
Py_DTSF_NO_NEG_0¶
Negative zero is converted to positive zero.
Added in version 3.11.
If ptype is non-
NULL
, then the value it points to will be set to one of the following constants depending on the type of val:*ptype
type of val
-
Py_DTST_FINITE¶
finite number
-
Py_DTST_INFINITE¶
infinite number
-
Py_DTST_NAN¶
not a number
The return value is a pointer to buffer with the converted string or
NULL
if the conversion failed. The caller is responsible for freeing the returned string by callingPyMem_Free()
.Added in version 3.1.
-
Py_DTSF_SIGN¶
-
int PyOS_mystricmp(const char *str1, const char *str2)¶
-
int PyOS_mystrnicmp(const char *str1, const char *str2, Py_ssize_t size)¶
- Part of the Stable ABI.
Case insensitive comparison of strings. These functions work almost identically to
strcmp()
andstrncmp()
(respectively), except that they ignore the case of ASCII characters.Return
0
if the strings are equal, a negative value if str1 sorts lexicographically before str2, or a positive value if it sorts after.In the str1 or str2 arguments, a NUL byte marks the end of the string. For
PyOS_mystrnicmp()
, the size argument gives the maximum size of the string, as if NUL was present at the index given by size.These functions do not use the locale.
-
int PyOS_stricmp(const char *str1, const char *str2)¶
-
int PyOS_strnicmp(const char *str1, const char *str2, Py_ssize_t size)¶
Case insensitive comparison of strings.
On Windows, these are aliases of
stricmp()
andstrnicmp()
, respectively.On other platforms, they are aliases of
PyOS_mystricmp()
andPyOS_mystrnicmp()
, respectively.
Character classification and conversion¶
The following macros provide locale-independent (unlike the C standard library
ctype.h
) character classification and conversion.
The argument must be a signed or unsigned char.
-
Py_ISALNUM(c)¶
Return true if the character c is an alphanumeric character.
-
Py_ISALPHA(c)¶
Return true if the character c is an alphabetic character (
a-z
andA-Z
).
-
Py_ISDIGIT(c)¶
Return true if the character c is a decimal digit (
0-9
).
-
Py_ISLOWER(c)¶
Return true if the character c is a lowercase ASCII letter (
a-z
).
-
Py_ISUPPER(c)¶
Return true if the character c is an uppercase ASCII letter (
A-Z
).
-
Py_ISSPACE(c)¶
Return true if the character c is a whitespace character (space, tab, carriage return, newline, vertical tab, or form feed).
-
Py_ISXDIGIT(c)¶
Return true if the character c is a hexadecimal digit (
0-9
,a-f
, andA-F
).
-
Py_TOLOWER(c)¶
Return the lowercase equivalent of the character c.
-
Py_TOUPPER(c)¶
Return the uppercase equivalent of the character c.


Graphic User Interface FAQ¶
General GUI Questions¶
What GUI toolkits exist for Python?¶
Standard builds of Python include an object-oriented interface to the Tcl/Tk widget set, called tkinter. This is probably the easiest to install (since it comes included with most binary distributions of Python) and use. For more info about Tk, including pointers to the source, see the Tcl/Tk home page. Tcl/Tk is fully portable to the macOS, Windows, and Unix platforms.
Depending on what platform(s) you are aiming at, there are also several alternatives. A list of cross-platform and platform-specific GUI frameworks can be found on the python wiki.
Tkinter questions¶
How do I freeze Tkinter applications?¶
Freeze is a tool to create stand-alone applications. When freezing Tkinter applications, the applications will not be truly stand-alone, as the application will still need the Tcl and Tk libraries.
One solution is to ship the application with the Tcl and Tk libraries, and point
to them at run-time using the TCL_LIBRARY
and TK_LIBRARY
environment variables.
Various third-party freeze libraries such as py2exe and cx_Freeze have handling for Tkinter applications built-in.
Can I have Tk events handled while waiting for I/O?¶
On platforms other than Windows, yes, and you don’t even
need threads! But you’ll have to restructure your I/O
code a bit. Tk has the equivalent of Xt’s XtAddInput()
call, which allows you
to register a callback function which will be called from the Tk mainloop when
I/O is possible on a file descriptor. See File Handlers.
I can’t get key bindings to work in Tkinter: why?¶
An often-heard complaint is that event handlers bound
to events with the bind()
method
don’t get handled even when the appropriate key is pressed.
The most common cause is that the widget to which the binding applies doesn’t have “keyboard focus”. Check out the Tk documentation for the focus command. Usually a widget is given the keyboard focus by clicking in it (but not for labels; see the takefocus option).