What’s New In Python 3.8 — Python 3.9.7 documentation

Bạn đang xem: What’s New In Python 3.8 — Python 3.9.7 documentation

This article explains the new features in Python 3.8, compared to 3.7.
For full details, see the changelog.

The pickle protocol 5 introduces support for out-of-band buffers where PEP 3118 -compatible data can be transmitted separately from the main pickle stream, at the discretion of the communication layer.

When pickle is used to transfer large data between Python processes in order to take advantage of multi-core or multi-machine processing, it is important to optimize the transfer by reducing memory copies, and possibly by applying custom techniques such as data-dependent compression.

This is currently provisional. The aim is to make it fully public in Python 3.9.

The Vectorcall Protocol is added to the Python/C API. It is meant to formalize existing optimizations which were already done for various classes. Any static type implementing a callable can use this protocol.

This PEP also adds _PyRuntimeState.preconfig ( PyPreConfig type) and PyInterpreterState.config ( PyConfig type) fields to these internal structures. PyInterpreterState.config becomes the new reference configuration, replacing global configuration variables and other private variables.

The PEP 587 adds a new C API to configure the Python Initialization providing finer control on the whole configuration and better error reporting.

The PEP adds an Audit Hook and Verified Open Hook. Both are available from Python and native code, allowing applications and frameworks written in pure Python code to take advantage of extra notifications, while also allowing embedders or system administrators to deploy builds of Python where auditing is always enabled.

The = specifier will display the whole expression so that calculations can be shown:

The usual f-string format specifiers allow more control over how the result of the expression is displayed:

Added an = specifier to f-string s. An f-string such as f'{expr=}’ will expand to the text of the expression, an equal sign, then the representation of the evaluated expression. For example:

On the other hand, pkg-config python3.8 –libs no longer contains -lpython3.8 . C extensions must not be linked to libpython (except on Android and Cygwin, whose cases are handled by the script); this change is backward incompatible on purpose. (Contributed by Victor Stinner in bpo-36721 .)

Add a pkg-config python-3.8-embed module to embed Python into an application: pkg-config python-3.8-embed –libs includes -lpython3.8 . To support both 3.8 and older, try pkg-config python-X.Y-embed –libs first and fallback to pkg-config python-X.Y –libs (without –embed ) if the previous command fails (replace X.Y with the Python version).

To embed Python into an application, a new –embed option must be passed to python3-config –libs –embed to get -lpython3.8 (link the application to libpython). To support both 3.8 and older, try python3-config –libs –embed first and fallback to python3-config –libs (without –embed ) if the previous command fails.

On Unix, when Python is built in debug mode, import now also looks for C extensions compiled in release mode and for C extensions compiled with the stable ABI. (Contributed by Victor Stinner in bpo-36722 .)

On Unix, C extensions are no longer linked to libpython except on Android and Cygwin. It is now possible for a statically linked Python to load a C extension built using a shared library Python. (Contributed by Victor Stinner in bpo-21536 .)

Release builds and debug builds are now ABI compatible: defining the Py_DEBUG macro no longer implies the Py_TRACE_REFS macro, which introduces the only ABI incompatibility. The Py_TRACE_REFS macro, which adds the sys.getobjects() function and the PYTHONDUMPREFS environment variable, can be set using the new ./configure –with-trace-refs build option. (Contributed by Victor Stinner in bpo-36465 .)

Python now uses the same ABI whether it’s built in release or debug mode. On Unix, when Python is built in debug mode, it is now possible to load C extensions built in release mode and C extensions built using the stable ABI.

The location of the cache is reported in sys.pycache_prefix ( None indicates the default location in __pycache__ subdirectories).

The new PYTHONPYCACHEPREFIX setting (also available as -X pycache_prefix ) configures the implicit bytecode cache to use a separate parallel filesystem tree, rather than the default __pycache__ subdirectories within each source directory.

This greatly simplifies the implementation of functions and methods that need to accept arbitrary từ khóa arguments. For example, here is an excerpt from code in the collections module:

# a and b are used in two ways

Since the parameters to the left of / are not exposed as possible keywords, the parameters names remain available for use in **kwargs :

A further benefit of marking a parameter as positional-only is that it allows the parameter name to be changed in the future without risk of breaking client code. For example, in the statistics module, the parameter name dist may be changed in the future. This was made possible with the following function specification:

