The new PYTHONMALLOC environment variable
can now be used to debug the interpreter memory allocation and access
errors.

Significant improvements in the standard library:

The asyncio module has received new features, significant
usability and performance improvements, and a fair amount of bug fixes.
Starting with Python 3.6 the asyncio module is no longer provisional
and its API is considered stable.

The tracemalloc module has been significantly reworked
and is now used to provide better output for ResourceWarning
as well as provide better diagnostics for memory allocation errors.
See the PYTHONMALLOC section for more
information.

Security improvements:

The new secrets module has been added to simplify the generation of
cryptographically strong pseudo-random numbers suitable for
managing secrets such as account authentication, tokens, and similar.

On Linux, os.urandom() now blocks until the system urandom entropy
pool is initialized to increase the security. See the PEP 524 for the
rationale.

The py.exe launcher, when used interactively, no longer prefers
Python 2 over Python 3 when the user doesn’t specify a version (via
command line arguments or a config file). Handling of shebang lines
remains unchanged - “python” refers to Python 2 in that case.

python.exe and pythonw.exe have been marked as long-path aware,
which means that the 260 character path limit may no longer apply.
See removing the MAX_PATH limitation for details.

A ._pth file can be added to force isolated mode and fully specify
all search paths to avoid registry and environment lookup. See
the documentation for more information.

Formatted string literals are prefixed with 'f' and are similar to
the format strings accepted by str.format(). They contain replacement
fields surrounded by curly braces. The replacement fields are expressions,
which are evaluated at run time, and then formatted using the
format() protocol:

>>> name="Fred">>> f"He said his name is {name}."'He said his name is Fred.'>>> width=10>>> precision=4>>> value=decimal.Decimal("12.34567")>>> f"result: {value:{width}.{precision}}"# nested fields'result: 12.35'

Just as for function annotations, the Python interpreter does not attach any
particular meaning to variable annotations and only stores them in the
__annotations__ attribute of a class or module.

In contrast to variable declarations in statically typed languages,
the goal of annotation syntax is to provide an easy way to specify structured
type metadata for third party tools and libraries via the abstract syntax tree
and the __annotations__ attribute.

PEP 515 adds the ability to use underscores in numeric literals for
improved readability. For example:

>>> 1_000_000_000_000_0001000000000000000>>> 0x_FF_FF_FF_FF4294967295

Single underscores are allowed between digits and after any base
specifier. Leading, trailing, or multiple underscores in a row are not
allowed.

The string formatting language also now has support
for the '_' option to signal the use of an underscore for a thousands
separator for floating point presentation types and for integer
presentation type 'd'. For integer presentation types 'b',
'o', 'x', and 'X', underscores will be inserted every 4
digits:

PEP 492 introduced support for native coroutines and async / await
syntax to Python 3.5. A notable limitation of the Python 3.5 implementation
is that it was not possible to use await and yield in the same
function body. In Python 3.6 this restriction has been lifted, making it
possible to define asynchronous generators:

asyncdefticker(delay,to):"""Yield numbers from 0 to *to* every *delay* seconds."""foriinrange(to):yieldiawaitasyncio.sleep(delay)

PEP 487 extends the descriptor protocol to include the new optional
__set_name__() method. Whenever a new class is defined, the new
method will be called on all descriptors included in the definition, providing
them with a reference to the class being defined and the name given to the
descriptor within the class namespace. In other words, instances of
descriptors can now know the attribute name of the descriptor in the
owner class:

classIntField:def__get__(self,instance,owner):returninstance.__dict__[self.name]def__set__(self,instance,value):ifnotisinstance(value,int):raiseValueError(f'expecting integer in {self.name}')instance.__dict__[self.name]=value# this is the new initializer:def__set_name__(self,owner,name):self.name=nameclassModel:int_field=IntField()

