Virtual environments help create separate Python setups while sharing a
system-wide base install, for ease of maintenance. Virtual environments
have their own set of private site packages (i.e. locally-installed
libraries), and are optionally segregated from the system-wide site
packages. Their concept and implementation are inspired by the popular
virtualenv third-party package, but benefit from tighter integration
with the interpreter core.

This PEP adds the venv module for programmatic access, and the
pyvenv script for command-line access and
administration. The Python interpreter checks for a pyvenv.cfg,
file whose existence signals the base of a virtual environment’s directory
tree.

Native support for package directories that don’t require __init__.py
marker files and can automatically span multiple path segments (inspired by
various third party approaches to namespace packages, as described in
PEP 420)

The new memoryview implementation comprehensively fixes all ownership and
lifetime issues of dynamically allocated fields in the Py_buffer struct
that led to multiple crash reports. Additionally, several functions that
crashed or returned incorrect results for non-contiguous or multi-dimensional
input have been fixed.

The memoryview object now has a PEP-3118 compliant getbufferproc()
that checks the consumer’s request type. Many new features have been
added, most of them work in full generality for non-contiguous arrays
and arrays with suboffsets.

The documentation has been updated, clearly spelling out responsibilities
for both exporters and consumers. Buffer request flags are grouped into
basic and compound flags. The memory layout of non-contiguous and
multi-dimensional NumPy-style arrays is explained.

The representation of empty shape, strides and suboffsets is now
an empty tuple instead of None.

Accessing a memoryview element with format ‘B’ (unsigned bytes)
now returns an integer (in accordance with the struct module syntax).
For returning a bytes object the view must be cast to ‘c’ first.

memoryview comparisons now use the logical structure of the operands
and compare all array elements by value. All format strings in struct
module syntax are supported. Views with unrecognised format strings
are still permitted, but will always compare as unequal, regardless
of view contents.

The Unicode string type is changed to support multiple internal
representations, depending on the character with the largest Unicode ordinal
(1, 2, or 4 bytes) in the represented string. This allows a space-efficient
representation in common cases, but gives access to full UCS-4 on all
systems. For compatibility with existing APIs, several representations may
exist in parallel; over time, this compatibility should be phased out.

On the Python side, there should be no downside to this change.

On the C API side, PEP 393 is fully backward compatible. The legacy API
should remain available at least five years. Applications using the legacy
API will not fully benefit of the memory reduction, or - worse - may use
a bit more memory, because Python may have to maintain two versions of each
string (in the legacy format and in the new efficient storage).

Python now always supports the full range of Unicode code points, including
non-BMP ones (i.e. from U+0000 to U+10FFFF). The distinction between
narrow and wide builds no longer exists and Python now behaves like a wide
build, even under Windows.

With the death of narrow builds, the problems specific to narrow builds have
also been fixed, for example:

len() now always returns 1 for non-BMP characters,
so len('\U0010FFFF')==1;

surrogate pairs are not recombined in string literals,
so '\uDBFF\uDFFF'!='\U0010FFFF';

indexing or slicing non-BMP characters returns the expected value,
so '\U0010FFFF'[0] now returns '\U0010FFFF' and not '\uDBFF';

all other functions in the standard library now correctly handle
non-BMP code points.

The value of sys.maxunicode is now always 1114111 (0x10FFFF
in hexadecimal). The PyUnicode_GetMax() function still returns
either 0xFFFF or 0x10FFFF for backward compatibility, and it should
not be used with the new Unicode API (see bpo-13054).

The net effect is that for most applications, memory usage of string
storage should decrease significantly - especially compared to former
wide unicode builds - as, in many cases, strings will be pure ASCII
even in international contexts (because many strings store non-human
language data, such as XML fragments, HTTP headers, JSON-encoded data,
etc.). We also hope that it will, for the same reasons, increase CPU
cache efficiency on non-trivial applications. The memory usage of
Python 3.3 is two to three times smaller than Python 3.2, and a little
bit better than Python 2.7, on a Django benchmark (see the PEP for
details).