Another use case is to preclude từ khóa arguments when the parameter name is not helpful. For example, the builtin len() function has the signature len(obj, /) . This precludes awkward calls such as:

One use case for this notation is that it allows pure Python functions to fully emulate behaviors of existing C coded functions. For example, the built-in divmod() function does not accept từ khóa arguments:

In the following example, parameters a and b are positional-only, while c or d can be positional or từ khóa, and e or f are required to be keywords:

There is a new function parameter syntax / to indicate that some function parameters must be specified positionally and cannot be used as từ khóa arguments. This is the same notation shown by help() for C functions annotated with Larry Hastings’ Argument Clinic tool.

Try to limit use of the walrus operator to clean cases that reduce complexity and improve readability.

Another motivating use case arises in list comprehensions where a value computed in a filtering condition is also needed in the expression body:

The operator is also useful with while-loops that compute a value to test loop termination and then need that same value again in the body of the loop:

A similar benefit arises during regular expression matching where match objects are needed twice, once to test whether a match occurred and another to extract a subgroup:

In this example, the assignment expression helps avoid calling len() twice:

There is new syntax := that assigns values to variables as part of a larger expression. It is affectionately known as “the walrus operator” due to its resemblance to the eyes and tusks of a walrus .

The object.__reduce__() method can now return a tuple from two to six elements long. Formerly, five was the limit. The new, optional sixth element is a callable with a (obj, state) signature. This allows the direct control over the state-updating behavior of a specific object. If not None, this callable will have priority over the object’s __setstate__() method. (Contributed by Pierre Glaser and Olivier Grisel in bpo-35900 .)

The guaranteed execution order is helpful with assignment expressions because variables assigned in the key expression will be available in the value expression:

Dict comprehensions have been synced-up with dict literals so that the key is computed first and the value second:

Modular inverses arise in the solution of linear Diophantine equations . For example, to find integer solutions for 4258? + 147? = 369 , first rewrite as 4258? ≡ 369 (mod 147) then solve:

For integers, the three-argument form of the pow() function now permits the exponent to be negative in the case where the base is relatively prime to the modulus. It then computes a modular inverse to the base when the exponent is -1 , and a suitable power of that inverse for other negative exponents. For example, to compute the modular multiplicative inverse of 38 modulo 137, write:

mean() got some positional-only arguments passed as từ khóa arguments: ‘data’

Here’s an example that alters the statistics.mean() function to prevent the data parameter from being used as a từ khóa argument:

Some advanced styles of programming require updating the types.CodeType object for an existing function. Since code objects are immutable, a new code object needs to be created, one that is modeled on the existing code object. With 19 parameters, this was somewhat tedious. Now, the new replace() method makes it possible to create a clone with a few altered parameters.

When the Python interpreter is interrupted by Ctrl-C (SIGINT) and the resulting KeyboardInterrupt exception is not caught, the Python process now exits via a SIGINT signal or with the correct exit code such that the calling process can detect that it died due to a Ctrl-C. Shells on POSIX and Windows use this to properly terminate scripts in interactive sessions. (Contributed by Google via Gregory P. Smith in bpo-1054041 .)

Arithmetic operations between subclasses of datetime.date or datetime.datetime and datetime.timedelta objects now return an instance of the subclass, rather than the base class. This also affects the return type of operations whose implementation (directly or indirectly) uses datetime.timedelta arithmetic, such as astimezone() . (Contributed by Paul Ganssle in bpo-32417 .)

When a comma is missed in code such as [(10, 20) (30, 40)] , the compiler displays a SyntaxWarning with a helpful suggestion. This improves on just having a TypeError indicating that the first tuple was not callable. (Contributed by Serhiy Storchaka in bpo-15248 .)

Generalized iterable unpacking in yield and return statements no longer requires enclosing parentheses. This brings the yield and return syntax into better agreement with normal assignment syntax:

The syntax allowed for từ khóa names in function calls was further restricted. In particular, f((từ khóa)=arg) is no longer allowed. It was never intended to permit more than a bare name on the left-hand side of a từ khóa argument assignment term. (Contributed by Benjamin Peterson in bpo-34641 .)

Dict and dictviews are now iterable in reversed insertion order using reversed() . (Contributed by Rémi Lapeyre in bpo-33462 .)

Constructors of int , float and complex will now use the __index__() special method, if available and the corresponding method __int__() , __float__() or __complex__() is not available. (Contributed by Serhiy Storchaka in bpo-20092 .)