File system paths have historically been represented as str
or bytes objects. This has led to people who write code which
operate on file system paths to assume that such objects are only one
of those two types (an int representing a file descriptor
does not count as that is not a file path). Unfortunately that
assumption prevents alternative object representations of file system
paths like pathlib from working with pre-existing code,
including Python’s standard library.

To fix this situation, a new interface represented by
os.PathLike has been defined. By implementing the
__fspath__() method, an object signals that it
represents a path. An object can then provide a low-level
representation of a file system path as a str or
bytes object. This means an object is considered
path-like if it implements
os.PathLike or is a str or bytes object
which represents a file system path. Code can use os.fspath(),
os.fsdecode(), or os.fsencode() to explicitly get a
str and/or bytes representation of a path-like
object.

The built-in open() function has been updated to accept
os.PathLike objects, as have all relevant functions in the
os and os.path modules, and most other functions and
classes in the standard library. The os.DirEntry class
and relevant classes in pathlib have also been updated to
implement os.PathLike.

The hope is that updating the fundamental functions for operating
on file system paths will lead to third-party code to implicitly
support all path-like objects without any
code changes, or at least very minimal ones (e.g. calling
os.fspath() at the beginning of code before operating on a
path-like object).

Here are some examples of how the new interface allows for
pathlib.Path to be used more easily and transparently with
pre-existing code:

In most world locations, there have been and will be times when local clocks
are moved back. In those times, intervals are introduced in which local
clocks show the same time twice in the same day. In these situations, the
information displayed on a local clock (or stored in a Python datetime
instance) is insufficient to identify a particular moment in time.

Representing filesystem paths is best performed with str (Unicode) rather than
bytes. However, there are some situations where using bytes is sufficient and
correct.

Prior to Python 3.6, data loss could result when using bytes paths on Windows.
With this change, using bytes to represent paths is now supported on Windows,
provided those bytes are encoded with the encoding returned by
sys.getfilesystemencoding(), which now defaults to 'utf-8'.

The order-preserving aspect of this new implementation is considered an
implementation detail and should not be relied upon (this may change in
the future, but it is desired to have this new dict implementation in
the language for a few releases before changing the language spec to mandate
order-preserving semantics for all current and future Python
implementations; this also helps preserve backwards-compatibility
with older versions of the language where random iteration order is
still in effect, e.g. Python 3.5).

While Python provides extensive support to customize how code
executes, one place it has not done so is in the evaluation of frame
objects. If you wanted some way to intercept frame evaluation in
Python there really wasn’t any way without directly manipulating
function pointers for defined functions.

PEP 523 changes this by providing an API to make frame
evaluation pluggable at the C level. This will allow for tools such
as debuggers and JITs to intercept frame evaluation before the
execution of Python code begins. This enables the use of alternative
evaluation implementations for Python code, tracking frame
evaluation, etc.

This API is not part of the limited C API and is marked as private to
signal that usage of this API is expected to be limited and only
applicable to very select, low-level use-cases. Semantics of the
API will change with Python as necessary.

It is now also possible to force the usage of the malloc() allocator of
the C library for all Python memory allocations using PYTHONMALLOC=malloc.
This is helpful when using external memory debuggers like Valgrind on
a Python compiled in release mode.

On error, the debug hooks on Python memory allocators now use the
tracemalloc module to get the traceback where a memory block was
allocated.

A global or nonlocal statement must now textually appear
before the first use of the affected name in the same scope.
Previously this was a SyntaxWarning.

It is now possible to set a special method to
None to indicate that the corresponding operation is not available.
For example, if a class sets __iter__() to None, the class
is not iterable.
(Contributed by Andrew Barnert and Ivan Levkivskyi in bpo-25958.)

Long sequences of repeated traceback lines are now abbreviated as
"[Previouslinerepeated{count}moretimes]" (see
traceback for an example).
(Contributed by Emanuel Barry in bpo-26823.)

Import now raises the new exception ModuleNotFoundError
(subclass of ImportError) when it cannot find a module. Code
that currently checks for ImportError (in try-except) will still work.
(Contributed by Eric Snow in bpo-15767.)