The Python 3.3 Windows installer now includes a py launcher application
that can be used to launch Python applications in a version independent
fashion.

This launcher is invoked implicitly when double-clicking *.py files.
If only a single Python version is installed on the system, that version
will be used to run the file. If multiple versions are installed, the most
recent version is used by default, but this can be overridden by including
a Unix-style “shebang line” in the Python script.

The launcher can also be used explicitly from the command line as the py
application. Running py follows the same version selection rules as
implicitly launching scripts, but a more specific version can be selected
by passing appropriate arguments (such as -3 to request Python 3 when
Python 2 is also installed, or -2.6 to specifclly request an earlier
Python version when a more recent version is installed).

In addition to the launcher, the Windows installer now includes an
option to add the newly installed Python to the system PATH. (Contributed
by Brian Curtin in bpo-3561.)

Also, it is now easier to catch a specific error condition. Instead of
inspecting the errno attribute (or args[0]) for a particular
constant from the errno module, you can catch the adequate
OSError subclass. The available subclasses are the following:

Thanks to the new exceptions, common usages of the errno can now be
avoided. For example, the following code written for Python 3.2:

fromerrnoimportENOENT,EACCES,EPERMtry:withopen("document.txt")asf:content=f.read()exceptIOErroraserr:iferr.errno==ENOENT:print("document.txt file is missing")eliferr.errnoin(EACCES,EPERM):print("You are not allowed to read document.txt")else:raise

can now be written without the errno import and without manual
inspection of exception attributes:

try:withopen("document.txt")asf:content=f.read()exceptFileNotFoundError:print("document.txt file is missing")exceptPermissionError:print("You are not allowed to read document.txt")

PEP 380 adds the yieldfrom expression, allowing a generator to
delegate
part of its operations to another generator. This allows a section of code
containing yield to be factored out and placed in another generator.
Additionally, the subgenerator is allowed to return with a value, and the
value is made available to the delegating generator.

While designed primarily for use in delegating to a subgenerator, the yieldfrom expression actually allows delegation to arbitrary subiterators.

For simple iterators, yieldfromiterable is essentially just a shortened
form of foriteminiterable:yielditem:

The main principle driving this change is to allow even generators that are
designed to be used with the send and throw methods to be split into
multiple subgenerators as easily as a single large function can be split into
multiple subfunctions.

To ease the transition from Python 2 for Unicode aware Python applications
that make heavy use of Unicode literals, Python 3.3 once again supports the
“u” prefix for string literals. This prefix has no semantic significance
in Python 3, it is provided solely to reduce the number of purely mechanical
changes in migrating to Python 3, making it easier for developers to focus on
the more significant semantic changes (such as the stricter default
separation of binary and text data).

Functions and class objects have a new __qualname__ attribute representing
the “path” from the module top-level to their definition. For global functions
and classes, this is the same as __name__. For other functions and classes,
it provides better information about where they were actually defined, and
how they might be accessible from the global scope.

Dictionaries used for the storage of objects’ attributes are now able to
share part of their internal storage between each other (namely, the part
which stores the keys and their respective hashes). This reduces the memory
consumption of programs creating many instances of non-builtin types.

A new attribute on the sys module exposes details specific to the
implementation of the currently running interpreter. The initial set of
attributes on sys.implementation are name, version,
hexversion, and cache_tag.

The intention of sys.implementation is to consolidate into one namespace
the implementation-specific data used by the standard library. This allows
different Python implementations to share a single standard library code base
much more easily. In its initial state, sys.implementation holds only a
small portion of the implementation-specific data. Over time that ratio will
shift in order to make the standard library more portable.

One example of improved standard library portability is cache_tag. As of
Python 3.3, sys.implementation.cache_tag is used by importlib to
support PEP 3147 compliance. Any Python implementation that uses
importlib for its built-in import system may use cache_tag to control
the caching behavior for modules.