The bool , int , and fractions.Fraction types now have an as_integer_ratio() method like that found in float and decimal.Decimal . This minor API extension makes it possible to write numerator, denominator = x.as_integer_ratio() and have it work across multiple numeric types. (Contributed by Lisa Roach in bpo-33073 and Raymond Hettinger in bpo-37819 .)

A continue statement was illegal in the finally clause due to a problem with the implementation. In Python 3.8 this restriction was lifted. (Contributed by Serhiy Storchaka in bpo-32489 .)

# Note following example requires that the popular “requests”

The new importlib.metadata module provides (provisional) support for reading metadata from third-party packages. For example, it can extract an installed package’s version number, list of entry points, and more:

Improved Modules¶

ast¶

AST nodes now have end_lineno and end_col_offset attributes,
which give the precise location of the end of the node. (This only
applies to nodes that have lineno and col_offset attributes.)

New function ast.get_source_segment() returns the source code
for a specific AST node.

(Contributed by Ivan Levkivskyi in bpo-33416.)

The ast.parse() function has some new flags:

• type_comments=True causes it to return the text of PEP 484 and
  PEP 526 type comments associated with certain AST nodes;

• mode='func_type' can be used to parse PEP 484 “signature type
  comments” (returned for function definition AST nodes);

• feature_version=(3, N) allows specifying an earlier Python 3
  version. For example, feature_version=(3, 4) will treat
  async and await as non-reserved words.

(Contributed by Guido van Rossum in bpo-35766.)

asyncio¶

asyncio.run() has graduated from the provisional to stable API. This
function can be used to execute a coroutine and return the result while
automatically managing the sự kiện loop. For example:

import
 
asyncio

async
 
def
 
main
():
    
await
 
asyncio
.
sleep
(
)
    
return
 
42

asyncio
.
run
(
main
())

This is roughly equivalent to:

import
 
asyncio

async
 
def
 
main
():
    
await
 
asyncio
.
sleep
(
)
    
return
 
42

loop
 
=
 
asyncio
.
new_event_loop
()
asyncio
.
set_event_loop
(
loop
)
try
:
    
loop
.
run_until_complete
(
main
())
finally
:
    
asyncio
.
set_event_loop
(
None
)
    
loop
.
close
()

The actual implementation is significantly more complex. Thus,
asyncio.run() should be the preferred way of running asyncio programs.

(Contributed by Yury Selivanov in bpo-32314.)

Running python -m asyncio launches a natively async REPL. This allows rapid
experimentation with code that has a top-level await. There is no
longer a need to directly call asyncio.run() which would spawn a new sự kiện
loop on every invocation:

$ python -m asyncio
asyncio REPL 3.8.0
Use "await" directly instead of "asyncio.run()".
Type "help", "copyright", "credits" or "license" for more information.
>>> import asyncio
>>> await asyncio.sleep(10, result='hello')
hello

(Contributed by Yury Selivanov in bpo-37028.)

The exception asyncio.CancelledError now inherits from
BaseException rather than Exception and no longer inherits
from concurrent.futures.CancelledError.
(Contributed by Yury Selivanov in bpo-32528.)

On Windows, the default sự kiện loop is now ProactorEventLoop.
(Contributed by Victor Stinner in bpo-34687.)

ProactorEventLoop now also supports UDP.
(Contributed by Adam Meily and Andrew Svetlov in bpo-29883.)

ProactorEventLoop can now be interrupted by
KeyboardInterrupt (“CTRL+C”).
(Contributed by Vladimir Matveev in bpo-23057.)

Added asyncio.Task.get_coro() for getting the wrapped coroutine
within an asyncio.Task.
(Contributed by Alex Grönholm in bpo-36999.)

Asyncio tasks can now be named, either by passing the name từ khóa
argument to asyncio.create_task() or
the create_task() sự kiện loop method, or by
calling the set_name() method on the task object. The
task name is visible in the repr() output of asyncio.Task and
can also be retrieved using the get_name() method.
(Contributed by Alex Grönholm in bpo-34270.)

Added support for
Happy Eyeballs to
asyncio.loop.create_connection(). To specify the behavior, two new
parameters have been added: happy_eyeballs_delay and interleave. The Happy
Eyeballs algorithm improves responsiveness in applications that support IPv4
and IPv6 by attempting to simultaneously kết nối using both.
(Contributed by twisteroid ambassador in bpo-33530.)

builtins¶