Class methods relying on zero-argument super() will now work correctly
when called from metaclass methods during class creation.
(Contributed by Martin Teichmann in bpo-23722.)

The main purpose of the new secrets module is to provide an obvious way
to reliably generate cryptographically strong pseudo-random values suitable
for managing secrets, such as account authentication, tokens, and similar.

Warning

Note that the pseudo-random generators in the random module
should NOT be used for security purposes. Use secrets
on Python 3.6+ and os.urandom() on Python 3.5 and earlier.

New Transport.is_closing()
method to check if the transport is closing or closed.
(Contributed by Yury Selivanov.)

The loop.create_server()
method can now accept a list of hosts.
(Contributed by Yann Sionneau.)

New loop.create_future()
method to create Future objects. This allows alternative event
loop implementations, such as
uvloop, to provide a faster
asyncio.Future implementation.
(Contributed by Yury Selivanov in bpo-27041.)

New loop.get_exception_handler()
method to get the current exception handler.
(Contributed by Yury Selivanov in bpo-27040.)

New StreamReader.readuntil()
method to read data from the stream until a separator bytes
sequence appears.
(Contributed by Mark Korenberg.)

The loop.getaddrinfo()
method is optimized to avoid calling the system getaddrinfo
function if the address is already resolved.
(Contributed by A. Jesse Jiryu Davis.)

The loop.stop()
method has been changed to stop the loop immediately after
the current iteration. Any new callbacks scheduled as a result
of the last iteration will be discarded.
(Contributed by Guido van Rossum in bpo-25593.)

The namedtuple() function now accepts an optional
keyword argument module, which, when specified, is used for
the __module__ attribute of the returned named tuple class.
(Contributed by Raymond Hettinger in bpo-17941.)

The verbose and rename arguments for
namedtuple() are now keyword-only.
(Contributed by Raymond Hettinger in bpo-25628.)

The ThreadPoolExecutor
class constructor now accepts an optional thread_name_prefix argument
to make it possible to customize the names of the threads created by the
pool.
(Contributed by Gregory P. Smith in bpo-27664.)

The contextlib.AbstractContextManager class has been added to
provide an abstract base class for context managers. It provides a
sensible default implementation for __enter__() which returns
self and leaves __exit__() an abstract method. A matching
class has been added to the typing module as
typing.ContextManager.
(Contributed by Brett Cannon in bpo-25609.)

The datetime and time classes have
the new fold attribute used to disambiguate local time
when necessary. Many functions in the datetime have been
updated to support local time disambiguation.
See Local Time Disambiguation section for more
information.
(Contributed by Alexander Belopolsky in bpo-24773.)

The datetime.isoformat() function
now accepts an optional timespec argument that specifies the number
of additional components of the time value to include.
(Contributed by Alessandro Cucci and Alexander Belopolsky in bpo-19475.)

The default_format attribute has been removed from
distutils.command.sdist.sdist and the formats
attribute defaults to ['gztar']. Although not anticipated,
any code relying on the presence of default_format may
need to be adapted. See bpo-27819 for more details.

The new email API, enabled via the policy keyword to various constructors, is
no longer provisional. The email documentation has been reorganized and
rewritten to focus on the new API, while retaining the old documentation for
the legacy API. (Contributed by R. David Murray in bpo-24277.)

The email.mime classes now all accept an optional policy keyword.
(Contributed by Berker Peksag in bpo-27331.)

Two new enumeration base classes have been added to the enum module:
Flag and IntFlags. Both are used to define
constants that can be combined using the bitwise operators.
(Contributed by Ethan Furman in bpo-23591.)

Many standard library modules have been updated to use the
IntFlags class for their constants.

The new enum.auto value can be used to assign values to enum
members automatically:

hashlib supports OpenSSL 1.1.0. The minimum recommend version is 1.0.2.
(Contributed by Christian Heimes in bpo-26470.)