The implementation of sys.implementation also introduces a new type to
Python: types.SimpleNamespace. In contrast to a mapping-based
namespace, like dict, SimpleNamespace is attribute-based, like
object. However, unlike object, SimpleNamespace instances
are writable. This means that you can add, remove, and modify the namespace
through normal attribute access.

The __import__() function is now powered by importlib.__import__().
This work leads to the completion of “phase 2” of PEP 302. There are
multiple benefits to this change. First, it has allowed for more of the
machinery powering import to be exposed instead of being implicit and hidden
within the C code. It also provides a single implementation for all Python VMs
supporting Python 3.3 to use, helping to end any VM-specific deviations in
import semantics. And finally it eases the maintenance of import, allowing for
future growth to occur.

For the common user, there should be no visible change in semantics. For
those whose code currently manipulates import or calls import
programmatically, the code changes that might possibly be required are covered
in the Porting Python code section of this document.

One of the large benefits of this work is the exposure of what goes into
making the import statement work. That means the various importers that were
once implicit are now fully exposed as part of the importlib package.

ImportError now has name and path attributes which are set when
there is relevant data to provide. The message for failed imports will also
provide the full name of the module now instead of just the tail end of the
module’s name.

Beyond the expanse of what importlib now exposes, there are other
visible changes to import. The biggest is that sys.meta_path and
sys.path_hooks now store all of the meta path finders and path entry
hooks used by import. Previously the finders were implicit and hidden within
the C code of import instead of being directly exposed. This means that one can
now easily remove or change the order of the various finders to fit one’s needs.

Another change is that all modules have a __loader__ attribute, storing the
loader used to create the module. PEP 302 has been updated to make this
attribute mandatory for loaders to implement, so in the future once 3rd-party
loaders have been updated people will be able to rely on the existence of the
attribute. Until such time, though, import is setting the module post-load.

Loaders are also now expected to set the __package__ attribute from
PEP 366. Once again, import itself is already setting this on all loaders
from importlib and import itself is setting the attribute post-load.

All other changes relate to semantic changes which should be taken into
consideration when updating code for Python 3.3, and thus should be read about
in the Porting Python code section of this document.

Previous versions of CPython have always relied on a global import lock.
This led to unexpected annoyances, such as deadlocks when importing a module
would trigger code execution in a different thread as a side-effect.
Clumsy workarounds were sometimes employed, such as the
PyImport_ImportModuleNoBlock() C API function.

In Python 3.3, importing a module takes a per-module lock. This correctly
serializes importation of a given module from multiple threads (preventing
the exposure of incompletely initialized modules), while eliminating the
aforementioned annoyances.

open() gets a new opener parameter: the underlying file descriptor
for the file object is then obtained by calling opener with (file,
flags). It can be used to use custom flags like os.O_CLOEXEC for
example. The 'x' mode was added: open for exclusive creation, failing if
the file already exists.

print(): added the flush keyword argument. If the flush keyword
argument is true, the stream is forcibly flushed.

The str type gets a new casefold() method: return a
casefolded copy of the string, casefolded strings may be used for caseless
matching. For example, 'ß'.casefold() returns 'ss'.

The sequence documentation has been substantially rewritten to better
explain the binary/text sequence distinction and to provide specific
documentation sections for the individual builtin sequence types
(bpo-4966).

This new debug module faulthandler contains functions to dump Python tracebacks explicitly,
on a fault (a crash like a segmentation fault), after a timeout, or on a user
signal. Call faulthandler.enable() to install fault handlers for the
SIGSEGV, SIGFPE, SIGABRT, SIGBUS, and
SIGILL signals. You can also enable them at startup by setting the
PYTHONFAULTHANDLER environment variable or by using -Xfaulthandler command line option.

Improved support for abstract base classes containing descriptors composed with
abstract methods. The recommended approach to declaring abstract descriptors is
now to provide __isabstractmethod__ as a dynamically updated
property. The built-in descriptors have been updated accordingly.