The compile() built-in has been improved to accept the
ast.PyCF_ALLOW_TOP_LEVEL_AWAIT flag. With this new flag passed,
compile() will allow top-level await, async for and async with
constructs that are usually considered invalid syntax. Asynchronous code object
marked with the CO_COROUTINE flag may then be returned.
(Contributed by Matthias Bussonnier in bpo-34616)

collections¶

The _asdict() method for
collections.namedtuple() now returns a dict instead of a
collections.OrderedDict. This works because regular dicts have
guaranteed ordering since Python 3.7. If the extra features of
OrderedDict are required, the suggested remediation is to cast the
result to the desired type: OrderedDict(nt._asdict()).
(Contributed by Raymond Hettinger in bpo-35864.)

cProfile¶

The cProfile.Profile class can now be used as a context manager.
Profile a block of code by running:

import
 
cProfile

with
 
cProfile
.
Profile
()
 
as
 
profiler
:
      
# code to be profiled
      
...

(Contributed by Scott Sanderson in bpo-29235.)

csv¶

The csv.DictReader now returns instances of dict instead of
a collections.OrderedDict. The tool is now faster and uses less
memory while still preserving the field order.
(Contributed by Michael Selik in bpo-34003.)

curses¶

Added a new variable holding structured version information for the
underlying ncurses library: ncurses_version.
(Contributed by Serhiy Storchaka in bpo-31680.)

ctypes¶

On Windows, CDLL and subclasses now accept a winmode parameter
to specify flags for the underlying LoadLibraryEx call. The default flags are
set to only load DLL dependencies from trusted locations, including the path
where the DLL is stored (if a full or partial path is used to load the initial
DLL) and paths added by add_dll_directory().
(Contributed by Steve Dower in bpo-36085.)

gc¶

get_objects() can now receive an optional generation parameter
indicating a generation to get objects from.
(Contributed by Pablo Galindo in bpo-36016.)

gettext¶

Added pgettext() and its variants.
(Contributed by Franz Glasner, Éric Araujo, and Cheryl Sabella in bpo-2504.)

gzip¶

Added the mtime parameter to gzip.compress() for reproducible output.
(Contributed by Guo Ci Teo in bpo-34898.)

A BadGzipFile exception is now raised instead of OSError
for certain types of invalid or corrupt gzip files.
(Contributed by Filip Gruszczyński, Michele Orrù, and Zackery Spytz in
bpo-6584.)

IDLE and idlelib¶

Output over N lines (50 by default) is squeezed down to a button.
N can be changed in the PyShell section of the General page of the
Settings dialog. Fewer, but possibly extra long, lines can be squeezed by
right clicking on the output. Squeezed output can be expanded in place
by double-clicking the button or into the clipboard or a separate window
by right-clicking the button. (Contributed by Tal Einat in bpo-1529353.)

Add “Run Customized” to the Run thực đơn to run a module with customized
settings. Any command line arguments entered are added to sys.argv.
They also re-appear in the box for the next customized run. One can also
suppress the normal Shell main module restart. (Contributed by Cheryl
Sabella, Terry Jan Reedy, and others in bpo-5680 and bpo-37627.)

Added optional line numbers for IDLE editor windows. Windows
open without line numbers unless set otherwise in the General
tab of the configuration dialog. Line numbers for an existing
window are shown and hidden in the Options thực đơn.
(Contributed by Tal Einat and Saimadhav Heblikar in bpo-17535.)

OS native encoding is now used for converting between Python strings and Tcl
objects. This allows IDLE to work with emoji and other non-BMP characters.
These characters can be displayed or copied and pasted to or from the
clipboard. Converting strings from Tcl to Python and back now never fails.
(Many people worked on this for eight years but the problem was finally
solved by Serhiy Storchaka in bpo-13153.)

New in 3.8.1:

Add option to toggle cursor blink off. (Contributed by Zackery Spytz
in bpo-4603.)

Escape key now closes IDLE completion windows. (Contributed by Johnny
Najera in bpo-38944.)

The changes above have been backported to 3.7 maintenance releases.

Add keywords to module name completion list. (Contributed by Terry J.
Reedy in bpo-37765.)

inspect¶

The inspect.getdoc() function can now find docstrings for __slots__
if that attribute is a dict where the values are docstrings.
This provides documentation options similar to what we already have
for property(), classmethod(), and staticmethod():

class
 
AudioClip
:
    
__slots__
 
=
 