BLAKE2 hash functions were added to the module. blake2b()
and blake2s() are always available and support the full
feature set of BLAKE2.
(Contributed by Christian Heimes in bpo-26798 based on code by
Dmitry Chestnykh and Samuel Neves. Documentation written by Dmitry Chestnykh.)

The idlelib package is being modernized and refactored to make IDLE look and
work better and to make the code easier to understand, test, and improve. Part
of making IDLE look better, especially on Linux and Mac, is using ttk widgets,
mostly in the dialogs. As a result, IDLE no longer runs with tcl/tk 8.4. It
now requires tcl/tk 8.5 or 8.6. We recommend running the latest release of
either.

‘Modernizing’ includes renaming and consolidation of idlelib modules. The
renaming of files with partial uppercase names is similar to the renaming of,
for instance, Tkinter and TkFont to tkinter and tkinter.font in 3.0. As a
result, imports of idlelib files that worked in 3.5 will usually not work in
3.6. At least a module name change will be needed (see idlelib/README.txt),
sometimes more. (Name changes contributed by Al Swiegart and Terry Reedy in
bpo-24225. Most idlelib patches since have been and will be part of the
process.)

In compensation, the eventual result with be that some idlelib classes will be
easier to use, with better APIs and docstrings explaining them. Additional
useful information will be added to idlelib when available.

New in 3.6.2:

Multiple fixes for autocompletion. (Contributed by Louie Lu in bpo-15786.)

The IDLE features formerly implemented as extensions have been reimplemented
as normal features. Their settings have been moved from the Extensions tab
to other dialog tabs.
(Contributed by Charles Wohlganger and Terry Jan Reedy in bpo-27099.)

The Settings dialog (Options, Configure IDLE) has been partly rewritten
to improve both appearance and function.
(Contributed by Cheryl Sabella and Terry Jan Reedy in multiple issues.)

New in 3.6.4:

The font sample now includes a selection of non-Latin characters so that
users can better see the effect of selecting a particular font.
(Contributed by Terry Jan Reedy in bpo-13802.)
The sample can be edited to include other characters.
(Contributed by Serhiy Storchaka in bpo-31860.)

New in 3.6.6:

Editor code context option revised. Box displays all context lines up to
maxlines. Clicking on a context line jumps the editor to that line. Context
colors for custom themes is added to Highlights tab of Settings dialog.
(Contributed by Cheryl Sabella and Terry Jan Reedy in bpo-33642,
bpo-33768, and bpo-33679.)

On Windows, a new API call tells Windows that tk scales for DPI. On Windows
8.1+ or 10, with DPI compatibility properties of the Python binary
unchanged, and a monitor resolution greater than 96 DPI, this should
make text and lines sharper. It should otherwise have no effect.
(Contributed by Terry Jan Reedy in bpo-33656.)

New in 3.6.7:

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

Import now raises the new exception ModuleNotFoundError
(subclass of ImportError) when it cannot find a module. Code
that current checks for ImportError (in try-except) will still work.
(Contributed by Eric Snow in bpo-15767.)

The inspect.signature() function now reports the
implicit .0 parameters generated by the compiler for comprehension and
generator expression scopes as if they were positional-only parameters called
implicit0. (Contributed by Jelle Zijlstra in bpo-19611.)

To reduce code churn when upgrading from Python 2.7 and the legacy
inspect.getargspec() API, the previously documented deprecation of
inspect.getfullargspec() has been reversed. While this function is
convenient for single/source Python 2/3 code bases, the richer
inspect.signature() interface remains the recommended approach for new
code. (Contributed by Nick Coghlan in bpo-27172)

Objects that need __new__ called with keyword arguments can now be pickled
using pickle protocols older than protocol version 4.
Protocol version 4 already supports this case. (Contributed by Serhiy
Storchaka in bpo-24164.)