bz2.BZ2File and bz2.decompress() can now decompress
multi-stream inputs (such as those produced by the pbzip2 tool).
bz2.BZ2File can now also be used to create this type of file, using
the 'a' (append) mode.

The mbcs codec has been rewritten to handle correctly
replace and ignore error handlers on all Windows versions. The
mbcs codec now supports all error handlers, instead of only
replace to encode and ignore to decode.

A new Windows-only codec has been added: cp65001 (bpo-13216). It is the
Windows code page 65001 (Windows UTF-8, CP_UTF8). For example, it is used
by sys.stdout if the console output code page is set to cp65001 (e.g., using
chcp65001 command).

Multibyte CJK decoders now resynchronize faster. They only ignore the first
byte of an invalid byte sequence. For example, b'\xff\n'.decode('gb2312','replace') now returns a \n after the replacement character.

Addition of a new ChainMap class to allow treating a
number of mappings as a single unit. (Written by Raymond Hettinger for
bpo-11089, made public in bpo-11297.)

The abstract base classes have been moved in a new collections.abc
module, to better differentiate between the abstract and the concrete
collections classes. Aliases for ABCs are still present in the
collections module to preserve existing imports. (bpo-11085)

The Counter class now supports the unary + and -
operators, as well as the in-place operators +=, -=, |=, and
&=. (Contributed by Raymond Hettinger in bpo-13121.)

ExitStack now provides a solid foundation for
programmatic manipulation of context managers and similar cleanup
functionality. Unlike the previous contextlib.nested API (which was
deprecated and removed), the new API is designed to work correctly
regardless of whether context managers acquire their resources in
their __init__ method (for example, file objects) or in their
__enter__ method (for example, synchronisation objects from the
threading module).

The new C version of the decimal module integrates the high speed libmpdec
library for arbitrary precision correctly-rounded decimal floating point
arithmetic. libmpdec conforms to IBM’s General Decimal Arithmetic Specification.

Performance gains range from 10x for database applications to 100x for
numerically intensive applications. These numbers are expected gains
for standard precisions used in decimal floating point arithmetic. Since
the precision is user configurable, the exact figures may vary. For example,
in integer bignum arithmetic the differences can be significantly higher.

The Decimal constructor in decimal.py does not observe
the context limits and converts values with arbitrary exponents or precision
exactly. Since the C version has internal limits, the following scheme is
used: If possible, values are converted exactly, otherwise
InvalidOperation is raised and the result is NaN. In the
latter case it is always possible to use create_decimal()
in order to obtain a rounded or inexact value.

The power function in decimal.py is always correctly-rounded. In the
C version, it is defined in terms of the correctly-rounded
exp() and ln() functions,
but the final result is only “almost always correctly rounded”.

In the C version, the context dictionary containing the signals is a
MutableMapping. For speed reasons,
flags and traps always
refer to the same MutableMapping that the context
was initialized with. If a new signal dictionary is assigned,
flags and traps
are updated with the new values, but they do not reference the RHS
dictionary.

Pickling a Context produces a different output in order
to have a common interchange format for the Python and C versions.

The order of arguments in the Context constructor has been
changed to match the order displayed by repr().

The email package now has a policy framework. A
Policy is an object with several methods and properties
that control how the email package behaves. The primary policy for Python 3.3
is the Compat32 policy, which provides backward
compatibility with the email package in Python 3.2. A policy can be
specified when an email message is parsed by a parser, or when a
Message object is created, or when an email is
serialized using a generator. Unless overridden, a policy passed
to a parser is inherited by all the Message object and sub-objects
created by the parser. By default a generator will use the policy of
the Message object it is serializing. The default policy is
compat32.

The minimum set of controls implemented by all policy objects are:

max_line_length

The maximum length, excluding the linesep character(s),
individual lines may have when a Message is
serialized. Defaults to 78.

linesep

The character used to separate individual lines when a
Message is serialized. Defaults to \n.