{
'bit_rate'
:
 
'expressed in kilohertz to one decimal place'
,
                 
'duration'
:
 
'in seconds, rounded up to an integer'
}
    
def
 
__init__
(
self
,
 
bit_rate
,
 
duration
):
        
self
.
bit_rate
 
=
 
round
(
bit_rate
 
/
 
1000.0
,
 
1
)
        
self
.
duration
 
=
 
ceil
(
duration
)

(Contributed by Raymond Hettinger in bpo-36326.)

io¶

In development mode (-X env) and in debug build, the
io.IOBase finalizer now logs the exception if the close() method
fails. The exception is ignored silently by default in release build.
(Contributed by Victor Stinner in bpo-18748.)

json.tool¶

Add option --json-lines to parse every input line as a separate JSON object.
(Contributed by Weipeng Hong in bpo-31553.)

logging¶

Added a force từ khóa argument to logging.basicConfig()
When set to true, any existing handlers attached
to the root logger are removed and closed before carrying out the
configuration specified by the other arguments.

This solves a long-standing problem. Once a logger or basicConfig() had
been called, subsequent calls to basicConfig() were silently ignored.
This made it difficult to update, experiment with, or teach the various
logging configuration options using the interactive prompt or a Jupyter
notebook.

(Suggested by Raymond Hettinger, implemented by Dong-hee Na, and
reviewed by Vinay Sajip in bpo-33897.)

math¶

Added new function math.dist() for computing Euclidean distance
between two points. (Contributed by Raymond Hettinger in bpo-33089.)

Expanded the math.hypot() function to handle multiple dimensions.
Formerly, it only supported the 2-D case.
(Contributed by Raymond Hettinger in bpo-33089.)

Added new function, math.prod(), as analogous function to sum()
that returns the product of a ‘start’ value (default: 1) times an iterable of
numbers:

>>> 
prior
 
=
 
0.8
>>> 
likelihoods
 
=
 
[
0.625
,
 
0.84
,
 
0.30
]
>>> 
math
.
prod
(
likelihoods
,
 
start
=
prior
)
0.126

(Contributed by Pablo Galindo in bpo-35606.)

Added two new combinatoric functions math.perm() and math.comb():

>>> 
math
.
perm
(
10
,
 
3
)
    
# Permutations of 10 things taken 3 at a time
720
>>> 
math
.
comb
(
10
,
 
3
)
    
# Combinations of 10 things taken 3 at a time
120

(Contributed by Yash Aggarwal, Keller Fuchs, Serhiy Storchaka, and Raymond
Hettinger in bpo-37128, bpo-37178, and bpo-35431.)

Added a new function math.isqrt() for computing accurate integer square
roots without conversion to floating point. The new function supports
arbitrarily large integers. It is faster than floor(sqrt(n)) but slower
than math.sqrt():

>>> 
r
 
=
 
650320427
>>> 
s
 
=
 
r
 
**
 
2
>>> 
isqrt
(
s
 
-
 
1
)
         
# correct
650320426
>>> 
floor
(
sqrt
(
s
 
-
 
1
))
   
# incorrect
650320427

(Contributed by Mark Dickinson in bpo-36887.)

The function math.factorial() no longer accepts arguments that are not
int-like. (Contributed by Pablo Galindo in bpo-33083.)

mmap¶

The mmap.mmap class now has an madvise() method to
access the madvise() system call.
(Contributed by Zackery Spytz in bpo-32941.)

multiprocessing¶

Added new multiprocessing.shared_memory module.
(Contributed by Davin Potts in bpo-35813.)

On macOS, the spawn start method is now used by default.
(Contributed by Victor Stinner in bpo-33725.)

os¶

Added new function add_dll_directory() on Windows for providing
additional tìm kiếm paths for native dependencies when importing extension
modules or loading DLLs using ctypes.
(Contributed by Steve Dower in bpo-36085.)

A new os.memfd_create() function was added to wrap the
memfd_create() syscall.
(Contributed by Zackery Spytz and Christian Heimes in bpo-26836.)

On Windows, much of the manual logic for handling reparse points (including
symlinks and directory junctions) has been delegated to the operating system.
Specifically, os.stat() will now traverse anything supported by the
operating system, while os.lstat() will only open reparse points that
identify as “name surrogates” while others are opened as for os.stat().
In all cases, stat_result.st_mode will only have S_IFLNK set for
symbolic links and not other kinds of reparse points. To identify other kinds
of reparse point, test the new stat_result.st_reparse_tag attribute.