Added support of modifier spans in regular expressions. Examples:
'(?i:p)ython' matches 'python' and 'Python', but not 'PYTHON';
'(?i)g(?-i:v)r' matches 'GvR' and 'gvr', but not 'GVR'.
(Contributed by Serhiy Storchaka in bpo-433028.)

Match object groups can be accessed by __getitem__, which is
equivalent to group(). So mo['name'] is now equivalent to
mo.group('name'). (Contributed by Eric Smith in bpo-24454.)

Private and special attribute names now are omitted unless the prefix starts
with underscores. A space or a colon is added after some completed keywords.
(Contributed by Serhiy Storchaka in bpo-25011 and bpo-25209.)

The getsockopt() constants SO_DOMAIN,
SO_PROTOCOL, SO_PEERSEC, and SO_PASSSEC are now supported.
(Contributed by Christian Heimes in bpo-26907.)

The setsockopt() now supports the
setsockopt(level,optname,None,optlen:int) form.
(Contributed by Christian Heimes in bpo-27744.)

The socket module now supports the address family
AF_ALG to interface with Linux Kernel crypto API. ALG_*,
SOL_ALG and sendmsg_afalg() were added.
(Contributed by Christian Heimes in bpo-27744 with support from
Victor Stinner.)

New Linux constants TCP_USER_TIMEOUT and TCP_CONGESTION were added.
(Contributed by Omar Sandoval, issue:26273).

ssl supports OpenSSL 1.1.0. The minimum recommend version is 1.0.2.
(Contributed by Christian Heimes in bpo-26470.)

3DES has been removed from the default cipher suites and ChaCha20 Poly1305
cipher suites have been added.
(Contributed by Christian Heimes in bpo-27850 and bpo-27766.)

SSLContext has better default configuration for options
and ciphers.
(Contributed by Christian Heimes in bpo-28043.)

SSL session can be copied from one client-side connection to another
with the new SSLSession class. TLS session resumption can
speed up the initial handshake, reduce latency and improve performance
(Contributed by Christian Heimes in bpo-19500 based on a draft by
Alex Warhawk.)

The new get_ciphers() method can be used to
get a list of enabled ciphers in order of cipher priority.

All constants and flags have been converted to IntEnum and
IntFlags.
(Contributed by Christian Heimes in bpo-28025.)

Server and client-side specific TLS protocols for SSLContext
were added.
(Contributed by Christian Heimes in bpo-28085.)

subprocess.Popen destructor now emits a ResourceWarning warning
if the child process is still running. Use the context manager protocol (withproc:...) or explicitly call the wait() method to
read the exit status of the child process. (Contributed by Victor Stinner in
bpo-26741.)

The subprocess.Popen constructor and all functions that pass arguments
through to it now accept encoding and errors arguments. Specifying either
of these will enable text mode for the stdin, stdout and stderr streams.
(Contributed by Steve Dower in bpo-6135.)

The new getfilesystemencodeerrors() function returns the name of
the error mode used to convert between Unicode filenames and bytes filenames.
(Contributed by Steve Dower in bpo-27781.)

On Windows the return value of the getwindowsversion() function
now includes the platform_version field which contains the accurate major
version, minor version and build number of the current operating system,
rather than the version that is being emulated for the process
(Contributed by Steve Dower in bpo-27932.)

The new Timer.autorange() convenience
method has been added to call Timer.timeit()
repeatedly so that the total run time is greater or equal to 200 milliseconds.
(Contributed by Steven D’Aprano in bpo-6422.)

timeit now warns when there is substantial (4x) variance
between best and worst times.
(Contributed by Serhiy Storchaka in bpo-23552.)

Added methods trace_add(),
trace_remove() and trace_info()
in the tkinter.Variable class. They replace old methods
trace_variable(), trace(),
trace_vdelete() and
trace_vinfo() that use obsolete Tcl commands and might
not work in future versions of Tcl.
(Contributed by Serhiy Storchaka in bpo-22115).