cte_type

7bit or 8bit. 8bit applies only to a
Bytesgenerator, and means that non-ASCII may
be used where allowed by the protocol (or where it
exists in the original input).

raise_on_defect

Causes a parser to raise error when defects are
encountered instead of adding them to the Message
object’s defects list.

A new policy instance, with new settings, is created using the
clone() method of policy objects. clone takes
any of the above controls as keyword arguments. Any control not specified in
the call retains its default value. Thus you can create a policy that uses
\r\n linesep characters like this:

mypolicy=compat32.clone(linesep='\r\n')

Policies can be used to make the generation of messages in the format needed by
your application simpler. Instead of having to remember to specify
linesep='\r\n' in all the places you call a generator, you can specify
it once, when you set the policy used by the parser or the Message,
whichever your program uses to create Message objects. On the other hand,
if you need to generate messages in multiple forms, you can still specify the
parameters in the appropriate generator call. Or you can have custom
policy instances for your different cases, and pass those in when you create
the generator.

While the policy framework is worthwhile all by itself, the main motivation for
introducing it is to allow the creation of new policies that implement new
features for the email package in a way that maintains backward compatibility
for those who do not use the new policies. Because the new policies introduce a
new API, we are releasing them in Python 3.3 as a provisional policy. Backwards incompatible changes (up to and including
removal of the code) may occur if deemed necessary by the core developers.

The new policies are instances of EmailPolicy,
and add the following additional controls:

refold_source

Controls whether or not headers parsed by a
parser are refolded by the
generator. It can be none, long,
or all. The default is long, which means that
source headers with a line longer than
max_line_length get refolded. none means no
line get refolded, and all means that all lines
get refolded.

header_factory

A callable that take a name and value and
produces a custom header object.

The header_factory is the key to the new features provided by the new
policies. When one of the new policies is used, any header retrieved from
a Message object is an object produced by the header_factory, and any
time you set a header on a Message it becomes an object produced by
header_factory. All such header objects have a name attribute equal
to the header name. Address and Date headers have additional attributes
that give you access to the parsed data of the header. This means you can now
do things like this:

You will note that the unicode display name is automatically encoded as
utf-8 when the message is serialized, but that when the header is accessed
directly, you get the unicode version. This eliminates any need to deal with
the email.headerdecode_header() or
make_header() functions.

In summary, if you use one of the new policies, header manipulation works the
way it ought to: your application works with unicode strings, and the email
package transparently encodes and decodes the unicode to and from the RFC
standard Content Transfer Encodings.

ftplib.FTP now accepts a source_address keyword argument to
specify the (host,port) to use as the source address in the bind call
when creating the outgoing socket. (Contributed by Giampaolo Rodolà
in bpo-8594.)

The FTP_TLS class now provides a new
ccc() function to revert control channel back to
plaintext. This can be useful to take advantage of firewalls that know how
to handle NAT with non-secure FTP without opening fixed ports. (Contributed
by Giampaolo Rodolà in bpo-12139.)