On Windows, os.readlink() is now able to read directory junctions. Note
that islink() will return False for directory junctions,
and so code that checks islink first will continue to treat junctions as
directories, while code that handles errors from os.readlink() may now
treat junctions as links.

(Contributed by Steve Dower in bpo-37834.)

os.path¶

os.path functions that return a boolean result like
exists(), lexists(), isdir(),
isfile(), islink(), and ismount()
now return False instead of raising ValueError or its subclasses
UnicodeEncodeError and UnicodeDecodeError for paths that contain
characters or bytes unrepresentable at the OS level.
(Contributed by Serhiy Storchaka in bpo-33721.)

expanduser() on Windows now prefers the USERPROFILE
environment variable and does not use HOME, which is not normally set
for regular user accounts.
(Contributed by Anthony Sottile in bpo-36264.)

isdir() on Windows no longer returns True for a link to a
non-existent directory.

realpath() on Windows now resolves reparse points, including
symlinks and directory junctions.

(Contributed by Steve Dower in bpo-37834.)

pathlib¶

pathlib.Path methods that return a boolean result like
exists(), is_dir(),
is_file(), is_mount(),
is_symlink(), is_block_device(),
is_char_device(), is_fifo(),
is_socket() now return False instead of raising
ValueError or its subclass UnicodeEncodeError for paths that
contain characters unrepresentable at the OS level.
(Contributed by Serhiy Storchaka in bpo-33721.)

Added pathlib.Path.link_to() which creates a hard link pointing
to a path.
(Contributed by Joannah Nanjekye in bpo-26978)

pickle¶

pickle extensions subclassing the C-optimized Pickler
can now override the pickling logic of functions and classes by defining the
special reducer_override() method.
(Contributed by Pierre Glaser and Olivier Grisel in bpo-35900.)

plistlib¶

Added new plistlib.UID and enabled support for reading and writing
NSKeyedArchiver-encoded binary plists.
(Contributed by Jon Janzen in bpo-26707.)

pprint¶

The pprint module added a sort_dicts parameter to several functions.
By default, those functions continue to sort dictionaries before rendering or
printing. However, if sort_dicts is set to false, the dictionaries retain
the order that keys were inserted. This can be useful for comparison to JSON
inputs during debugging.

In addition, there is a convenience new function, pprint.pp() that is
like pprint.pprint() but with sort_dicts defaulting to False:

>>> 
from
 
pprint
 
import
 
pprint
,
 
pp
>>> 
d
 
=
 
dict
(
source
=
'input.txt'
,
 
operation
=
'filter'
,
 
destination
=
'output.txt'
)
>>> 
pp
(
d
,
 
width
=
40
)
                  
# Original order
{'source': 'input.txt',
 'operation': 'filter',
 'destination': 'output.txt'}
>>> 
pprint
(
d
,
 
width
=
40
)
              
# Keys sorted alphabetically
{'destination': 'output.txt',
 'operation': 'filter',
 'source': 'input.txt'}

(Contributed by Rémi Lapeyre in bpo-30670.)

py_compile¶

py_compile.compile() now supports silent mode.
(Contributed by Joannah Nanjekye in bpo-22640.)

shlex¶

The new shlex.join() function acts as the inverse of shlex.split().
(Contributed by Bo Bayles in bpo-32102.)

shutil¶

shutil.copytree() now accepts a new dirs_exist_ok từ khóa argument.
(Contributed by Josh Bronson in bpo-20849.)

shutil.make_archive() now defaults to the modern pax (POSIX.1-2001)
format for new archives to improve portability and standards conformance,
inherited from the corresponding change to the tarfile module.
(Contributed by C.A.M. Gerlach in bpo-30661.)

shutil.rmtree() on Windows now removes directory junctions without
recursively removing their contents first.
(Contributed by Steve Dower in bpo-37834.)

socket¶

Added create_server() and has_dualstack_ipv6()
convenience functions to automate the necessary tasks usually involved when
creating a server socket, including accepting both IPv4 and IPv6 connections
on the same socket. (Contributed by Giampaolo Rodolà in bpo-17561.)

The socket.if_nameindex(), socket.if_nametoindex(), and
socket.if_indextoname() functions have been implemented on Windows.
(Contributed by Zackery Spytz in bpo-37007.)

ssl¶

