python_doc_md/Beginner/whatsnew/3.3.md

# What\'s New In Python 3.3

> \* Anyone can add text to this document. Do not spend very much time on the wording of your changes, because your text will probably get rewritten to some degree.
>
> \* The maintainer will go through Misc/NEWS periodically and add changes; it\'s therefore more important to add your changes to Misc/NEWS than to this file.
>
> \* This is not a complete list of every single change; completeness is the purpose of Misc/NEWS. Some changes I consider too small or esoteric to include. If such a change is added to the text, I\'ll just remove it. (This is another reason you shouldn\'t spend too much time on writing your addition.)
>
> \* If you want to draw your new text to the attention of the maintainer, add \'XXX\' to the beginning of the paragraph or section.
>
> \* It\'s OK to just add a fragmentary note about a change. For example: \"XXX Describe the transmogrify() function added to the socket module.\" The maintainer will research the change and write the necessary text.
>
> \* You can comment out your additions if you like, but it\'s not necessary (especially when a final release is some months away).
>
> \* Credit the author of a patch or bugfix. Just the name is sufficient; the e-mail address isn\'t necessary.
>
> - It\'s helpful to add the bug/patch number as a comment:
>
> XXX Describe the transmogrify() function added to the socket module. (Contributed by P.Y. Developer in `12345`{.interpreted-text role="issue"}.)
>
> This saves the maintainer the effort of going through the Mercurial log when researching a change.