The functools.lru_cache() decorator now accepts a typed keyword
argument (that defaults to False to ensure that it caches values of
different types that compare equal in separate cache slots. (Contributed
by Raymond Hettinger in bpo-13227.)

A new html5 dictionary that maps HTML5 named character
references to the equivalent Unicode character(s) (e.g. html5['gt;']=='>') has been added to the html.entities module. The dictionary is
now also used by HTMLParser. (Contributed by Ezio
Melotti in bpo-11113 and bpo-15156.)

A new getclosurevars() function has been added. This function
reports the current binding of all names referenced from the function body and
where those names were resolved, making it easier to verify correct internal
state when testing code that relies on stateful closures.

A new getgeneratorlocals() function has been added. This
function reports the current binding of local variables in the generator’s
stack frame, making it easier to verify correct internal state when testing
generators.

The constructor of the TextIOWrapper class has a new
write_through optional argument. If write_through is True, calls to
write() are guaranteed not to be buffered: any data
written on the TextIOWrapper object is immediately handled to its
underlying binary buffer.

The basicConfig() function now supports an optional handlers
argument taking an iterable of handlers to be added to the root logger.

A class level attribute append_nul has
been added to SysLogHandler to allow control of the
appending of the NUL (\000) byte to syslog records, since for some
deamons it is required while for others it is passed through to the log.

The read() method is now more compatible with other file-like
objects: if the argument is omitted or specified as None, it returns the
bytes from the current file position to the end of the mapping. (Contributed
by Petri Lehtinen in bpo-12021.)

The os module has a new pipe2() function that makes it
possible to create a pipe with O_CLOEXEC or
O_NONBLOCK flags set atomically. This is especially useful to
avoid race conditions in multi-threaded programs.

The os module has a new sendfile() function which provides
an efficient “zero-copy” way for copying data from one file (or socket)
descriptor to another. The phrase “zero-copy” refers to the fact that all of
the copying of data between the two descriptors is done entirely by the
kernel, with no copying of data into userspace buffers. sendfile()
can be used to efficiently copy data from a file on disk to a network socket,
e.g. for downloading a file.

(Patch submitted by Ross Lagerwall and Giampaolo Rodolà in bpo-10882.)

To avoid race conditions like symlink attacks and issues with temporary
files and directories, it is more reliable (and also faster) to manipulate
file descriptors instead of file names. Python 3.3 enhances existing functions
and introduces new functions to work on file descriptors (bpo-4761,
bpo-10755 and bpo-14626).

The os module has a new fwalk() function similar to
walk() except that it also yields file descriptors referring to the
directories visited. This is especially useful to avoid symlink races.

access() accepts an effective_ids keyword argument to turn on
using the effective uid/gid rather than the real uid/gid in the access check.
Platform support for this can be checked via the
supports_effective_ids set.

The os module has two new functions: getpriority() and
setpriority(). They can be used to get or set process
niceness/priority in a fashion similar to os.nice() but extended to all
processes instead of just the current one.

The new os.replace() function allows cross-platform renaming of a
file with overwriting the destination. With os.rename(), an existing
destination file is overwritten under POSIX, but raises an error under
Windows.
(Contributed by Antoine Pitrou in bpo-8828.)

The stat family of functions (stat(), fstat(),
and lstat()) now support reading a file’s timestamps
with nanosecond precision. Symmetrically, utime()
can now write file timestamps with nanosecond precision. (Contributed by
Larry Hastings in bpo-14127.)

run() now accepts a blocking parameter which when
set to false makes the method execute the scheduled events due to expire
soonest (if any) and then return immediately.
This is useful in case you want to use the scheduler in
non-blocking applications. (Contributed by Giampaolo Rodolà in bpo-13449.)

scheduler class can now be safely used in multi-threaded
environments. (Contributed by Josiah Carlson and Giampaolo Rodolà in
bpo-8684.)

The previously undocumented helper function quote from the
pipes modules has been moved to the shlex module and
documented. quote() properly escapes all characters in a string
that might be otherwise given special meaning by the shell.

copy2() and copystat() now preserve file
timestamps with nanosecond precision on platforms that support it.
They also preserve file “extended attributes” on Linux. (Contributed
by Larry Hastings in bpo-14127 and bpo-15238.)

Several functions now take an optional symlinks argument: when that
parameter is true, symlinks aren’t dereferenced and the operation instead
acts on the symlink itself (or creates one, if relevant).
(Contributed by Hynek Schlawack in bpo-12715.)

When copying files to a different file system, move() now
handles symlinks the way the posix mv command does, recreating the
symlink rather than copying the target file contents. (Contributed by
Jonathan Niehof in bpo-9993.) move() now also returns
the dst argument as its result.

rmtree() is now resistant to symlink attacks on platforms
which support the new dir_fd parameter in os.open() and
os.unlink(). (Contributed by Martin von Löwis and Hynek Schlawack
in bpo-4489.)

The smtpd module now supports RFC 5321 (extended SMTP) and RFC 1870
(size extension). Per the standard, these extensions are enabled if and only
if the client initiates the session with an EHLO command.

(Initial ELHO support by Alberto Trevino. Size extension by Juhana
Jauhiainen. Substantial additional work on the patch contributed by Michele
Orrù and Dan Boswell. bpo-8739)

The SMTP, SMTP_SSL, and
LMTP classes now accept a source_address keyword argument
to specify the (host,port) to use as the source address in the bind call
when creating the outgoing socket. (Contributed by Paulo Scardine in
bpo-11281.)

SMTP now supports the context management protocol, allowing an
SMTP instance to be used in a with statement. (Contributed
by Giampaolo Rodolà in bpo-11289.)

The SMTP_SSL constructor and the starttls()
method now accept an SSLContext parameter to control parameters of the secure
channel. (Contributed by Kasun Herath in bpo-8809.)

SSL sockets have a new get_channel_binding() method
allowing the implementation of certain authentication mechanisms such as
SCRAM-SHA-1-PLUS. (Contributed by Jacek Konieczny in bpo-12551.)

You can query the SSL compression algorithm used by an SSL socket, thanks
to its new compression() method. The new attribute
OP_NO_COMPRESSION can be used to disable compression.
(Contributed by Antoine Pitrou in bpo-13634.)

The threading.Thread constructor now accepts a daemon keyword
argument to override the default behavior of inheriting the deamon flag
value from the parent thread (bpo-6064).

The formerly private function _thread.get_ident is now available as the
public function threading.get_ident(). This eliminates several cases of
direct access to the _thread module in the stdlib. Third party code that
used _thread.get_ident should likewise be changed to use the new public
interface.

The webbrowser module supports more “browsers”: Google Chrome (named
chrome, chromium, chrome-browser or
chromium-browser depending on the version and operating system),
and the generic launchers xdg-open, from the FreeDesktop.org
project, and gvfs-open, which is the default URI handler for GNOME
3. (The former contributed by Arnaud Calmettes in bpo-13620, the latter
by Matthias Klose in bpo-14493.)

The xml.etree.ElementTree module now imports its C accelerator by
default; there is no longer a need to explicitly import
xml.etree.cElementTree (this module stays for backwards compatibility,
but is now deprecated). In addition, the iter family of methods of
Element has been optimized (rewritten in C).
The module’s documentation has also been greatly improved with added examples
and a more detailed reference.

Hash randomization is enabled by default. Set the PYTHONHASHSEED
environment variable to 0 to disable hash randomization. See also the
object.__hash__() method.

bpo-12326: On Linux, sys.platform doesn’t contain the major version
anymore. It is now always ‘linux’, instead of ‘linux2’ or ‘linux3’ depending
on the Linux version used to build Python. Replace sys.platform == ‘linux2’
with sys.platform.startswith(‘linux’), or directly sys.platform == ‘linux’ if
you don’t need to support older Python versions.

The default finders used by import now utilize a cache of what is contained
within a specific directory. If you create a Python source file or sourceless
bytecode file, make sure to call importlib.invalidate_caches() to clear
out the cache for the finders to notice the new file.

ImportError now uses the full name of the module that was attempted to
be imported. Doctests that check ImportErrors’ message will need to be
updated to use the full name of the module instead of just the tail of the
name.

The index argument to __import__() now defaults to 0 instead of -1
and no longer support negative values. It was an oversight when PEP 328 was
implemented that the default value remained -1. If you need to continue to
perform a relative import followed by an absolute import, then perform the
relative import using an index of 1, followed by another import using an
index of 0. It is preferred, though, that you use
importlib.import_module() rather than call __import__() directly.

__import__() no longer allows one to use an index value other than 0
for top-level modules. E.g. __import__('sys',level=1) is now an error.

Because sys.meta_path and sys.path_hooks now have finders on
them by default, you will most likely want to use list.insert() instead
of list.append() to add to those lists.

Because None is now inserted into sys.path_importer_cache, if you
are clearing out entries in the dictionary of paths that do not have a
finder, you will need to remove keys paired with values of Noneandimp.NullImporter to be backwards-compatible. This will lead to extra
overhead on older versions of Python that re-insert None into
sys.path_importer_cache where it repesents the use of implicit
finders, but semantically it should not change anything.

importlib.abc.Finder no longer specifies a find_module() abstract
method that must be implemented. If you were relying on subclasses to
implement that method, make sure to check for the method’s existence first.
You will probably want to check for find_loader() first, though, in the
case of working with path entry finders.

pkgutil has been converted to use importlib internally. This
eliminates many edge cases where the old behaviour of the PEP 302 import
emulation failed to match the behaviour of the real import system. The
import emulation itself is still present, but is now deprecated. The
pkgutil.iter_importers() and pkgutil.walk_packages() functions
special case the standard import hooks so they are still supported even
though they do not provide the non-standard iter_modules() method.

A longstanding RFC-compliance bug (bpo-1079) in the parsing done by
email.header.decode_header() has been fixed. Code that uses the
standard idiom to convert encoded headers into unicode
(str(make_header(decode_header(h))) will see no change, but code that
looks at the individual tuples returned by decode_header will see that
whitespace that precedes or follows ASCII sections is now included in the
ASCII section. Code that builds headers using make_header should
also continue to work without change, since make_header continues to add
whitespace between ASCII and non-ASCII sections if it is not already
present in the input strings.

email.utils.formataddr() now does the correct content transfer
encoding when passed non-ASCII display names. Any code that depended on
the previous buggy behavior that preserved the non-ASCII unicode in the
formatted output string will need to be changed (bpo-1690608).

poplib.POP3.quit() may now raise protocol errors like all other
poplib methods. Code that assumes quit does not raise
poplib.error_proto errors may need to be changed if errors on quit
are encountered by a particular application (bpo-11291).

The strict argument to email.parser.Parser, deprecated since
Python 2.4, has finally been removed.

The deprecated method unittest.TestCase.assertSameElements has been
removed.

The deprecated variable time.accept2dyear has been removed.

The deprecated Context._clamp attribute has been removed from the
decimal module. It was previously replaced by the public attribute
clamp. (See bpo-8540.)

The undocumented internal helper class SSLFakeFile has been removed
from smtplib, since its functionality has long been provided directly
by socket.socket.makefile().

Passing a negative value to time.sleep() on Windows now raises an
error instead of sleeping forever. It has always raised an error on posix.

The ast.__version__ constant has been removed. If you need to
make decisions affected by the AST version, use sys.version_info
to make the decision.

Code that used to work around the fact that the threading module used
factory functions by subclassing the private classes will need to change to
subclass the now-public classes.

The undocumented debugging machinery in the threading module has been
removed, simplifying the code. This should have no effect on production
code, but is mentioned here in case any application debug frameworks were
interacting with it (bpo-13550).

In the course of changes to the buffer API the undocumented
smalltable member of the
Py_buffer structure has been removed and the
layout of the PyMemoryViewObject has changed.

All extensions relying on the relevant parts in memoryobject.h
or object.h must be rebuilt.

Due to PEP 393, the Py_UNICODE type and all
functions using this type are deprecated (but will stay available for
at least five years). If you were using low-level Unicode APIs to
construct and access unicode objects and you want to benefit of the
memory footprint reduction provided by PEP 393, you have to convert
your code to the new Unicode API.

The range of possible file names for C extensions has been narrowed.
Very rarely used spellings have been suppressed: under POSIX, files
named xxxmodule.so, xxxmodule.abi3.so and
xxxmodule.cpython-*.so are no longer recognized as implementing
the xxx module. If you had been generating such files, you have
to switch to the other spellings (i.e., remove the module string
from the file names).