Added post_handshake_auth to enable and
verify_client_post_handshake() to initiate TLS 1.3
post-handshake authentication.
(Contributed by Christian Heimes in bpo-34670.)

statistics¶

Added statistics.fmean() as a faster, floating point variant of
statistics.mean(). (Contributed by Raymond Hettinger and
Steven D’Aprano in bpo-35904.)

Added statistics.geometric_mean()
(Contributed by Raymond Hettinger in bpo-27181.)

Added statistics.multimode() that returns a list of the most
common values. (Contributed by Raymond Hettinger in bpo-35892.)

Added statistics.quantiles() that divides data or a distribution
in to equiprobable intervals (e.g. quartiles, deciles, or percentiles).
(Contributed by Raymond Hettinger in bpo-36546.)

Added statistics.NormalDist, a tool for creating
and manipulating normal distributions of a random variable.
(Contributed by Raymond Hettinger in bpo-36018.)

>>> 
temperature_feb
 
=
 
NormalDist
.
from_samples
([
4
,
 
12
,
 
-
3
,
 
2
,
 
7
,
 
14
])
>>> 
temperature_feb
.
mean
6.0
>>> 
temperature_feb
.
stdev
6.356099432828281

>>> 
temperature_feb
.
cdf
(
3
)
            
# Chance of being under 3 degrees
0.3184678262814532
>>> 
# Relative chance of being 7 degrees versus 10 degrees
>>> 
temperature_feb
.
pdf
(
7
)
 
/
 
temperature_feb
.
pdf
(
10
)
1.2039930378537762

>>> 
el_niño
 
=
 
NormalDist
(
4
,
 
2.5
)
>>> 
temperature_feb
 
+=
 
el_niño
        
# Add in a climate effect
>>> 
temperature_feb
NormalDist(mu=10.0, sigma=6.830080526611674)

>>> 
temperature_feb
 
*
 
(
9
/
5
)
 
+
 
32
      
# Convert to Fahrenheit
NormalDist(mu=50.0, sigma=12.294144947901014)
>>> 
temperature_feb
.
samples
(
3
)
        
# Generate random samples
[7.672102882379219, 12.000027119750287, 4.647488369766392]

sys¶

Add new sys.unraisablehook() function which can be overridden to control
how “unraisable exceptions” are handled. It is called when an exception has
occurred but there is no way for Python to handle it. For example, when a
destructor raises an exception or during garbage collection
(gc.collect()).
(Contributed by Victor Stinner in bpo-36829.)

tarfile¶

The tarfile module now defaults to the modern pax (POSIX.1-2001)
format for new archives, instead of the previous GNU-specific one.
This improves cross-platform portability with a consistent encoding (UTF-8)
in a standardized and extensible format, and offers several other benefits.
(Contributed by C.A.M. Gerlach in bpo-36268.)

threading¶

Add a new threading.excepthook() function which handles uncaught
threading.Thread.run() exception. It can be overridden to control how
uncaught threading.Thread.run() exceptions are handled.
(Contributed by Victor Stinner in bpo-1230540.)

Add a new threading.get_native_id() function and
a native_id
attribute to the threading.Thread class. These return the native
integral Thread ID of the current thread assigned by the kernel.
This feature is only available on certain platforms, see
get_native_id for more information.
(Contributed by Jake Tesler in bpo-36084.)

tokenize¶

The tokenize module now implicitly emits a NEWLINE token when
provided with input that does not have a trailing new line. This behavior
now matches what the C tokenizer does internally.
(Contributed by Ammar Askar in bpo-33899.)

tkinter¶

Added methods selection_from(),
selection_present(),
selection_range() and
selection_to()
in the tkinter.Spinbox class.
(Contributed by Juliette Monsel in bpo-34829.)

Added method moveto()
in the tkinter.Canvas class.
(Contributed by Juliette Monsel in bpo-23831.)

The tkinter.PhotoImage class now has
transparency_get() and
transparency_set() methods. (Contributed by
Zackery Spytz in bpo-25451.)

time¶

Added new clock CLOCK_UPTIME_RAW for macOS 10.12.
(Contributed by Joannah Nanjekye in bpo-35702.)

typing¶

The typing module incorporates several new features:

• A dictionary type with per-key types. See PEP 589 and
  typing.TypedDict.
  TypedDict uses only string keys. By default, every key is required
  to be present. Specify “total=False” to allow keys to be optional:

  class
   
  Location
  (
  TypedDict
  ,
   
  total
  =
  False
  ):
      
  lat_long
  :
   
  tuple
      
  grid_square
  :
   
  str
      
  xy_coordinate
  :
   
  tuple
  