This article explains the new features in Python 3.3, compared to 3.2. Python 3.3 was released on September 29, 2012. For full details, see the [changelog](https://docs.python.org/3.3/whatsnew/changelog.html).

::: seealso
`398`{.interpreted-text role="pep"} - Python 3.3 Release Schedule
:::

## Summary \-- Release highlights

New syntax features:

- New `yield from` expression for `generator delegation <pep-380>`{.interpreted-text role="ref"}.
- The `u'unicode'` syntax is accepted again for `str`{.interpreted-text role="class"} objects.

New library modules:

- `faulthandler`{.interpreted-text role="mod"} (helps debugging low-level crashes)
- `ipaddress`{.interpreted-text role="mod"} (high-level objects representing IP addresses and masks)
- `lzma`{.interpreted-text role="mod"} (compress data using the XZ / LZMA algorithm)
- `unittest.mock`{.interpreted-text role="mod"} (replace parts of your system under test with mock objects)
- `venv`{.interpreted-text role="mod"} (Python `virtual environments <pep-405>`{.interpreted-text role="ref"}, as in the popular `virtualenv` package)

New built-in features:

- Reworked `I/O exception hierarchy <pep-3151>`{.interpreted-text role="ref"}.

Implementation improvements:

- Rewritten `import machinery <importlib>`{.interpreted-text role="ref"} based on `importlib`{.interpreted-text role="mod"}.
- More compact `unicode strings <pep-393>`{.interpreted-text role="ref"}.
- More compact `attribute dictionaries <pep-412>`{.interpreted-text role="ref"}.

Significantly Improved Library Modules:

- C Accelerator for the `decimal <new-decimal>`{.interpreted-text role="ref"} module.
- Better unicode handling in the `email <new-email>`{.interpreted-text role="ref"} module (`provisional <provisional package>`{.interpreted-text role="term"}).

Security improvements:

- Hash randomization is switched on by default.

Please read on for a comprehensive list of user-facing changes.

## PEP 405: Virtual Environments {#pep-405}

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`{.interpreted-text role="mod"} 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.

::: seealso

`405`{.interpreted-text role="pep"} - Python Virtual Environments

:   PEP written by Carl Meyer; implementation by Carl Meyer and Vinay Sajip
:::

## PEP 420: Implicit Namespace Packages

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 `420`{.interpreted-text role="pep"})

::: seealso

`420`{.interpreted-text role="pep"} - Implicit Namespace Packages

:   PEP written by Eric V. Smith; implementation by Eric V. Smith and Barry Warsaw
:::

## PEP 3118: New memoryview implementation and buffer protocol documentation {#pep-3118-update}

The implementation of `3118`{.interpreted-text role="pep"} has been significantly improved.

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.

### Features

- All native single character format specifiers in struct module syntax (optionally prefixed with \'@\') are now supported.
- With some restrictions, the cast() method allows changing of format and shape of C-contiguous arrays.
- Multi-dimensional list representations are supported for any array type.
- Multi-dimensional comparisons are supported for any array type.
- One-dimensional memoryviews of hashable (read-only) types with formats B, b or c are now hashable. (Contributed by Antoine Pitrou in `13411`{.interpreted-text role="issue"}.)
- Arbitrary slicing of any 1-D arrays type is supported. For example, it is now possible to reverse a memoryview in *O*(1) by using a negative step.

### API changes

- The maximum number of dimensions is officially limited to 64.
- 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.
- For further changes see [Build and C API Changes](#build-and-c-api-changes) and [Porting C code](#porting-c-code).

(Contributed by Stefan Krah in `10181`{.interpreted-text role="issue"}.)

::: seealso
`3118`{.interpreted-text role="pep"} - Revising the Buffer Protocol
:::

## PEP 393: Flexible String Representation {#pep-393}

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, `393`{.interpreted-text role="pep"} 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).

### Functionality

Changes introduced by `393`{.interpreted-text role="pep"} are the following:

- 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`{.interpreted-text role="func"} 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`{.interpreted-text role="data"} is now always `1114111` (`0x10FFFF` in hexadecimal). The `!PyUnicode_GetMax`{.interpreted-text role="c:func"} function still returns either `0xFFFF` or `0x10FFFF` for backward compatibility, and it should not be used with the new Unicode API (see `13054`{.interpreted-text role="issue"}).
- The `./configure`{.interpreted-text role="file"} flag `--with-wide-unicode` has been removed.

### Performance and resource usage

The storage of Unicode strings now depends on the highest code point in the string:

- pure ASCII and Latin1 strings (`U+0000-U+00FF`) use 1 byte per code point;
- BMP strings (`U+0000-U+FFFF`) use 2 bytes per code point;
- non-BMP strings (`U+10000-U+10FFFF`) use 4 bytes per code point.

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

::: seealso

`393`{.interpreted-text role="pep"} - Flexible String Representation

:   PEP written by Martin von Löwis; implementation by Torsten Becker and Martin von Löwis.
:::

## PEP 397: Python Launcher for Windows {#pep-397}

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 specifically 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 `3561`{.interpreted-text role="issue"}.)

::: seealso

`397`{.interpreted-text role="pep"} - Python Launcher for Windows

:   PEP written by Mark Hammond and Martin v. Löwis; implementation by Vinay Sajip.

Launcher documentation: `launcher`{.interpreted-text role="ref"}

Installer PATH modification: `windows-path-mod`{.interpreted-text role="ref"}
:::

## PEP 3151: Reworking the OS and IO exception hierarchy {#pep-3151}

The hierarchy of exceptions raised by operating system errors is now both simplified and finer-grained.

You don\'t have to worry anymore about choosing the appropriate exception type between `OSError`{.interpreted-text role="exc"}, `IOError`{.interpreted-text role="exc"}, `EnvironmentError`{.interpreted-text role="exc"}, `WindowsError`{.interpreted-text role="exc"}, `!mmap.error`{.interpreted-text role="exc"}, `socket.error`{.interpreted-text role="exc"} or `select.error`{.interpreted-text role="exc"}. All these exception types are now only one: `OSError`{.interpreted-text role="exc"}. The other names are kept as aliases for compatibility reasons.

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`{.interpreted-text role="mod"} module, you can catch the adequate `OSError`{.interpreted-text role="exc"} subclass. The available subclasses are the following:

- `BlockingIOError`{.interpreted-text role="exc"}
- `ChildProcessError`{.interpreted-text role="exc"}
- `ConnectionError`{.interpreted-text role="exc"}
- `FileExistsError`{.interpreted-text role="exc"}
- `FileNotFoundError`{.interpreted-text role="exc"}
- `InterruptedError`{.interpreted-text role="exc"}
- `IsADirectoryError`{.interpreted-text role="exc"}
- `NotADirectoryError`{.interpreted-text role="exc"}
- `PermissionError`{.interpreted-text role="exc"}
- `ProcessLookupError`{.interpreted-text role="exc"}
- `TimeoutError`{.interpreted-text role="exc"}

And the `ConnectionError`{.interpreted-text role="exc"} itself has finer-grained subclasses:

- `BrokenPipeError`{.interpreted-text role="exc"}
- `ConnectionAbortedError`{.interpreted-text role="exc"}
- `ConnectionRefusedError`{.interpreted-text role="exc"}
- `ConnectionResetError`{.interpreted-text role="exc"}

Thanks to the new exceptions, common usages of the `errno`{.interpreted-text role="mod"} can now be avoided. For example, the following code written for Python 3.2:

    from errno import ENOENT, EACCES, EPERM

    try:
        with open("document.txt") as f:
            content = f.read()
    except IOError as err:
        if err.errno == ENOENT:
            print("document.txt file is missing")
        elif err.errno in (EACCES, EPERM):
            print("You are not allowed to read document.txt")
        else:
            raise

can now be written without the `errno`{.interpreted-text role="mod"} import and without manual inspection of exception attributes:

    try:
        with open("document.txt") as f:
            content = f.read()
    except FileNotFoundError:
        print("document.txt file is missing")
    except PermissionError:
        print("You are not allowed to read document.txt")

::: seealso

`3151`{.interpreted-text role="pep"} - Reworking the OS and IO Exception Hierarchy

:   PEP written and implemented by Antoine Pitrou
:::

::: index
single: yield; yield from (in What\'s New)
:::

## PEP 380: Syntax for Delegating to a Subgenerator {#pep-380}

PEP 380 adds the `yield from` expression, allowing a `generator`{.interpreted-text role="term"} to delegate part of its operations to another generator. This allows a section of code containing `yield`{.interpreted-text role="keyword"} 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 `yield from` expression actually allows delegation to arbitrary subiterators.

For simple iterators, `yield from iterable` is essentially just a shortened form of `for item in iterable: yield item`:

    >>> def g(x):
    ...     yield from range(x, 0, -1)
    ...     yield from range(x)
    ...
    >>> list(g(5))
    [5, 4, 3, 2, 1, 0, 1, 2, 3, 4]

However, unlike an ordinary loop, `yield from` allows subgenerators to receive sent and thrown values directly from the calling scope, and return a final value to the outer generator:

    >>> def accumulate():
    ...     tally = 0
    ...     while 1:
    ...         next = yield
    ...         if next is None:
    ...             return tally
    ...         tally += next
    ...
    >>> def gather_tallies(tallies):
    ...     while 1:
    ...         tally = yield from accumulate()
    ...         tallies.append(tally)
    ...
    >>> tallies = []
    >>> acc = gather_tallies(tallies)
    >>> next(acc)  # Ensure the accumulator is ready to accept values
    >>> for i in range(4):
    ...     acc.send(i)
    ...
    >>> acc.send(None)  # Finish the first tally
    >>> for i in range(5):
    ...     acc.send(i)
    ...
    >>> acc.send(None)  # Finish the second tally
    >>> tallies
    [6, 10]

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.

::: seealso

`380`{.interpreted-text role="pep"} - Syntax for Delegating to a Subgenerator

:   PEP written by Greg Ewing; implementation by Greg Ewing, integrated into 3.3 by Renaud Blanch, Ryan Kelly and Nick Coghlan; documentation by Zbigniew Jędrzejewski-Szmek and Nick Coghlan
:::

## PEP 409: Suppressing exception context

PEP 409 introduces new syntax that allows the display of the chained exception context to be disabled. This allows cleaner error messages in applications that convert between exception types:

    >>> class D:
    ...     def __init__(self, extra):
    ...         self._extra_attributes = extra
    ...     def __getattr__(self, attr):
    ...         try:
    ...             return self._extra_attributes[attr]
    ...         except KeyError:
    ...             raise AttributeError(attr) from None
    ...
    >>> D({}).x
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 8, in __getattr__
    AttributeError: x

Without the `from None` suffix to suppress the cause, the original exception would be displayed by default:

    >>> class C:
    ...     def __init__(self, extra):
    ...         self._extra_attributes = extra
    ...     def __getattr__(self, attr):
    ...         try:
    ...             return self._extra_attributes[attr]
    ...         except KeyError:
    ...             raise AttributeError(attr)
    ...
    >>> C({}).x
    Traceback (most recent call last):
      File "<stdin>", line 6, in __getattr__
    KeyError: 'x'

    During handling of the above exception, another exception occurred:

    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 8, in __getattr__
    AttributeError: x

No debugging capability is lost, as the original exception context remains available if needed (for example, if an intervening library has incorrectly suppressed valuable underlying details):

    >>> try:
    ...     D({}).x
    ... except AttributeError as exc:
    ...     print(repr(exc.__context__))
    ...
    KeyError('x',)

::: seealso

`409`{.interpreted-text role="pep"} - Suppressing exception context

:   PEP written by Ethan Furman; implemented by Ethan Furman and Nick Coghlan.
:::

## PEP 414: Explicit Unicode literals

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

::: seealso

`414`{.interpreted-text role="pep"} - Explicit Unicode literals

:   PEP written by Armin Ronacher.
:::

## PEP 3155: Qualified name for classes and functions

Functions and class objects have a new `~definition.__qualname__`{.interpreted-text role="attr"} attribute representing the \"path\" from the module top-level to their definition. For global functions and classes, this is the same as `~definition.__name__`{.interpreted-text role="attr"}. 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.

Example with (non-bound) methods:

    >>> class C:
    ...     def meth(self):
    ...         pass
    ...
    >>> C.meth.__name__
    'meth'
    >>> C.meth.__qualname__
    'C.meth'

Example with nested classes:

    >>> class C:
    ...     class D:
    ...         def meth(self):
    ...             pass
    ...
    >>> C.D.__name__
    'D'
    >>> C.D.__qualname__
    'C.D'
    >>> C.D.meth.__name__
    'meth'
    >>> C.D.meth.__qualname__
    'C.D.meth'

Example with nested functions:

    >>> def outer():
    ...     def inner():
    ...         pass
    ...     return inner
    ...
    >>> outer().__name__
    'inner'
    >>> outer().__qualname__
    'outer.<locals>.inner'

The string representation of those objects is also changed to include the new, more precise information:

    >>> str(C.D)
    "<class '__main__.C.D'>"
    >>> str(C.D.meth)
    '<function C.D.meth at 0x7f46b9fe31e0>'

::: seealso

`3155`{.interpreted-text role="pep"} - Qualified name for classes and functions

:   PEP written and implemented by Antoine Pitrou.
:::

## PEP 412: Key-Sharing Dictionary {#pep-412}

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.

::: seealso

`412`{.interpreted-text role="pep"} - Key-Sharing Dictionary

:   PEP written and implemented by Mark Shannon.
:::

## PEP 362: Function Signature Object

A new function `inspect.signature`{.interpreted-text role="func"} makes introspection of python callables easy and straightforward. A broad range of callables is supported: python functions, decorated or not, classes, and `functools.partial`{.interpreted-text role="func"} objects. New classes `inspect.Signature`{.interpreted-text role="class"}, `inspect.Parameter`{.interpreted-text role="class"} and `inspect.BoundArguments`{.interpreted-text role="class"} hold information about the call signatures, such as, annotations, default values, parameters kinds, and bound arguments, which considerably simplifies writing decorators and any code that validates or amends calling signatures or arguments.

::: seealso

`362`{.interpreted-text role="pep"}: - Function Signature Object

:   PEP written by Brett Cannon, Yury Selivanov, Larry Hastings, Jiwon Seo; implemented by Yury Selivanov.
:::

## PEP 421: Adding sys.implementation

A new attribute on the `sys`{.interpreted-text role="mod"} module exposes details specific to the implementation of the currently running interpreter. The initial set of attributes on `sys.implementation`{.interpreted-text role="data"} 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`{.interpreted-text role="mod"} to support `3147`{.interpreted-text role="pep"} compliance. Any Python implementation that uses `importlib` for its built-in import system may use `cache_tag` to control the caching behavior for modules.

### SimpleNamespace

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

::: seealso

`421`{.interpreted-text role="pep"} - Adding sys.implementation

:   PEP written and implemented by Eric Snow.
:::

## Using importlib as the Implementation of Import {#importlib}

`2377`{.interpreted-text role="issue"} - Replace \_\_import\_\_ w/ importlib.\_\_import\_\_ `13959`{.interpreted-text role="issue"} - Re-implement parts of `!imp`{.interpreted-text role="mod"} in pure Python `14605`{.interpreted-text role="issue"} - Make import machinery explicit `14646`{.interpreted-text role="issue"} - Require loaders set \_\_loader\_\_ and \_\_package\_\_

The `__import__`{.interpreted-text role="func"} function is now powered by `importlib.__import__`{.interpreted-text role="func"}. This work leads to the completion of \"phase 2\" of `302`{.interpreted-text role="pep"}. 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](#porting-python-code) section of this document.

### New APIs

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`{.interpreted-text role="mod"} package.

The abstract base classes defined in `importlib.abc`{.interpreted-text role="mod"} have been expanded to properly delineate between `meta path finders <meta path finder>`{.interpreted-text role="term"} and `path entry finders <path entry finder>`{.interpreted-text role="term"} by introducing `importlib.abc.MetaPathFinder`{.interpreted-text role="class"} and `importlib.abc.PathEntryFinder`{.interpreted-text role="class"}, respectively. The old ABC of `!importlib.abc.Finder`{.interpreted-text role="class"} is now only provided for backwards-compatibility and does not enforce any method requirements.

In terms of finders, `importlib.machinery.FileFinder`{.interpreted-text role="class"} exposes the mechanism used to search for source and bytecode files of a module. Previously this class was an implicit member of `sys.path_hooks`{.interpreted-text role="data"}.

For loaders, the new abstract base class `importlib.abc.FileLoader`{.interpreted-text role="class"} helps write a loader that uses the file system as the storage mechanism for a module\'s code. The loader for source files (`importlib.machinery.SourceFileLoader`{.interpreted-text role="class"}), sourceless bytecode files (`importlib.machinery.SourcelessFileLoader`{.interpreted-text role="class"}), and extension modules (`importlib.machinery.ExtensionFileLoader`{.interpreted-text role="class"}) are now available for direct use.

`ImportError`{.interpreted-text role="exc"} 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.

The `importlib.invalidate_caches`{.interpreted-text role="func"} function will now call the method with the same name on all finders cached in `sys.path_importer_cache`{.interpreted-text role="data"} to help clean up any stored state as necessary.

### Visible Changes

For potential required changes to code, see the [Porting Python code](#porting-python-code) section.

Beyond the expanse of what `importlib`{.interpreted-text role="mod"} now exposes, there are other visible changes to import. The biggest is that `sys.meta_path`{.interpreted-text role="data"} and `sys.path_hooks`{.interpreted-text role="data"} 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. `302`{.interpreted-text role="pep"} 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 `366`{.interpreted-text role="pep"}. Once again, import itself is already setting this on all loaders from `importlib`{.interpreted-text role="mod"} and import itself is setting the attribute post-load.

`None` is now inserted into `sys.path_importer_cache`{.interpreted-text role="data"} when no finder can be found on `sys.path_hooks`{.interpreted-text role="data"}. Since `!imp.NullImporter`{.interpreted-text role="class"} is not directly exposed on `sys.path_hooks`{.interpreted-text role="data"} it could no longer be relied upon to always be available to use as a value representing no finder found.

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](#porting-python-code) section of this document.

(Implementation by Brett Cannon)

## Other Language Changes

Some smaller changes made to the core Python language are:

- Added support for Unicode name aliases and named sequences. Both `unicodedata.lookup`{.interpreted-text role="func"} and `'\N{...}'` now resolve name aliases, and `unicodedata.lookup`{.interpreted-text role="func"} resolves named sequences too.

  (Contributed by Ezio Melotti in `12753`{.interpreted-text role="issue"}.)

- Unicode database updated to UCD version 6.1.0

- Equality comparisons on `range`{.interpreted-text role="func"} objects now return a result reflecting the equality of the underlying sequences generated by those range objects. (`13201`{.interpreted-text role="issue"})

- The `count()`, `find()`, `rfind()`, `index()` and `rindex()` methods of `bytes`{.interpreted-text role="class"} and `bytearray`{.interpreted-text role="class"} objects now accept an integer between 0 and 255 as their first argument.

  (Contributed by Petri Lehtinen in `12170`{.interpreted-text role="issue"}.)

- The `rjust()`, `ljust()`, and `center()` methods of `bytes`{.interpreted-text role="class"} and `bytearray`{.interpreted-text role="class"} now accept a `bytearray`{.interpreted-text role="class"} for the `fill` argument. (Contributed by Petri Lehtinen in `12380`{.interpreted-text role="issue"}.)

- New methods have been added to `list`{.interpreted-text role="class"} and `bytearray`{.interpreted-text role="class"}: `copy()` and `clear()` (`10516`{.interpreted-text role="issue"}). Consequently, `~collections.abc.MutableSequence`{.interpreted-text role="class"} now also defines a `!clear`{.interpreted-text role="meth"} method (`11388`{.interpreted-text role="issue"}).

- Raw bytes literals can now be written `rb"..."` as well as `br"..."`.

  (Contributed by Antoine Pitrou in `13748`{.interpreted-text role="issue"}.)

- `dict.setdefault`{.interpreted-text role="meth"} now does only one lookup for the given key, making it atomic when used with built-in types.

  (Contributed by Filip Gruszczyński in `13521`{.interpreted-text role="issue"}.)

- The error messages produced when a function call does not match the function signature have been significantly improved.

  (Contributed by Benjamin Peterson.)

## A Finer-Grained Import Lock

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`{.interpreted-text role="c:func"} 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.

(Contributed by Antoine Pitrou in `9260`{.interpreted-text role="issue"}.)

## Builtin functions and types

- `open`{.interpreted-text role="func"} 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`{.interpreted-text role="const"} for example. The `'x'` mode was added: open for exclusive creation, failing if the file already exists.
- `print`{.interpreted-text role="func"}: added the *flush* keyword argument. If the *flush* keyword argument is true, the stream is forcibly flushed.
- `hash`{.interpreted-text role="func"}: hash randomization is enabled by default, see `object.__hash__`{.interpreted-text role="meth"} and `PYTHONHASHSEED`{.interpreted-text role="envvar"}.
- The `str`{.interpreted-text role="class"} type gets a new `~str.casefold`{.interpreted-text role="meth"} 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 (`4966`{.interpreted-text role="issue"}).

## New Modules

### faulthandler

This new debug module `faulthandler`{.interpreted-text role="mod"} 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`{.interpreted-text role="func"} to install fault handlers for the `~signal.SIGSEGV`{.interpreted-text role="const"}, `~signal.SIGFPE`{.interpreted-text role="const"}, `~signal.SIGABRT`{.interpreted-text role="const"}, `~signal.SIGBUS`{.interpreted-text role="const"}, and `~signal.SIGILL`{.interpreted-text role="const"} signals. You can also enable them at startup by setting the `PYTHONFAULTHANDLER`{.interpreted-text role="envvar"} environment variable or by using `-X`{.interpreted-text role="option"} `faulthandler` command line option.

Example of a segmentation fault on Linux:

``` shell-session
$ python -q -X faulthandler
>>> import ctypes
>>> ctypes.string_at(0)
Fatal Python error: Segmentation fault

Current thread 0x00007fb899f39700:
  File "/home/python/cpython/Lib/ctypes/__init__.py", line 486 in string_at
  File "<stdin>", line 1 in <module>
Segmentation fault
```

### ipaddress

The new `ipaddress`{.interpreted-text role="mod"} module provides tools for creating and manipulating objects representing IPv4 and IPv6 addresses, networks and interfaces (i.e. an IP address associated with a specific IP subnet).

(Contributed by Google and Peter Moody in `3144`{.interpreted-text role="pep"}.)

### lzma

The newly added `lzma`{.interpreted-text role="mod"} module provides data compression and decompression using the LZMA algorithm, including support for the `.xz` and `.lzma` file formats.

(Contributed by Nadeem Vawda and Per Øyvind Karlsen in `6715`{.interpreted-text role="issue"}.)

## Improved Modules

### abc

Improved support for abstract base classes containing descriptors composed with abstract methods. The recommended approach to declaring abstract descriptors is now to provide `!__isabstractmethod__`{.interpreted-text role="attr"} as a dynamically updated property. The built-in descriptors have been updated accordingly.

- `abc.abstractproperty`{.interpreted-text role="class"} has been deprecated, use `property`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.
- `abc.abstractclassmethod`{.interpreted-text role="class"} has been deprecated, use `classmethod`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.
- `abc.abstractstaticmethod`{.interpreted-text role="class"} has been deprecated, use `staticmethod`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.

(Contributed by Darren Dale in `11610`{.interpreted-text role="issue"}.)

`abc.ABCMeta.register`{.interpreted-text role="meth"} now returns the registered subclass, which means it can now be used as a class decorator (`10868`{.interpreted-text role="issue"}).

### array

The `array`{.interpreted-text role="mod"} module supports the `long long`{.interpreted-text role="c:expr"} type using `q` and `Q` type codes.

(Contributed by Oren Tirosh and Hirokazu Yamamoto in `1172711`{.interpreted-text role="issue"}.)

### base64

ASCII-only Unicode strings are now accepted by the decoding functions of the `base64`{.interpreted-text role="mod"} modern interface. For example, `base64.b64decode('YWJj')` returns `b'abc'`. (Contributed by Catalin Iacob in `13641`{.interpreted-text role="issue"}.)

### binascii

In addition to the binary objects they normally accept, the `a2b_` functions now all also accept ASCII-only strings as input. (Contributed by Antoine Pitrou in `13637`{.interpreted-text role="issue"}.)

### bz2

The `bz2`{.interpreted-text role="mod"} module has been rewritten from scratch. In the process, several new features have been added:

- New `bz2.open`{.interpreted-text role="func"} function: open a bzip2-compressed file in binary or text mode.

- `bz2.BZ2File`{.interpreted-text role="class"} can now read from and write to arbitrary file-like objects, by means of its constructor\'s *fileobj* argument.

  (Contributed by Nadeem Vawda in `5863`{.interpreted-text role="issue"}.)

- `bz2.BZ2File`{.interpreted-text role="class"} and `bz2.decompress`{.interpreted-text role="func"} can now decompress multi-stream inputs (such as those produced by the `pbzip2`{.interpreted-text role="program"} tool). `bz2.BZ2File`{.interpreted-text role="class"} can now also be used to create this type of file, using the `'a'` (append) mode.

  (Contributed by Nir Aides in `1625`{.interpreted-text role="issue"}.)

- `bz2.BZ2File`{.interpreted-text role="class"} now implements all of the `io.BufferedIOBase`{.interpreted-text role="class"} API, except for the `!detach`{.interpreted-text role="meth"} and `!truncate`{.interpreted-text role="meth"} methods.

### codecs

The `~encodings.mbcs`{.interpreted-text role="mod"} codec has been rewritten to handle correctly `replace` and `ignore` error handlers on all Windows versions. The `~encodings.mbcs`{.interpreted-text role="mod"} 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` (`13216`{.interpreted-text role="issue"}). 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 `chcp 65001` 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.

(`12016`{.interpreted-text role="issue"})

Incremental CJK codec encoders are no longer reset at each call to their encode() methods. For example:

    >>> import codecs
    >>> encoder = codecs.getincrementalencoder('hz')('strict')
    >>> b''.join(encoder.encode(x) for x in '\u52ff\u65bd\u65bc\u4eba\u3002 Bye.')
    b'~{NpJ)l6HK!#~} Bye.'

This example gives `b'~{Np~}~{J)~}~{l6~}~{HK~}~{!#~} Bye.'` with older Python versions.

(`12100`{.interpreted-text role="issue"})

The `unicode_internal` codec has been deprecated.

### collections

Addition of a new `~collections.ChainMap`{.interpreted-text role="class"} class to allow treating a number of mappings as a single unit. (Written by Raymond Hettinger for `11089`{.interpreted-text role="issue"}, made public in `11297`{.interpreted-text role="issue"}.)

The abstract base classes have been moved in a new `collections.abc`{.interpreted-text role="mod"} module, to better differentiate between the abstract and the concrete collections classes. Aliases for ABCs are still present in the `collections`{.interpreted-text role="mod"} module to preserve existing imports. (`11085`{.interpreted-text role="issue"})

The `~collections.Counter`{.interpreted-text role="class"} class now supports the unary `+` and `-` operators, as well as the in-place operators `+=`, `-=`, `|=`, and `&=`. (Contributed by Raymond Hettinger in `13121`{.interpreted-text role="issue"}.)

### contextlib

`~contextlib.ExitStack`{.interpreted-text role="class"} 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`{.interpreted-text role="mod"} module).

(`13585`{.interpreted-text role="issue"})

### crypt

Addition of salt and modular crypt format (hashing method) and the `!mksalt`{.interpreted-text role="func"} function to the `!crypt`{.interpreted-text role="mod"} module.

(`10924`{.interpreted-text role="issue"})

### curses

- If the `curses`{.interpreted-text role="mod"} module is linked to the ncursesw library, use Unicode functions when Unicode strings or characters are passed (e.g. `!waddwstr`{.interpreted-text role="c:func"}), and bytes functions otherwise (e.g. `!waddstr`{.interpreted-text role="c:func"}).
- Use the locale encoding instead of `utf-8` to encode Unicode strings.
- `curses.window`{.interpreted-text role="class"} has a new `curses.window.encoding`{.interpreted-text role="attr"} attribute.
- The `curses.window`{.interpreted-text role="class"} class has a new `~curses.window.get_wch`{.interpreted-text role="meth"} method to get a wide character
- The `curses`{.interpreted-text role="mod"} module has a new `~curses.unget_wch`{.interpreted-text role="meth"} function to push a wide character so the next `~curses.window.get_wch`{.interpreted-text role="meth"} will return it

(Contributed by Iñigo Serna in `6755`{.interpreted-text role="issue"}.)

### datetime

- Equality comparisons between naive and aware `~datetime.datetime`{.interpreted-text role="class"} instances now return `False`{.interpreted-text role="const"} instead of raising `TypeError`{.interpreted-text role="exc"} (`15006`{.interpreted-text role="issue"}).
- New `datetime.datetime.timestamp`{.interpreted-text role="meth"} method: Return POSIX timestamp corresponding to the `~datetime.datetime`{.interpreted-text role="class"} instance.
- The `datetime.datetime.strftime`{.interpreted-text role="meth"} method supports formatting years older than 1000.
- The `datetime.datetime.astimezone`{.interpreted-text role="meth"} method can now be called without arguments to convert datetime instance to the system timezone.

### decimal {#new-decimal}

`7652`{.interpreted-text role="issue"} - integrate fast native decimal arithmetic.

:   C-module and libmpdec written by Stefan Krah.

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 following table is meant as an illustration. Benchmarks are available at <https://www.bytereef.org/mpdecimal/quickstart.html>.

> +---------+--------------+-----------------------+-------------+
> |         | > decimal.py | > [decimal]{#decimal} | > speedup   |
> +=========+==============+=======================+=============+
> | > pi    | > 42.02s     | > 0.345s              | > 120x      |
> +---------+--------------+-----------------------+-------------+
> | telco   | > 172.19s    | > 5.68s               | > 30x       |
> +---------+--------------+-----------------------+-------------+
> | psycopg | > 3.57s      | > 0.29s               | > 12x       |
> +---------+--------------+-----------------------+-------------+

#### Features

- The `~decimal.FloatOperation`{.interpreted-text role="exc"} signal optionally enables stricter semantics for mixing floats and Decimals.
- If Python is compiled without threads, the C version automatically disables the expensive thread local context machinery. In this case, the variable `~decimal.HAVE_THREADS`{.interpreted-text role="const"} is set to `False`.

#### API changes

- The C module has the following context limits, depending on the machine architecture:

  > +-----------------------------------------------------+---------------+------------------------+
  > |                                                     | > 32-bit      | > 64-bit               |
  > +=====================================================+===============+========================+
  > | `~decimal.MAX_PREC`{.interpreted-text role="const"} | `425000000`   | `999999999999999999`   |
  > +-----------------------------------------------------+---------------+------------------------+
  > | `~decimal.MAX_EMAX`{.interpreted-text role="const"} | `425000000`   | `999999999999999999`   |
  > +-----------------------------------------------------+---------------+------------------------+
  > | `~decimal.MIN_EMIN`{.interpreted-text role="const"} | `-425000000`  | `-999999999999999999`  |
  > +-----------------------------------------------------+---------------+------------------------+

- In the context templates (`~decimal.DefaultContext`{.interpreted-text role="const"}, `~decimal.BasicContext`{.interpreted-text role="const"} and `~decimal.ExtendedContext`{.interpreted-text role="const"}) the magnitude of `~decimal.Context.Emax`{.interpreted-text role="attr"} and `~decimal.Context.Emin`{.interpreted-text role="attr"} has changed to `999999`.

- The `~decimal.Decimal`{.interpreted-text role="class"} 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 `~decimal.InvalidOperation`{.interpreted-text role="exc"} is raised and the result is NaN. In the latter case it is always possible to use `~decimal.Context.create_decimal`{.interpreted-text role="meth"} 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 `~decimal.Decimal.exp`{.interpreted-text role="meth"} and `~decimal.Decimal.ln`{.interpreted-text role="meth"} functions, but the final result is only \"almost always correctly rounded\".

- In the C version, the context dictionary containing the signals is a `~collections.abc.MutableMapping`{.interpreted-text role="class"}. For speed reasons, `~decimal.Context.flags`{.interpreted-text role="attr"} and `~decimal.Context.traps`{.interpreted-text role="attr"} always refer to the same `~collections.abc.MutableMapping`{.interpreted-text role="class"} that the context was initialized with. If a new signal dictionary is assigned, `~decimal.Context.flags`{.interpreted-text role="attr"} and `~decimal.Context.traps`{.interpreted-text role="attr"} are updated with the new values, but they do not reference the RHS dictionary.

- Pickling a `~decimal.Context`{.interpreted-text role="class"} produces a different output in order to have a common interchange format for the Python and C versions.

- The order of arguments in the `~decimal.Context`{.interpreted-text role="class"} constructor has been changed to match the order displayed by `repr`{.interpreted-text role="func"}.

- The `watchexp` parameter in the `~decimal.Decimal.quantize`{.interpreted-text role="meth"} method is deprecated.

### email {#new-email}

#### Policy Framework

The email package now has a `~email.policy`{.interpreted-text role="mod"} framework. A `~email.policy.Policy`{.interpreted-text role="class"} is an object with several methods and properties that control how the email package behaves. The primary policy for Python 3.3 is the `~email.policy.Compat32`{.interpreted-text role="class"} 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 `~email.parser`{.interpreted-text role="mod"}, or when a `~email.message.Message`{.interpreted-text role="class"} object is created, or when an email is serialized using a `~email.generator`{.interpreted-text role="mod"}. 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 `~email.policy.compat32`{.interpreted-text role="data"}.

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

::: tabularcolumns
[\|l\|](##SUBST##|l|)L\|
:::

  ----------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  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 `Bytes` `generator`, 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 `~email.policy.Policy.clone`{.interpreted-text role="meth"} 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`.

#### Provisional Policy with New Header API

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
<provisional package>`{.interpreted-text role="term"}. 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 `~email.policy.EmailPolicy`{.interpreted-text role="class"}, and add the following additional controls:

::: tabularcolumns
[\|l\|](##SUBST##|l|)L\|
:::

  ---------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  refold_source    Controls whether or not headers parsed by a `~email.parser`{.interpreted-text role="mod"} are refolded by the `~email.generator`{.interpreted-text role="mod"}. 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:

    >>> m = Message(policy=SMTP)
    >>> m['To'] = 'Éric <foo@example.com>'
    >>> m['to']
    'Éric <foo@example.com>'
    >>> m['to'].addresses
    (Address(display_name='Éric', username='foo', domain='example.com'),)
    >>> m['to'].addresses[0].username
    'foo'
    >>> m['to'].addresses[0].display_name
    'Éric'
    >>> m['Date'] = email.utils.localtime()
    >>> m['Date'].datetime
    datetime.datetime(2012, 5, 25, 21, 39, 24, 465484, tzinfo=datetime.timezone(datetime.timedelta(-1, 72000), 'EDT'))
    >>> m['Date']
    'Fri, 25 May 2012 21:44:27 -0400'
    >>> print(m)
    To: =?utf-8?q?=C3=89ric?= <foo@example.com>
    Date: Fri, 25 May 2012 21:44:27 -0400

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.header`{.interpreted-text role="mod"} `~email.header.decode_header`{.interpreted-text role="meth"} or `~email.header.make_header`{.interpreted-text role="meth"} functions.

You can also create addresses from parts:

    >>> m['cc'] = [Group('pals', [Address('Bob', 'bob', 'example.com'),
    ...                           Address('Sally', 'sally', 'example.com')]),
    ...            Address('Bonzo', addr_spec='bonz@laugh.com')]
    >>> print(m)
    To: =?utf-8?q?=C3=89ric?= <foo@example.com>
    Date: Fri, 25 May 2012 21:44:27 -0400
    cc: pals: Bob <bob@example.com>, Sally <sally@example.com>;, Bonzo <bonz@laugh.com>

Decoding to unicode is done automatically:

    >>> m2 = message_from_string(str(m))
    >>> m2['to']
    'Éric <foo@example.com>'

When you parse a message, you can use the `addresses` and `groups` attributes of the header objects to access the groups and individual addresses:

    >>> m2['cc'].addresses
    (Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com'), Address(display_name='Bonzo', username='bonz', domain='laugh.com'))
    >>> m2['cc'].groups
    (Group(display_name='pals', addresses=(Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com')), Group(display_name=None, addresses=(Address(display_name='Bonzo', username='bonz', domain='laugh.com'),))

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.

#### Other API Changes

New `~email.parser.BytesHeaderParser`{.interpreted-text role="class"}, added to the `~email.parser`{.interpreted-text role="mod"} module to complement `~email.parser.HeaderParser`{.interpreted-text role="class"} and complete the Bytes API.

New utility functions:

- `~email.utils.format_datetime`{.interpreted-text role="func"}: given a `~datetime.datetime`{.interpreted-text role="class"}, produce a string formatted for use in an email header.
- `~email.utils.parsedate_to_datetime`{.interpreted-text role="func"}: given a date string from an email header, convert it into an aware `~datetime.datetime`{.interpreted-text role="class"}, or a naive `~datetime.datetime`{.interpreted-text role="class"} if the offset is `-0000`.
- `~email.utils.localtime`{.interpreted-text role="func"}: With no argument, returns the current local time as an aware `~datetime.datetime`{.interpreted-text role="class"} using the local `~datetime.timezone`{.interpreted-text role="class"}. Given an aware `~datetime.datetime`{.interpreted-text role="class"}, converts it into an aware `~datetime.datetime`{.interpreted-text role="class"} using the local `~datetime.timezone`{.interpreted-text role="class"}.

### ftplib

- `ftplib.FTP`{.interpreted-text role="class"} 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 `8594`{.interpreted-text role="issue"}.)
- The `~ftplib.FTP_TLS`{.interpreted-text role="class"} class now provides a new `~ftplib.FTP_TLS.ccc`{.interpreted-text role="func"} 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 `12139`{.interpreted-text role="issue"}.)
- Added `ftplib.FTP.mlsd`{.interpreted-text role="meth"} method which provides a parsable directory listing format and deprecates `ftplib.FTP.nlst`{.interpreted-text role="meth"} and `ftplib.FTP.dir`{.interpreted-text role="meth"}. (Contributed by Giampaolo Rodolà in `11072`{.interpreted-text role="issue"}.)

### functools

The `functools.lru_cache`{.interpreted-text role="func"} 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 `13227`{.interpreted-text role="issue"}.)

### gc

It is now possible to register callbacks invoked by the garbage collector before and after collection using the new `~gc.callbacks`{.interpreted-text role="data"} list.

### hmac

A new `~hmac.compare_digest`{.interpreted-text role="func"} function has been added to prevent side channel attacks on digests through timing analysis. (Contributed by Nick Coghlan and Christian Heimes in `15061`{.interpreted-text role="issue"}.)

### http

`http.server.BaseHTTPRequestHandler`{.interpreted-text role="class"} now buffers the headers and writes them all at once when `~http.server.BaseHTTPRequestHandler.end_headers`{.interpreted-text role="meth"} is called. A new method `~http.server.BaseHTTPRequestHandler.flush_headers`{.interpreted-text role="meth"} can be used to directly manage when the accumulated headers are sent. (Contributed by Andrew Schaaf in `3709`{.interpreted-text role="issue"}.)

`http.server`{.interpreted-text role="class"} now produces valid `HTML 4.01 strict` output. (Contributed by Ezio Melotti in `13295`{.interpreted-text role="issue"}.)

`http.client.HTTPResponse`{.interpreted-text role="class"} now has a `~http.client.HTTPResponse.readinto`{.interpreted-text role="meth"} method, which means it can be used as an `io.RawIOBase`{.interpreted-text role="class"} class. (Contributed by John Kuhn in `13464`{.interpreted-text role="issue"}.)

### html

`html.parser.HTMLParser`{.interpreted-text role="class"} is now able to parse broken markup without raising errors, therefore the *strict* argument of the constructor and the `!HTMLParseError`{.interpreted-text role="exc"} exception are now deprecated. The ability to parse broken markup is the result of a number of bug fixes that are also available on the latest bug fix releases of Python 2.7/3.2. (Contributed by Ezio Melotti in `15114`{.interpreted-text role="issue"}, and `14538`{.interpreted-text role="issue"}, `13993`{.interpreted-text role="issue"}, `13960`{.interpreted-text role="issue"}, `13358`{.interpreted-text role="issue"}, `1745761`{.interpreted-text role="issue"}, `755670`{.interpreted-text role="issue"}, `13357`{.interpreted-text role="issue"}, `12629`{.interpreted-text role="issue"}, `1200313`{.interpreted-text role="issue"}, `670664`{.interpreted-text role="issue"}, `13273`{.interpreted-text role="issue"}, `12888`{.interpreted-text role="issue"}, `7311`{.interpreted-text role="issue"}.)

A new `~html.entities.html5`{.interpreted-text role="data"} dictionary that maps HTML5 named character references to the equivalent Unicode character(s) (e.g. `html5['gt;'] == '>'`) has been added to the `html.entities`{.interpreted-text role="mod"} module. The dictionary is now also used by `~html.parser.HTMLParser`{.interpreted-text role="class"}. (Contributed by Ezio Melotti in `11113`{.interpreted-text role="issue"} and `15156`{.interpreted-text role="issue"}.)

### imaplib

The `~imaplib.IMAP4_SSL`{.interpreted-text role="class"} constructor now accepts an SSLContext parameter to control parameters of the secure channel.

(Contributed by Sijin Joseph in `8808`{.interpreted-text role="issue"}.)

### inspect

A new `~inspect.getclosurevars`{.interpreted-text role="func"} 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.

(Contributed by Meador Inge and Nick Coghlan in `13062`{.interpreted-text role="issue"}.)

A new `~inspect.getgeneratorlocals`{.interpreted-text role="func"} 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.

(Contributed by Meador Inge in `15153`{.interpreted-text role="issue"}.)

### io

The `~io.open`{.interpreted-text role="func"} function has a new `'x'` mode that can be used to exclusively create a new file, and raise a `FileExistsError`{.interpreted-text role="exc"} if the file already exists. It is based on the C11 \'x\' mode to fopen().

(Contributed by David Townshend in `12760`{.interpreted-text role="issue"}.)

The constructor of the `~io.TextIOWrapper`{.interpreted-text role="class"} class has a new *write_through* optional argument. If *write_through* is `True`, calls to `!write`{.interpreted-text role="meth"} are guaranteed not to be buffered: any data written on the `~io.TextIOWrapper`{.interpreted-text role="class"} object is immediately handled to its underlying binary buffer.

### itertools

`~itertools.accumulate`{.interpreted-text role="func"} now takes an optional `func` argument for providing a user-supplied binary function.

### logging

The `~logging.basicConfig`{.interpreted-text role="func"} 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`{.interpreted-text role="attr"} has been added to `~logging.handlers.SysLogHandler`{.interpreted-text role="class"} to allow control of the appending of the `NUL` (`\000`) byte to syslog records, since for some daemons it is required while for others it is passed through to the log.

### math

The `math`{.interpreted-text role="mod"} module has a new function, `~math.log2`{.interpreted-text role="func"}, which returns the base-2 logarithm of *x*.

(Written by Mark Dickinson in `11888`{.interpreted-text role="issue"}.)

### mmap

The `~mmap.mmap.read`{.interpreted-text role="meth"} 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 `12021`{.interpreted-text role="issue"}.)

### multiprocessing

The new `multiprocessing.connection.wait`{.interpreted-text role="func"} function allows polling multiple objects (such as connections, sockets and pipes) with a timeout. (Contributed by Richard Oudkerk in `12328`{.interpreted-text role="issue"}.)

`multiprocessing.connection.Connection`{.interpreted-text role="class"} objects can now be transferred over multiprocessing connections. (Contributed by Richard Oudkerk in `4892`{.interpreted-text role="issue"}.)

`multiprocessing.Process`{.interpreted-text role="class"} now accepts a `daemon` keyword argument to override the default behavior of inheriting the `daemon` flag from the parent process (`6064`{.interpreted-text role="issue"}).

New attribute `multiprocessing.Process.sentinel`{.interpreted-text role="data"} allows a program to wait on multiple `~multiprocessing.Process`{.interpreted-text role="class"} objects at one time using the appropriate OS primitives (for example, `select`{.interpreted-text role="mod"} on posix systems).

New methods `multiprocessing.pool.Pool.starmap`{.interpreted-text role="meth"} and `~multiprocessing.pool.Pool.starmap_async`{.interpreted-text role="meth"} provide `itertools.starmap`{.interpreted-text role="func"} equivalents to the existing `multiprocessing.pool.Pool.map`{.interpreted-text role="meth"} and `~multiprocessing.pool.Pool.map_async`{.interpreted-text role="meth"} functions. (Contributed by Hynek Schlawack in `12708`{.interpreted-text role="issue"}.)

### nntplib

The `!nntplib.NNTP`{.interpreted-text role="class"} class now supports the context management protocol to unconditionally consume `socket.error`{.interpreted-text role="exc"} exceptions and to close the NNTP connection when done:

    >>> from nntplib import NNTP
    >>> with NNTP('news.gmane.org') as n:
    ...     n.group('gmane.comp.python.committers')
    ...
    ('211 1755 1 1755 gmane.comp.python.committers', 1755, 1, 1755, 'gmane.comp.python.committers')
    >>>

(Contributed by Giampaolo Rodolà in `9795`{.interpreted-text role="issue"}.)

### os

- The `os`{.interpreted-text role="mod"} module has a new `~os.pipe2`{.interpreted-text role="func"} function that makes it possible to create a pipe with `~os.O_CLOEXEC`{.interpreted-text role="const"} or `~os.O_NONBLOCK`{.interpreted-text role="const"} flags set atomically. This is especially useful to avoid race conditions in multi-threaded programs.

- The `os`{.interpreted-text role="mod"} module has a new `~os.sendfile`{.interpreted-text role="func"} 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. `~os.sendfile`{.interpreted-text role="func"} 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 `10882`{.interpreted-text role="issue"}.)

- 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 (`4761`{.interpreted-text role="issue"}, `10755`{.interpreted-text role="issue"} and `14626`{.interpreted-text role="issue"}).

  - The `os`{.interpreted-text role="mod"} module has a new `~os.fwalk`{.interpreted-text role="func"} function similar to `~os.walk`{.interpreted-text role="func"} except that it also yields file descriptors referring to the directories visited. This is especially useful to avoid symlink races.
  - The following functions get new optional *dir_fd* (`paths relative to
    directory descriptors <dir_fd>`{.interpreted-text role="ref"}) and/or *follow_symlinks* (`not
    following symlinks <follow_symlinks>`{.interpreted-text role="ref"}): `~os.access`{.interpreted-text role="func"}, `~os.chflags`{.interpreted-text role="func"}, `~os.chmod`{.interpreted-text role="func"}, `~os.chown`{.interpreted-text role="func"}, `~os.link`{.interpreted-text role="func"}, `~os.lstat`{.interpreted-text role="func"}, `~os.mkdir`{.interpreted-text role="func"}, `~os.mkfifo`{.interpreted-text role="func"}, `~os.mknod`{.interpreted-text role="func"}, `~os.open`{.interpreted-text role="func"}, `~os.readlink`{.interpreted-text role="func"}, `~os.remove`{.interpreted-text role="func"}, `~os.rename`{.interpreted-text role="func"}, `~os.replace`{.interpreted-text role="func"}, `~os.rmdir`{.interpreted-text role="func"}, `~os.stat`{.interpreted-text role="func"}, `~os.symlink`{.interpreted-text role="func"}, `~os.unlink`{.interpreted-text role="func"}, `~os.utime`{.interpreted-text role="func"}. Platform support for using these parameters can be checked via the sets `os.supports_dir_fd`{.interpreted-text role="data"} and `os.supports_follow_symlinks`{.interpreted-text role="data"}.
  - The following functions now support a file descriptor for their path argument: `~os.chdir`{.interpreted-text role="func"}, `~os.chmod`{.interpreted-text role="func"}, `~os.chown`{.interpreted-text role="func"}, `~os.execve`{.interpreted-text role="func"}, `~os.listdir`{.interpreted-text role="func"}, `~os.pathconf`{.interpreted-text role="func"}, `~os.path.exists`{.interpreted-text role="func"}, `~os.stat`{.interpreted-text role="func"}, `~os.statvfs`{.interpreted-text role="func"}, `~os.utime`{.interpreted-text role="func"}. Platform support for this can be checked via the `os.supports_fd`{.interpreted-text role="data"} set.

- `~os.access`{.interpreted-text role="func"} 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 `~os.supports_effective_ids`{.interpreted-text role="data"} set.

- The `os`{.interpreted-text role="mod"} module has two new functions: `~os.getpriority`{.interpreted-text role="func"} and `~os.setpriority`{.interpreted-text role="func"}. They can be used to get or set process niceness/priority in a fashion similar to `os.nice`{.interpreted-text role="func"} but extended to all processes instead of just the current one.

  (Patch submitted by Giampaolo Rodolà in `10784`{.interpreted-text role="issue"}.)

- The new `os.replace`{.interpreted-text role="func"} function allows cross-platform renaming of a file with overwriting the destination. With `os.rename`{.interpreted-text role="func"}, an existing destination file is overwritten under POSIX, but raises an error under Windows. (Contributed by Antoine Pitrou in `8828`{.interpreted-text role="issue"}.)

- The stat family of functions (`~os.stat`{.interpreted-text role="func"}, `~os.fstat`{.interpreted-text role="func"}, and `~os.lstat`{.interpreted-text role="func"}) now support reading a file\'s timestamps with nanosecond precision. Symmetrically, `~os.utime`{.interpreted-text role="func"} can now write file timestamps with nanosecond precision. (Contributed by Larry Hastings in `14127`{.interpreted-text role="issue"}.)

- The new `os.get_terminal_size`{.interpreted-text role="func"} function queries the size of the terminal attached to a file descriptor. See also `shutil.get_terminal_size`{.interpreted-text role="func"}. (Contributed by Zbigniew Jędrzejewski-Szmek in `13609`{.interpreted-text role="issue"}.)

<!-- -->

- New functions to support Linux extended attributes (`12720`{.interpreted-text role="issue"}): `~os.getxattr`{.interpreted-text role="func"}, `~os.listxattr`{.interpreted-text role="func"}, `~os.removexattr`{.interpreted-text role="func"}, `~os.setxattr`{.interpreted-text role="func"}.
- New interface to the scheduler. These functions control how a process is allocated CPU time by the operating system. New functions: `~os.sched_get_priority_max`{.interpreted-text role="func"}, `~os.sched_get_priority_min`{.interpreted-text role="func"}, `~os.sched_getaffinity`{.interpreted-text role="func"}, `~os.sched_getparam`{.interpreted-text role="func"}, `~os.sched_getscheduler`{.interpreted-text role="func"}, `~os.sched_rr_get_interval`{.interpreted-text role="func"}, `~os.sched_setaffinity`{.interpreted-text role="func"}, `~os.sched_setparam`{.interpreted-text role="func"}, `~os.sched_setscheduler`{.interpreted-text role="func"}, `~os.sched_yield`{.interpreted-text role="func"},
- New functions to control the file system:
  - `~os.posix_fadvise`{.interpreted-text role="func"}: Announces an intention to access data in a specific pattern thus allowing the kernel to make optimizations.
  - `~os.posix_fallocate`{.interpreted-text role="func"}: Ensures that enough disk space is allocated for a file.
  - `~os.sync`{.interpreted-text role="func"}: Force write of everything to disk.
- Additional new posix functions:
  - `~os.lockf`{.interpreted-text role="func"}: Apply, test or remove a POSIX lock on an open file descriptor.
  - `~os.pread`{.interpreted-text role="func"}: Read from a file descriptor at an offset, the file offset remains unchanged.
  - `~os.pwrite`{.interpreted-text role="func"}: Write to a file descriptor from an offset, leaving the file offset unchanged.
  - `~os.readv`{.interpreted-text role="func"}: Read from a file descriptor into a number of writable buffers.
  - `~os.truncate`{.interpreted-text role="func"}: Truncate the file corresponding to *path*, so that it is at most *length* bytes in size.
  - `~os.waitid`{.interpreted-text role="func"}: Wait for the completion of one or more child processes.
  - `~os.writev`{.interpreted-text role="func"}: Write the contents of *buffers* to a file descriptor, where *buffers* is an arbitrary sequence of buffers.
  - `~os.getgrouplist`{.interpreted-text role="func"} (`9344`{.interpreted-text role="issue"}): Return list of group ids that specified user belongs to.
- `~os.times`{.interpreted-text role="func"} and `~os.uname`{.interpreted-text role="func"}: Return type changed from a tuple to a tuple-like object with named attributes.
- Some platforms now support additional constants for the `~os.lseek`{.interpreted-text role="func"} function, such as `os.SEEK_HOLE` and `os.SEEK_DATA`.
- New constants `~os.RTLD_LAZY`{.interpreted-text role="const"}, `~os.RTLD_NOW`{.interpreted-text role="const"}, `~os.RTLD_GLOBAL`{.interpreted-text role="const"}, `~os.RTLD_LOCAL`{.interpreted-text role="const"}, `~os.RTLD_NODELETE`{.interpreted-text role="const"}, `~os.RTLD_NOLOAD`{.interpreted-text role="const"}, and `~os.RTLD_DEEPBIND`{.interpreted-text role="const"} are available on platforms that support them. These are for use with the `sys.setdlopenflags`{.interpreted-text role="func"} function, and supersede the similar constants defined in `ctypes`{.interpreted-text role="mod"} and `!DLFCN`{.interpreted-text role="mod"}. (Contributed by Victor Stinner in `13226`{.interpreted-text role="issue"}.)
- `os.symlink`{.interpreted-text role="func"} now accepts (and ignores) the `target_is_directory` keyword argument on non-Windows platforms, to ease cross-platform support.

### pdb

Tab-completion is now available not only for command names, but also their arguments. For example, for the `break` command, function and file names are completed.

(Contributed by Georg Brandl in `14210`{.interpreted-text role="issue"})

### pickle

`pickle.Pickler`{.interpreted-text role="class"} objects now have an optional `~pickle.Pickler.dispatch_table`{.interpreted-text role="attr"} attribute allowing per-pickler reduction functions to be set.

(Contributed by Richard Oudkerk in `14166`{.interpreted-text role="issue"}.)

### pydoc

The Tk GUI and the `!serve`{.interpreted-text role="func"} function have been removed from the `pydoc`{.interpreted-text role="mod"} module: `pydoc -g` and `!serve`{.interpreted-text role="func"} have been deprecated in Python 3.2.

### re

`str`{.interpreted-text role="class"} regular expressions now support `\u` and `\U` escapes.

(Contributed by Serhiy Storchaka in `3665`{.interpreted-text role="issue"}.)

### sched

- `~sched.scheduler.run`{.interpreted-text role="meth"} 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 `~sched.scheduler`{.interpreted-text role="class"} in non-blocking applications. (Contributed by Giampaolo Rodolà in `13449`{.interpreted-text role="issue"}.)
- `~sched.scheduler`{.interpreted-text role="class"} class can now be safely used in multi-threaded environments. (Contributed by Josiah Carlson and Giampaolo Rodolà in `8684`{.interpreted-text role="issue"}.)
- *timefunc* and *delayfunct* parameters of `~sched.scheduler`{.interpreted-text role="class"} class constructor are now optional and defaults to `time.time`{.interpreted-text role="func"} and `time.sleep`{.interpreted-text role="func"} respectively. (Contributed by Chris Clark in `13245`{.interpreted-text role="issue"}.)
- `~sched.scheduler.enter`{.interpreted-text role="meth"} and `~sched.scheduler.enterabs`{.interpreted-text role="meth"} *argument* parameter is now optional. (Contributed by Chris Clark in `13245`{.interpreted-text role="issue"}.)
- `~sched.scheduler.enter`{.interpreted-text role="meth"} and `~sched.scheduler.enterabs`{.interpreted-text role="meth"} now accept a *kwargs* parameter. (Contributed by Chris Clark in `13245`{.interpreted-text role="issue"}.)

### select

Solaris and derivative platforms have a new class `select.devpoll`{.interpreted-text role="class"} for high performance asynchronous sockets via `/dev/poll`{.interpreted-text role="file"}. (Contributed by Jesús Cea Avión in `6397`{.interpreted-text role="issue"}.)

### shlex

The previously undocumented helper function `quote` from the `!pipes`{.interpreted-text role="mod"} modules has been moved to the `shlex`{.interpreted-text role="mod"} module and documented. `~shlex.quote`{.interpreted-text role="func"} properly escapes all characters in a string that might be otherwise given special meaning by the shell.

### shutil

- New functions:
  - `~shutil.disk_usage`{.interpreted-text role="func"}: provides total, used and free disk space statistics. (Contributed by Giampaolo Rodolà in `12442`{.interpreted-text role="issue"}.)
  - `~shutil.chown`{.interpreted-text role="func"}: allows one to change user and/or group of the given path also specifying the user/group names and not only their numeric ids. (Contributed by Sandro Tosi in `12191`{.interpreted-text role="issue"}.)
  - `shutil.get_terminal_size`{.interpreted-text role="func"}: returns the size of the terminal window to which the interpreter is attached. (Contributed by Zbigniew Jędrzejewski-Szmek in `13609`{.interpreted-text role="issue"}.)
- `~shutil.copy2`{.interpreted-text role="func"} and `~shutil.copystat`{.interpreted-text role="func"} 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 `14127`{.interpreted-text role="issue"} and `15238`{.interpreted-text role="issue"}.)
- 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 `12715`{.interpreted-text role="issue"}.)
- When copying files to a different file system, `~shutil.move`{.interpreted-text role="func"} 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 `9993`{.interpreted-text role="issue"}.) `~shutil.move`{.interpreted-text role="func"} now also returns the `dst` argument as its result.
- `~shutil.rmtree`{.interpreted-text role="func"} is now resistant to symlink attacks on platforms which support the new `dir_fd` parameter in `os.open`{.interpreted-text role="func"} and `os.unlink`{.interpreted-text role="func"}. (Contributed by Martin von Löwis and Hynek Schlawack in `4489`{.interpreted-text role="issue"}.)

### signal

- The `signal`{.interpreted-text role="mod"} module has new functions:
  - `~signal.pthread_sigmask`{.interpreted-text role="func"}: fetch and/or change the signal mask of the calling thread (Contributed by Jean-Paul Calderone in `8407`{.interpreted-text role="issue"});
  - `~signal.pthread_kill`{.interpreted-text role="func"}: send a signal to a thread;
  - `~signal.sigpending`{.interpreted-text role="func"}: examine pending functions;
  - `~signal.sigwait`{.interpreted-text role="func"}: wait a signal;
  - `~signal.sigwaitinfo`{.interpreted-text role="func"}: wait for a signal, returning detailed information about it;
  - `~signal.sigtimedwait`{.interpreted-text role="func"}: like `~signal.sigwaitinfo`{.interpreted-text role="func"} but with a timeout.
- The signal handler writes the signal number as a single byte instead of a nul byte into the wakeup file descriptor. So it is possible to wait more than one signal and know which signals were raised.
- `signal.signal`{.interpreted-text role="func"} and `signal.siginterrupt`{.interpreted-text role="func"} raise an OSError, instead of a RuntimeError: OSError has an errno attribute.

### smtpd

The `!smtpd`{.interpreted-text role="mod"} module now supports `5321`{.interpreted-text role="rfc"} (extended SMTP) and `1870`{.interpreted-text role="rfc"} (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. `8739`{.interpreted-text role="issue"})

### smtplib

The `~smtplib.SMTP`{.interpreted-text role="class"}, `~smtplib.SMTP_SSL`{.interpreted-text role="class"}, and `~smtplib.LMTP`{.interpreted-text role="class"} 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 `11281`{.interpreted-text role="issue"}.)

`~smtplib.SMTP`{.interpreted-text role="class"} now supports the context management protocol, allowing an `SMTP` instance to be used in a `with` statement. (Contributed by Giampaolo Rodolà in `11289`{.interpreted-text role="issue"}.)

The `~smtplib.SMTP_SSL`{.interpreted-text role="class"} constructor and the `~smtplib.SMTP.starttls`{.interpreted-text role="meth"} method now accept an SSLContext parameter to control parameters of the secure channel. (Contributed by Kasun Herath in `8809`{.interpreted-text role="issue"}.)

### socket

- The `~socket.socket`{.interpreted-text role="class"} class now exposes additional methods to process ancillary data when supported by the underlying platform:

  - `~socket.socket.sendmsg`{.interpreted-text role="func"}
  - `~socket.socket.recvmsg`{.interpreted-text role="func"}
  - `~socket.socket.recvmsg_into`{.interpreted-text role="func"}

  (Contributed by David Watson in `6560`{.interpreted-text role="issue"}, based on an earlier patch by Heiko Wundram)

- The `~socket.socket`{.interpreted-text role="class"} class now supports the PF_CAN protocol family (<https://en.wikipedia.org/wiki/Socketcan>), on Linux (<https://lwn.net/Articles/253425>).

  (Contributed by Matthias Fuchs, updated by Tiago Gonçalves in `10141`{.interpreted-text role="issue"}.)

- The `~socket.socket`{.interpreted-text role="class"} class now supports the PF_RDS protocol family (<https://en.wikipedia.org/wiki/Reliable_Datagram_Sockets> and [https://oss.oracle.com/projects/rds](https://web.archive.org/web/20130115155505/https://oss.oracle.com/projects/rds/)).

- The `~socket.socket`{.interpreted-text role="class"} class now supports the `PF_SYSTEM` protocol family on OS X. (Contributed by Michael Goderbauer in `13777`{.interpreted-text role="issue"}.)

- New function `~socket.sethostname`{.interpreted-text role="func"} allows the hostname to be set on Unix systems if the calling process has sufficient privileges. (Contributed by Ross Lagerwall in `10866`{.interpreted-text role="issue"}.)

### socketserver

`~socketserver.BaseServer`{.interpreted-text role="class"} now has an overridable method `~socketserver.BaseServer.service_actions`{.interpreted-text role="meth"} that is called by the `~socketserver.BaseServer.serve_forever`{.interpreted-text role="meth"} method in the service loop. `~socketserver.ForkingMixIn`{.interpreted-text role="class"} now uses this to clean up zombie child processes. (Contributed by Justin Warkentin in `11109`{.interpreted-text role="issue"}.)

### sqlite3

New `sqlite3.Connection`{.interpreted-text role="class"} method `~sqlite3.Connection.set_trace_callback`{.interpreted-text role="meth"} can be used to capture a trace of all sql commands processed by sqlite. (Contributed by Torsten Landschoff in `11688`{.interpreted-text role="issue"}.)

### ssl

- The `ssl`{.interpreted-text role="mod"} module has two new random generation functions:

  - `~ssl.RAND_bytes`{.interpreted-text role="func"}: generate cryptographically strong pseudo-random bytes.
  - `!RAND_pseudo_bytes`{.interpreted-text role="func"}: generate pseudo-random bytes.

  (Contributed by Victor Stinner in `12049`{.interpreted-text role="issue"}.)

- The `ssl`{.interpreted-text role="mod"} module now exposes a finer-grained exception hierarchy in order to make it easier to inspect the various kinds of errors. (Contributed by Antoine Pitrou in `11183`{.interpreted-text role="issue"}.)

- `~ssl.SSLContext.load_cert_chain`{.interpreted-text role="meth"} now accepts a *password* argument to be used if the private key is encrypted. (Contributed by Adam Simpkins in `12803`{.interpreted-text role="issue"}.)

- Diffie-Hellman key exchange, both regular and Elliptic Curve-based, is now supported through the `~ssl.SSLContext.load_dh_params`{.interpreted-text role="meth"} and `~ssl.SSLContext.set_ecdh_curve`{.interpreted-text role="meth"} methods. (Contributed by Antoine Pitrou in `13626`{.interpreted-text role="issue"} and `13627`{.interpreted-text role="issue"}.)

- SSL sockets have a new `~ssl.SSLSocket.get_channel_binding`{.interpreted-text role="meth"} method allowing the implementation of certain authentication mechanisms such as SCRAM-SHA-1-PLUS. (Contributed by Jacek Konieczny in `12551`{.interpreted-text role="issue"}.)

- You can query the SSL compression algorithm used by an SSL socket, thanks to its new `~ssl.SSLSocket.compression`{.interpreted-text role="meth"} method. The new attribute `~ssl.OP_NO_COMPRESSION`{.interpreted-text role="const"} can be used to disable compression. (Contributed by Antoine Pitrou in `13634`{.interpreted-text role="issue"}.)

- Support has been added for the Next Protocol Negotiation extension using the `ssl.SSLContext.set_npn_protocols`{.interpreted-text role="meth"} method. (Contributed by Colin Marc in `14204`{.interpreted-text role="issue"}.)

- SSL errors can now be introspected more easily thanks to `~ssl.SSLError.library`{.interpreted-text role="attr"} and `~ssl.SSLError.reason`{.interpreted-text role="attr"} attributes. (Contributed by Antoine Pitrou in `14837`{.interpreted-text role="issue"}.)

- The `~ssl.get_server_certificate`{.interpreted-text role="func"} function now supports IPv6. (Contributed by Charles-François Natali in `11811`{.interpreted-text role="issue"}.)

- New attribute `~ssl.OP_CIPHER_SERVER_PREFERENCE`{.interpreted-text role="const"} allows setting SSLv3 server sockets to use the server\'s cipher ordering preference rather than the client\'s (`13635`{.interpreted-text role="issue"}).

### stat

The undocumented tarfile.filemode function has been moved to `stat.filemode`{.interpreted-text role="func"}. It can be used to convert a file\'s mode to a string of the form \'-rwxrwxrwx\'.

(Contributed by Giampaolo Rodolà in `14807`{.interpreted-text role="issue"}.)

### struct

The `struct`{.interpreted-text role="mod"} module now supports `ssize_t`{.interpreted-text role="c:type"} and `size_t`{.interpreted-text role="c:type"} via the new codes `n` and `N`, respectively. (Contributed by Antoine Pitrou in `3163`{.interpreted-text role="issue"}.)

### subprocess

Command strings can now be bytes objects on posix platforms. (Contributed by Victor Stinner in `8513`{.interpreted-text role="issue"}.)

A new constant `~subprocess.DEVNULL`{.interpreted-text role="const"} allows suppressing output in a platform-independent fashion. (Contributed by Ross Lagerwall in `5870`{.interpreted-text role="issue"}.)

### sys

The `sys`{.interpreted-text role="mod"} module has a new `~sys.thread_info`{.interpreted-text role="data"} `named
tuple`{.interpreted-text role="term"} holding information about the thread implementation (`11223`{.interpreted-text role="issue"}).

### tarfile

`tarfile`{.interpreted-text role="mod"} now supports `lzma` encoding via the `lzma`{.interpreted-text role="mod"} module. (Contributed by Lars Gustäbel in `5689`{.interpreted-text role="issue"}.)

### tempfile

`tempfile.SpooledTemporaryFile`{.interpreted-text role="class"}\'s `!truncate`{.interpreted-text role="meth"} method now accepts a `size` parameter. (Contributed by Ryan Kelly in `9957`{.interpreted-text role="issue"}.)

### textwrap

The `textwrap`{.interpreted-text role="mod"} module has a new `~textwrap.indent`{.interpreted-text role="func"} that makes it straightforward to add a common prefix to selected lines in a block of text (`13857`{.interpreted-text role="issue"}).

### threading

`threading.Condition`{.interpreted-text role="class"}, `threading.Semaphore`{.interpreted-text role="class"}, `threading.BoundedSemaphore`{.interpreted-text role="class"}, `threading.Event`{.interpreted-text role="class"}, and `threading.Timer`{.interpreted-text role="class"}, all of which used to be factory functions returning a class instance, are now classes and may be subclassed. (Contributed by Éric Araujo in `10968`{.interpreted-text role="issue"}.)

The `threading.Thread`{.interpreted-text role="class"} constructor now accepts a `daemon` keyword argument to override the default behavior of inheriting the `daemon` flag value from the parent thread (`6064`{.interpreted-text role="issue"}).

The formerly private function `_thread.get_ident` is now available as the public function `threading.get_ident`{.interpreted-text role="func"}. 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.

### time

The `418`{.interpreted-text role="pep"} added new functions to the `time`{.interpreted-text role="mod"} module:

- `~time.get_clock_info`{.interpreted-text role="func"}: Get information on a clock.
- `~time.monotonic`{.interpreted-text role="func"}: Monotonic clock (cannot go backward), not affected by system clock updates.
- `~time.perf_counter`{.interpreted-text role="func"}: Performance counter with the highest available resolution to measure a short duration.
- `~time.process_time`{.interpreted-text role="func"}: Sum of the system and user CPU time of the current process.

Other new functions:

- `~time.clock_getres`{.interpreted-text role="func"}, `~time.clock_gettime`{.interpreted-text role="func"} and `~time.clock_settime`{.interpreted-text role="func"} functions with `CLOCK_{xxx}`{.interpreted-text role="samp"} constants. (Contributed by Victor Stinner in `10278`{.interpreted-text role="issue"}.)

To improve cross platform consistency, `~time.sleep`{.interpreted-text role="func"} now raises a `ValueError`{.interpreted-text role="exc"} when passed a negative sleep value. Previously this was an error on posix, but produced an infinite sleep on Windows.

### types

Add a new `types.MappingProxyType`{.interpreted-text role="class"} class: Read-only proxy of a mapping. (`14386`{.interpreted-text role="issue"})

The new functions `types.new_class`{.interpreted-text role="func"} and `types.prepare_class`{.interpreted-text role="func"} provide support for `3115`{.interpreted-text role="pep"} compliant dynamic type creation. (`14588`{.interpreted-text role="issue"})

### unittest

`.assertRaises`{.interpreted-text role="meth"}, `.assertRaisesRegex`{.interpreted-text role="meth"}, `.assertWarns`{.interpreted-text role="meth"}, and `.assertWarnsRegex`{.interpreted-text role="meth"} now accept a keyword argument *msg* when used as context managers. (Contributed by Ezio Melotti and Winston Ewert in `10775`{.interpreted-text role="issue"}.)

`unittest.TestCase.run`{.interpreted-text role="meth"} now returns the `~unittest.TestResult`{.interpreted-text role="class"} object.

### urllib

The `~urllib.request.Request`{.interpreted-text role="class"} class, now accepts a *method* argument used by `~urllib.request.Request.get_method`{.interpreted-text role="meth"} to determine what HTTP method should be used. For example, this will send a `'HEAD'` request:

    >>> urlopen(Request('https://www.python.org', method='HEAD'))

(`1673007`{.interpreted-text role="issue"})

### webbrowser

The `webbrowser`{.interpreted-text role="mod"} module supports more \"browsers\": Google Chrome (named `chrome`{.interpreted-text role="program"}, `chromium`{.interpreted-text role="program"}, `chrome-browser`{.interpreted-text role="program"} or `chromium-browser`{.interpreted-text role="program"} depending on the version and operating system), and the generic launchers `xdg-open`{.interpreted-text role="program"}, from the FreeDesktop.org project, and `gvfs-open`{.interpreted-text role="program"}, which is the default URI handler for GNOME 3. (The former contributed by Arnaud Calmettes in `13620`{.interpreted-text role="issue"}, the latter by Matthias Klose in `14493`{.interpreted-text role="issue"}.)

### xml.etree.ElementTree

The `xml.etree.ElementTree`{.interpreted-text role="mod"} module now imports its C accelerator by default; there is no longer a need to explicitly import `!xml.etree.cElementTree`{.interpreted-text role="mod"} (this module stays for backwards compatibility, but is now deprecated). In addition, the `iter` family of methods of `~xml.etree.ElementTree.Element`{.interpreted-text role="class"} has been optimized (rewritten in C). The module\'s documentation has also been greatly improved with added examples and a more detailed reference.

### zlib

New attribute `zlib.Decompress.eof`{.interpreted-text role="attr"} makes it possible to distinguish between a properly formed compressed stream and an incomplete or truncated one. (Contributed by Nadeem Vawda in `12646`{.interpreted-text role="issue"}.)

New attribute `zlib.ZLIB_RUNTIME_VERSION`{.interpreted-text role="const"} reports the version string of the underlying `zlib` library that is loaded at runtime. (Contributed by Torsten Landschoff in `12306`{.interpreted-text role="issue"}.)

## Optimizations

Major performance enhancements have been added:

- Thanks to `393`{.interpreted-text role="pep"}, some operations on Unicode strings have been optimized:

  - the memory footprint is divided by 2 to 4 depending on the text
  - encode an ASCII string to UTF-8 doesn\'t need to encode characters anymore, the UTF-8 representation is shared with the ASCII representation
  - the UTF-8 encoder has been optimized
  - repeating a single ASCII letter and getting a substring of an ASCII string is 4 times faster

- UTF-8 is now 2x to 4x faster. UTF-16 encoding is now up to 10x faster.

  (Contributed by Serhiy Storchaka, `14624`{.interpreted-text role="issue"}, `14738`{.interpreted-text role="issue"} and `15026`{.interpreted-text role="issue"}.)

## Build and C API Changes

Changes to Python\'s build process and to the C API include:

- New `3118`{.interpreted-text role="pep"} related function:
  - `PyMemoryView_FromMemory`{.interpreted-text role="c:func"}
- `393`{.interpreted-text role="pep"} added new Unicode types, macros and functions:
  - High-level API:
    - `PyUnicode_CopyCharacters`{.interpreted-text role="c:func"}
    - `PyUnicode_FindChar`{.interpreted-text role="c:func"}
    - `PyUnicode_GetLength`{.interpreted-text role="c:func"}, `PyUnicode_GET_LENGTH`{.interpreted-text role="c:macro"}
    - `PyUnicode_New`{.interpreted-text role="c:func"}
    - `PyUnicode_Substring`{.interpreted-text role="c:func"}
    - `PyUnicode_ReadChar`{.interpreted-text role="c:func"}, `PyUnicode_WriteChar`{.interpreted-text role="c:func"}
  - Low-level API:
    - `Py_UCS1`{.interpreted-text role="c:type"}, `Py_UCS2`{.interpreted-text role="c:type"}, `Py_UCS4`{.interpreted-text role="c:type"} types
    - `PyASCIIObject`{.interpreted-text role="c:type"} and `PyCompactUnicodeObject`{.interpreted-text role="c:type"} structures
    - `PyUnicode_READY`{.interpreted-text role="c:macro"}
    - `PyUnicode_FromKindAndData`{.interpreted-text role="c:func"}
    - `PyUnicode_AsUCS4`{.interpreted-text role="c:func"}, `PyUnicode_AsUCS4Copy`{.interpreted-text role="c:func"}
    - `PyUnicode_DATA`{.interpreted-text role="c:macro"}, `PyUnicode_1BYTE_DATA`{.interpreted-text role="c:macro"}, `PyUnicode_2BYTE_DATA`{.interpreted-text role="c:macro"}, `PyUnicode_4BYTE_DATA`{.interpreted-text role="c:macro"}
    - `PyUnicode_KIND`{.interpreted-text role="c:macro"} with `!PyUnicode_Kind`{.interpreted-text role="c:enum"} enum: `!PyUnicode_WCHAR_KIND`{.interpreted-text role="c:data"}, `PyUnicode_1BYTE_KIND`{.interpreted-text role="c:data"}, `PyUnicode_2BYTE_KIND`{.interpreted-text role="c:data"}, `PyUnicode_4BYTE_KIND`{.interpreted-text role="c:data"}
    - `PyUnicode_READ`{.interpreted-text role="c:macro"}, `PyUnicode_READ_CHAR`{.interpreted-text role="c:macro"}, `PyUnicode_WRITE`{.interpreted-text role="c:macro"}
    - `PyUnicode_MAX_CHAR_VALUE`{.interpreted-text role="c:macro"}
- `PyArg_ParseTuple`{.interpreted-text role="c:macro"} now accepts a `bytearray`{.interpreted-text role="class"} for the `c` format (`12380`{.interpreted-text role="issue"}).

## Deprecated

### Unsupported Operating Systems

OS/2 and VMS are no longer supported due to the lack of a maintainer.

Windows 2000 and Windows platforms which set `COMSPEC` to `command.com` are no longer supported due to maintenance burden.

OSF support, which was deprecated in 3.2, has been completely removed.

### Deprecated Python modules, functions and methods

- Passing a non-empty string to `object.__format__()` is deprecated, and will produce a `TypeError`{.interpreted-text role="exc"} in Python 3.4 (`9856`{.interpreted-text role="issue"}).
- The `unicode_internal` codec has been deprecated because of the `393`{.interpreted-text role="pep"}, use UTF-8, UTF-16 (`utf-16-le` or `utf-16-be`), or UTF-32 (`utf-32-le` or `utf-32-be`)
- `ftplib.FTP.nlst`{.interpreted-text role="meth"} and `ftplib.FTP.dir`{.interpreted-text role="meth"}: use `ftplib.FTP.mlsd`{.interpreted-text role="meth"}
- `!platform.popen`{.interpreted-text role="func"}: use the `subprocess`{.interpreted-text role="mod"} module. Check especially the `subprocess-replacements`{.interpreted-text role="ref"} section (`11377`{.interpreted-text role="issue"}).
- `13374`{.interpreted-text role="issue"}: The Windows bytes API has been deprecated in the `os`{.interpreted-text role="mod"} module. Use Unicode filenames, instead of bytes filenames, to not depend on the ANSI code page anymore and to support any filename.
- `13988`{.interpreted-text role="issue"}: The `!xml.etree.cElementTree`{.interpreted-text role="mod"} module is deprecated. The accelerator is used automatically whenever available.
- The behaviour of `!time.clock`{.interpreted-text role="func"} depends on the platform: use the new `time.perf_counter`{.interpreted-text role="func"} or `time.process_time`{.interpreted-text role="func"} function instead, depending on your requirements, to have a well defined behaviour.
- The `!os.stat_float_times`{.interpreted-text role="func"} function is deprecated.
- `abc`{.interpreted-text role="mod"} module:
  - `abc.abstractproperty`{.interpreted-text role="class"} has been deprecated, use `property`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.
  - `abc.abstractclassmethod`{.interpreted-text role="class"} has been deprecated, use `classmethod`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.
  - `abc.abstractstaticmethod`{.interpreted-text role="class"} has been deprecated, use `staticmethod`{.interpreted-text role="class"} with `abc.abstractmethod`{.interpreted-text role="func"} instead.
- `importlib`{.interpreted-text role="mod"} package:
  - `importlib.abc.SourceLoader.path_mtime`{.interpreted-text role="meth"} is now deprecated in favour of `importlib.abc.SourceLoader.path_stats`{.interpreted-text role="meth"} as bytecode files now store both the modification time and size of the source file the bytecode file was compiled from.

### Deprecated functions and types of the C API

The `Py_UNICODE`{.interpreted-text role="c:type"} has been deprecated by `393`{.interpreted-text role="pep"} and will be removed in Python 4. All functions using this type are deprecated:

Unicode functions and methods using `Py_UNICODE`{.interpreted-text role="c:type"} and `Py_UNICODE*`{.interpreted-text role="c:expr"} types:

- `!PyUnicode_FromUnicode`{.interpreted-text role="c:macro"}: use `PyUnicode_FromWideChar`{.interpreted-text role="c:func"} or `PyUnicode_FromKindAndData`{.interpreted-text role="c:func"}
- `!PyUnicode_AS_UNICODE`{.interpreted-text role="c:macro"}, `!PyUnicode_AsUnicode`{.interpreted-text role="c:func"}, `!PyUnicode_AsUnicodeAndSize`{.interpreted-text role="c:func"}: use `PyUnicode_AsWideCharString`{.interpreted-text role="c:func"}
- `!PyUnicode_AS_DATA`{.interpreted-text role="c:macro"}: use `PyUnicode_DATA`{.interpreted-text role="c:macro"} with `PyUnicode_READ`{.interpreted-text role="c:macro"} and `PyUnicode_WRITE`{.interpreted-text role="c:macro"}
- `!PyUnicode_GET_SIZE`{.interpreted-text role="c:macro"}, `!PyUnicode_GetSize`{.interpreted-text role="c:func"}: use `PyUnicode_GET_LENGTH`{.interpreted-text role="c:macro"} or `PyUnicode_GetLength`{.interpreted-text role="c:func"}
- `!PyUnicode_GET_DATA_SIZE`{.interpreted-text role="c:macro"}: use `PyUnicode_GET_LENGTH(str) * PyUnicode_KIND(str)` (only work on ready strings)
- `!PyUnicode_AsUnicodeCopy`{.interpreted-text role="c:func"}: use `PyUnicode_AsUCS4Copy`{.interpreted-text role="c:func"} or `PyUnicode_AsWideCharString`{.interpreted-text role="c:func"}
- `!PyUnicode_GetMax`{.interpreted-text role="c:func"}

Functions and macros manipulating Py_UNICODE\* strings:

- `!Py_UNICODE_strlen()`{.interpreted-text role="c:macro"}: use `PyUnicode_GetLength`{.interpreted-text role="c:func"} or `PyUnicode_GET_LENGTH`{.interpreted-text role="c:macro"}
- `!Py_UNICODE_strcat()`{.interpreted-text role="c:macro"}: use `PyUnicode_CopyCharacters`{.interpreted-text role="c:func"} or `PyUnicode_FromFormat`{.interpreted-text role="c:func"}
- `!Py_UNICODE_strcpy()`{.interpreted-text role="c:macro"}, `!Py_UNICODE_strncpy()`{.interpreted-text role="c:macro"}, `!Py_UNICODE_COPY()`{.interpreted-text role="c:macro"}: use `PyUnicode_CopyCharacters`{.interpreted-text role="c:func"} or `PyUnicode_Substring`{.interpreted-text role="c:func"}
- `!Py_UNICODE_strcmp()`{.interpreted-text role="c:macro"}: use `PyUnicode_Compare`{.interpreted-text role="c:func"}
- `!Py_UNICODE_strncmp()`{.interpreted-text role="c:macro"}: use `PyUnicode_Tailmatch`{.interpreted-text role="c:func"}
- `!Py_UNICODE_strchr()`{.interpreted-text role="c:macro"}, `!Py_UNICODE_strrchr()`{.interpreted-text role="c:macro"}: use `PyUnicode_FindChar`{.interpreted-text role="c:func"}
- `!Py_UNICODE_FILL()`{.interpreted-text role="c:macro"}: use `PyUnicode_Fill`{.interpreted-text role="c:func"}
- `!Py_UNICODE_MATCH`{.interpreted-text role="c:macro"}

Encoders:

- `!PyUnicode_Encode`{.interpreted-text role="c:func"}: use `!PyUnicode_AsEncodedObject`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeUTF7`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeUTF8`{.interpreted-text role="c:func"}: use `PyUnicode_AsUTF8`{.interpreted-text role="c:func"} or `PyUnicode_AsUTF8String`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeUTF32`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeUTF16`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeUnicodeEscape`{.interpreted-text role="c:func"} use `PyUnicode_AsUnicodeEscapeString`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeRawUnicodeEscape`{.interpreted-text role="c:func"} use `PyUnicode_AsRawUnicodeEscapeString`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeLatin1`{.interpreted-text role="c:func"}: use `PyUnicode_AsLatin1String`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeASCII`{.interpreted-text role="c:func"}: use `PyUnicode_AsASCIIString`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeCharmap`{.interpreted-text role="c:func"}
- `!PyUnicode_TranslateCharmap`{.interpreted-text role="c:func"}
- `!PyUnicode_EncodeMBCS`{.interpreted-text role="c:func"}: use `PyUnicode_AsMBCSString`{.interpreted-text role="c:func"} or `PyUnicode_EncodeCodePage`{.interpreted-text role="c:func"} (with `CP_ACP` code_page)
- `!PyUnicode_EncodeDecimal`{.interpreted-text role="c:func"}, `!PyUnicode_TransformDecimalToASCII`{.interpreted-text role="c:func"}

### Deprecated features

The `array`{.interpreted-text role="mod"} module\'s `'u'` format code is now deprecated and will be removed in Python 4 together with the rest of the (`Py_UNICODE`{.interpreted-text role="c:type"}) API.

## Porting to Python 3.3

This section lists previously described changes and other bugfixes that may require changes to your code.

### Porting Python code {#portingpythoncode}

- Hash randomization is enabled by default. Set the `PYTHONHASHSEED`{.interpreted-text role="envvar"} environment variable to `0` to disable hash randomization. See also the `object.__hash__`{.interpreted-text role="meth"} method.
- `12326`{.interpreted-text role="issue"}: 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.
- `13847`{.interpreted-text role="issue"}, `14180`{.interpreted-text role="issue"}: `time`{.interpreted-text role="mod"} and `datetime`{.interpreted-text role="mod"}: `OverflowError`{.interpreted-text role="exc"} is now raised instead of `ValueError`{.interpreted-text role="exc"} if a timestamp is out of range. `OSError`{.interpreted-text role="exc"} is now raised if C functions `gmtime`{.interpreted-text role="c:func"} or `localtime`{.interpreted-text role="c:func"} failed.
- 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`{.interpreted-text role="func"} to clear out the cache for the finders to notice the new file.
- `ImportError`{.interpreted-text role="exc"} 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__`{.interpreted-text role="func"} now defaults to 0 instead of -1 and no longer support negative values. It was an oversight when `328`{.interpreted-text role="pep"} 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`{.interpreted-text role="func"} rather than call `__import__`{.interpreted-text role="func"} directly.
- `__import__`{.interpreted-text role="func"} 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`{.interpreted-text role="data"} and `sys.path_hooks`{.interpreted-text role="data"} now have finders on them by default, you will most likely want to use `list.insert`{.interpreted-text role="meth"} instead of `list.append`{.interpreted-text role="meth"} to add to those lists.
- Because `None` is now inserted into `sys.path_importer_cache`{.interpreted-text role="data"}, 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 `None` **and** `!imp.NullImporter`{.interpreted-text role="class"} to be backwards-compatible. This will lead to extra overhead on older versions of Python that re-insert `None` into `sys.path_importer_cache`{.interpreted-text role="data"} where it represents the use of implicit finders, but semantically it should not change anything.
- `!importlib.abc.Finder`{.interpreted-text role="class"} 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 <path entry finder>`{.interpreted-text role="term"}.
- `pkgutil`{.interpreted-text role="mod"} has been converted to use `importlib`{.interpreted-text role="mod"} internally. This eliminates many edge cases where the old behaviour of the `302`{.interpreted-text role="pep"} 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`{.interpreted-text role="func"} and `pkgutil.walk_packages`{.interpreted-text role="func"} 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 (`1079`{.interpreted-text role="issue"}) in the parsing done by `email.header.decode_header`{.interpreted-text role="func"} 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`{.interpreted-text role="func"} 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 (`1690608`{.interpreted-text role="issue"}).
- `poplib.POP3.quit`{.interpreted-text role="meth"} may now raise protocol errors like all other `poplib` methods. Code that assumes `quit` does not raise `poplib.error_proto`{.interpreted-text role="exc"} errors may need to be changed if errors on `quit` are encountered by a particular application (`11291`{.interpreted-text role="issue"}).
- The `strict` argument to `email.parser.Parser`{.interpreted-text role="class"}, 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`{.interpreted-text role="mod"} module. It was previously replaced by the public attribute `~decimal.Context.clamp`{.interpreted-text role="attr"}. (See `8540`{.interpreted-text role="issue"}.)
- The undocumented internal helper class `SSLFakeFile` has been removed from `smtplib`{.interpreted-text role="mod"}, since its functionality has long been provided directly by `socket.socket.makefile`{.interpreted-text role="meth"}.
- Passing a negative value to `time.sleep`{.interpreted-text role="func"} 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`{.interpreted-text role="data"} to make the decision.
- Code that used to work around the fact that the `threading`{.interpreted-text role="mod"} 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 (`13550`{.interpreted-text role="issue"}).

### Porting C code

- In the course of changes to the buffer API the undocumented `!smalltable`{.interpreted-text role="c:member"} member of the `Py_buffer`{.interpreted-text role="c:type"} structure has been removed and the layout of the `!PyMemoryViewObject`{.interpreted-text role="c:type"} has changed.

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

- Due to `PEP 393 <pep-393>`{.interpreted-text role="ref"}, the `Py_UNICODE`{.interpreted-text role="c:type"} 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 `393`{.interpreted-text role="pep"}, you have to convert your code to the new `Unicode API <../c-api/unicode>`{.interpreted-text role="doc"}.

  However, if you only have been using high-level functions such as `PyUnicode_Concat()`{.interpreted-text role="c:func"}, `PyUnicode_Join`{.interpreted-text role="c:func"} or `PyUnicode_FromFormat()`{.interpreted-text role="c:func"}, your code will automatically take advantage of the new unicode representations.

- `PyImport_GetMagicNumber`{.interpreted-text role="c:func"} now returns `-1` upon failure.

- As a negative value for the *level* argument to `__import__`{.interpreted-text role="func"} is no longer valid, the same now holds for `PyImport_ImportModuleLevel`{.interpreted-text role="c:func"}. This also means that the value of *level* used by `PyImport_ImportModuleEx`{.interpreted-text role="c:func"} is now `0` instead of `-1`.

### Building C extensions

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

  (implemented in `14040`{.interpreted-text role="issue"}.)

### Command Line Switch Changes

- The -Q command-line flag and related artifacts have been removed. Code checking sys.flags.division_warning will need updating.

  (`10998`{.interpreted-text role="issue"}, contributed by Éric Araujo.)

- When `python`{.interpreted-text role="program"} is started with `-S`{.interpreted-text role="option"}, `import site` will no longer add site-specific paths to the module search paths. In previous versions, it did.

  (`11591`{.interpreted-text role="issue"}, contributed by Carl Meyer with editions by Éric Araujo.)