The typing.ClassVar type construct has been added to
mark class variables. As introduced in PEP 526, a variable annotation
wrapped in ClassVar indicates that a given attribute is intended to be used as
a class variable and should not be set on instances of that class.
(Contributed by Ivan Levkivskyi in Github #280.)

A new TYPE_CHECKING constant that is assumed to be
True by the static type chekers, but is False at runtime.
(Contributed by Guido van Rossum in Github #230.)

A new NewType() helper function has been added to create
lightweight distinct types for annotations:

If a HTTP request has a file or iterable body (other than a
bytes object) but no Content-Length header, rather than
throwing an error, AbstractHTTPHandler now
falls back to use chunked transfer encoding.
(Contributed by Demian Brecht and Rolf Krahl in bpo-12319.)

The Python interpreter now uses a 16-bit wordcode instead of bytecode which
made a number of opcode optimizations possible.
(Contributed by Demur Rumed with input and reviews from
Serhiy Storchaka and Victor Stinner in bpo-26647 and bpo-28050.)

The asyncio.Future class now has an optimized C implementation.
(Contributed by Yury Selivanov and INADA Naoki in bpo-26081.)

The asyncio.Task class now has an optimized
C implementation. (Contributed by Yury Selivanov in bpo-28544.)

Various implementation improvements in the typing module
(such as caching of generic types) allow up to 30 times performance
improvements and reduced memory footprint.

The ASCII decoder is now up to 60 times as fast for error handlers
surrogateescape, ignore and replace (Contributed
by Victor Stinner in bpo-24870).

The ASCII and the Latin1 encoders are now up to 3 times as fast for the
error handler surrogateescape
(Contributed by Victor Stinner in bpo-25227).

The UTF-8 encoder is now up to 75 times as fast for error handlers
ignore, replace, surrogateescape, surrogatepass (Contributed
by Victor Stinner in bpo-25267).

The UTF-8 decoder is now up to 15 times as fast for error handlers
ignore, replace and surrogateescape (Contributed
by Victor Stinner in bpo-25301).

bytes%args is now up to 2 times faster. (Contributed by Victor Stinner
in bpo-25349).

bytearray%args is now between 2.5 and 5 times faster. (Contributed by
Victor Stinner in bpo-25399).

Optimize bytes.replace(b'',b'.') and bytearray.replace(b'',b'.'):
up to 80% faster. (Contributed by Josh Snider in bpo-26574).

Allocator functions of the PyMem_Malloc() domain
(PYMEM_DOMAIN_MEM) now use the pymalloc memory allocator instead of malloc() function of the C library. The
pymalloc allocator is optimized for objects smaller or equal to 512 bytes
with a short lifetime, and use malloc() for larger memory blocks.
(Contributed by Victor Stinner in bpo-26249).

Passing keyword arguments to a function has an
overhead in comparison with passing positional arguments. Now in extension functions implemented with using
Argument Clinic this overhead is significantly decreased.
(Contributed by Serhiy Storchaka in bpo-27574).

Optimized glob() and iglob() functions in the
glob module; they are now about 3–6 times faster.
(Contributed by Serhiy Storchaka in bpo-25596).

Python now requires some C99 support in the toolchain to build.
Most notably, Python now uses standard integer types and macros in
place of custom macros like PY_LONG_LONG.
For more information, see PEP 7 and bpo-17884.

Cross-compiling CPython with the Android NDK and the Android API level set to
21 (Android 5.0 Lollipop) or greater runs successfully. While Android is not
yet a supported platform, the Python test suite runs on the Android emulator
with only about 16 tests failures. See the Android meta-issue bpo-26865.

The --enable-optimizations configure flag has been added. Turning it on
will activate expensive optimizations like PGO.
(Original patch by Alecsandru Patrascu of Intel in bpo-26359.)

async and await are not recommended to be used as variable, class,
function or module names. Introduced by PEP 492 in Python 3.5, they will
become proper keywords in Python 3.7. Starting in Python 3.6, the use of
async or await as names will generate a DeprecationWarning.

The __aiter__() method is now expected to return an asynchronous
iterator directly instead of returning an awaitable as previously.
Doing the former will trigger a DeprecationWarning. Backward
compatibility will be removed in Python 3.7.
(Contributed by Yury Selivanov in bpo-27243.)

A backslash-character pair that is not a valid escape sequence now generates
a DeprecationWarning. Although this will eventually become a
SyntaxError, that will not be for several Python releases.
(Contributed by Emanuel Barry in bpo-27364.)

When performing a relative import, falling back on __name__ and
__path__ from the calling module when __spec__ or
__package__ are not defined now raises an ImportWarning.
(Contributed by Rose Ames in bpo-25791.)

Unlike other dbm implementations, the dbm.dumb module
creates databases with the 'rw' mode and allows modifying the database
opened with the 'r' mode. This behavior is now deprecated and will
be removed in 3.8.
(Contributed by Serhiy Storchaka in bpo-21708.)

The undocumented extra_path argument to the
Distribution constructor is now considered deprecated
and will raise a warning if set. Support for this parameter will be
removed in a future Python release. See bpo-27919 for details.

Support for inline flags (?letters) in the middle of the regular
expression has been deprecated and will be removed in a future Python
version. Flags at the start of a regular expression are still allowed.
(Contributed by Serhiy Storchaka in bpo-22493.)

A couple of protocols and functions of the ssl module are now
deprecated. Some features will no longer be available in future versions
of OpenSSL. Other features are deprecated in favor of a different API.
(Contributed by Christian Heimes in bpo-28022 and bpo-26470.)

The pyvenv script has been deprecated in favour of python3-mvenv.
This prevents confusion as to what Python interpreter pyvenv is
connected to and thus what Python interpreter will be used by the virtual
environment. (Contributed by Brett Cannon in bpo-25154.)

The --with-system-ffi configure flag is now on by default on non-macOS
UNIX platforms. It may be disabled by using --without-system-ffi, but
using the flag is deprecated and will not be accepted in Python 3.7.
macOS is unaffected by this change. Note that many OS distributors already
use the --with-system-ffi flag when building their system Python.

Unknown escapes consisting of '\' and an ASCII letter in
regular expressions will now cause an error. In replacement templates for
re.sub() they are still allowed, but deprecated.
The re.LOCALE flag can now only be used with binary patterns.

inspect.getmoduleinfo() was removed (was deprecated since CPython 3.3).
inspect.getmodulename() should be used for obtaining the module
name for a given path.
(Contributed by Yury Selivanov in bpo-13248.)

traceback.Ignore class and traceback.usage, traceback.modname,
traceback.fullmodname, traceback.find_lines_from_code,
traceback.find_lines, traceback.find_strings,
traceback.find_executable_lines methods were removed from the
traceback module. They were undocumented methods deprecated since
Python 3.2 and equivalent functionality is available from private methods.

The tk_menuBar() and tk_bindForTraversal() dummy methods in
tkinter widget classes were removed (corresponding Tk commands
were obsolete since Tk 4.0).

The undocumented IN, CDROM, DLFCN, TYPES, CDIO, and
STROPTS modules have been removed. They had been available in the
platform specific Lib/plat-*/ directories, but were chronically out of
date, inconsistently available across platforms, and unmaintained. The
script that created these modules is still available in the source
distribution at Tools/scripts/h2py.py.

The output of a special Python build with defined COUNT_ALLOCS,
SHOW_ALLOC_COUNT or SHOW_TRACK_COUNT macros is now off by
default. It can be re-enabled using the -Xshowalloccount option.
It now outputs to stderr instead of stdout.
(Contributed by Serhiy Storchaka in bpo-23034.)

The format of the co_lnotab attribute of code objects changed to support
a negative line number delta. By default, Python does not emit bytecode with
a negative line number delta. Functions using frame.f_lineno,
PyFrame_GetLineNumber() or PyCode_Addr2Line() are not affected.
Functions directly decoding co_lnotab should be updated to use a signed
8-bit integer type for the line number delta, but this is only required to
support applications using a negative line number delta. See
Objects/lnotab_notes.txt for the co_lnotab format and how to decode
it, and see the PEP 511 for the rationale.

The functions in the compileall module now return booleans instead
of 1 or 0 to represent success or failure, respectively. Thanks to
booleans being a subclass of integers, this should only be an issue if you7
were doing identity checks for 1 or 0. See bpo-25768.

The socket.socket.close() method now raises an exception if
an error (e.g. EBADF) was reported by the underlying system call.
(Contributed by Martin Panter in bpo-26685.)

The decode_data argument for the smtpd.SMTPChannel and
smtpd.SMTPServer constructors is now False by default.
This means that the argument passed to
process_message() is now a bytes object by
default, and process_message() will be passed keyword arguments.
Code that has already been updated in accordance with the deprecation
warning generated by 3.5 will not be affected.

Subclasses of type which don’t override type.__new__ may no
longer use the one-argument form to get the type of an object.

As part of PEP 487, the handling of keyword arguments passed to
type (other than the metaclass hint, metaclass) is now
consistently delegated to object.__init_subclass__(). This means that
type.__new__() and type.__init__() both now accept arbitrary
keyword arguments, but object.__init_subclass__() (which is called from
type.__new__()) will reject them by default. Custom metaclasses
accepting additional keyword arguments will need to adjust their calls to
type.__new__() (whether direct or via super) accordingly.

In distutils.command.sdist.sdist, the default_format
attribute has been removed and is no longer honored. Instead, the
gzipped tarfile format is the default on all platforms and no
platform-specific selection is made.
In environments where distributions are
built on Windows and zip distributions are required, configure
the project with a setup.cfg file containing the following:

[sdist]formats=zip

This behavior has also been backported to earlier Python versions
by Setuptools 26.0.0.

In the urllib.request module and the
http.client.HTTPConnection.request() method, if no Content-Length
header field has been specified and the request body is a file object,
it is now sent with HTTP 1.1 chunked encoding. If a file object has to
be sent to a HTTP 1.0 server, the Content-Length value now has to be
specified by the caller.
(Contributed by Demian Brecht and Rolf Krahl with tweaks from
Martin Panter in bpo-12319.)

re.sub() now raises an error for invalid numerical group
references in replacement templates even if the pattern is not
found in the string. The error message for invalid group references
now includes the group index and the position of the reference.
(Contributed by SilentGhost, Serhiy Storchaka in bpo-25953.)

when custom metaclasses are combined with zero-argument super() or
direct references from methods to the implicit __class__ closure
variable, the implicit __classcell__ namespace entry must now be passed
up to type.__new__ for initialisation. Failing to do so will result in
a DeprecationWarning in Python 3.6 and a RuntimeError in
Python 3.8.

With the introduction of ModuleNotFoundError, import system consumers
may start expecting import system replacements to raise that more specific
exception when appropriate, rather than the less-specific ImportError.
To provide future compatibility with such consumers, implementors of
alternative import systems that completely replace __import__() will
need to update their implementations to raise the new subclass when a module
can’t be found at all. Implementors of compliant plugins to the default
import system shouldn’t need to make any changes, as the default import
system will raise the new subclass when appropriate.

To simplify cross-compilation, and to ensure that CPython can reliably be
compiled without requiring an existing version of Python to already be
available, the autotools-based build system no longer attempts to implicitly
recompile generated files based on file modification times.

Instead, a new makeregen-all command has been added to force regeneration
of these files when desired (e.g. after an initial version of Python has
already been built based on the pregenerated versions).

More selective regeneration targets are also defined - see
Makefile.pre.in for details.

The PyExc_RecursionErrorInst singleton that was part of the public API
has been removed as its members being never cleared may cause a segfault
during finalization of the interpreter.
(Contributed by Xavier de Gaye in bpo-22898 and bpo-30697.)

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