• Literal types. See PEP 586 and typing.Literal.
  Literal types indicate that a parameter or return value
  is constrained to one or more specific literal values:

  def
   
  get_status
  (
  port
  :
   
  int
  )
   
  ->
   
  Literal
  [
  'connected'
  ,
   
  'disconnected'
  ]:
      
  ...
  

• “Final” variables, functions, methods and classes. See PEP 591,
  typing.Final and typing.final().
  The final qualifier instructs a static type checker to restrict
  subclassing, overriding, or reassignment:

  pi
  :
   
  Final
  [
  float
  ]
   
  =
   
  3.1415926536
  

• Protocol definitions. See PEP 544, typing.Protocol and
  typing.runtime_checkable(). Simple ABCs like
  typing.SupportsInt are now Protocol subclasses.

• New protocol class typing.SupportsIndex.

• New functions typing.get_origin() and typing.get_args().

unicodedata¶

The unicodedata module has been upgraded to use the Unicode 12.1.0 release.

New function is_normalized() can be used to verify a string
is in a specific normal form, often much faster than by actually normalizing
the string. (Contributed by Max Belanger, David Euresti, and Greg Price in
bpo-32285 and bpo-37966).

unittest¶

Added AsyncMock to support an asynchronous version of
Mock. Appropriate new assert functions for testing
have been added as well.
(Contributed by Lisa Roach in bpo-26467).

Added addModuleCleanup() and
addClassCleanup() to unittest to support
cleanups for setUpModule() and
setUpClass().
(Contributed by Lisa Roach in bpo-24412.)

Several mock assert functions now also print a list of actual calls upon
failure. (Contributed by Petter Strandmark in bpo-35047.)

unittest module gained support for coroutines to be used as test cases
with unittest.IsolatedAsyncioTestCase.
(Contributed by Andrew Svetlov in bpo-32972.)

Example:

import
 
unittest


class
 
TestRequest
(
unittest
.
IsolatedAsyncioTestCase
):

    
async
 
def
 
asyncSetUp
(
self
):
        
self
.
connection
 
=
 
await
 
AsyncConnection
()

    
async
 
def
 
test_get
(
self
):
        
response
 
=
 
await
 
self
.
connection
.
get
(
"https://example.com"
)
        
self
.
assertEqual
(
response
.
status_code
,
 
200
)

    
async
 
def
 
asyncTearDown
(
self
):
        
await
 
self
.
connection
.
close
()


if
 
__name__
 
==
 
"__main__"
:
    
unittest
.
main
()

venv¶

venv now includes an Activate.ps1 script on all platforms for
activating virtual environments under PowerShell Core 6.1.
(Contributed by Brett Cannon in bpo-32718.)

weakref¶

The proxy objects returned by weakref.proxy() now support the matrix
multiplication operators @ and @= in addition to the other
numeric operators. (Contributed by Mark Dickinson in bpo-36669.)

xml¶

As mitigation against DTD and external entity retrieval, the
xml.dom.minidom and xml.sax modules no longer process
external entities by default.
(Contributed by Christian Heimes in bpo-17239.)

The .find*() methods in the xml.etree.ElementTree module
support wildcard searches like {*}tag which ignores the namespace
and {namespace}* which returns all tags in the given namespace.
(Contributed by Stefan Behnel in bpo-28238.)

The xml.etree.ElementTree module provides a new function
–xml.etree.ElementTree.canonicalize() that implements C14N 2.0.
(Contributed by Stefan Behnel in bpo-13611.)

The target object of xml.etree.ElementTree.XMLParser can
receive namespace declaration events through the new callback methods
start_ns() and end_ns(). Additionally, the
xml.etree.ElementTree.TreeBuilder target can be configured
to process events about comments and processing instructions to include
them in the generated tree.
(Contributed by Stefan Behnel in bpo-36676 and bpo-36673.)

xmlrpc¶

xmlrpc.client.ServerProxy now supports an optional headers từ khóa
argument for a sequence of HTTP headers to be sent with each request. Among
other things, this makes it possible to upgrade from default basic
authentication to faster session authentication.
(Contributed by Cédric Krier in bpo-35153.)

Xem thêm bài viết thuộc chuyên mục: Du Lịch