What’s New In Python 3.3 — Python 3.3.7 documentation (original) (raw)

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.

See also

PEP 398 - Python 3.3 Release Schedule

Summary – Release highlights

New syntax features:

New library modules:

New built-in features:

Implementation improvements:

Significantly Improved Library Modules:

Security improvements:

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

PEP 405: Virtual Environments

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 popularvirtualenv third-party package, but benefit from tighter integration with the interpreter core.

This PEP adds the venv module for programmatic access, and thepyvenv 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.

See also

PEP 405 - 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__.pymarker files and can automatically span multiple path segments (inspired by various third party approaches to namespace packages, as described inPEP 420)

See also

PEP 420 - 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

The implementation of PEP 3118 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

API changes

(Contributed by Stefan Krah in issue 10181)

See also

PEP 3118 - Revising the Buffer Protocol

PEP 393: Flexible String Representation

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

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

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

Functionality

Changes introduced by PEP 393 are the following:

Performance and resource usage

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

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

See also

PEP 393 - 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

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 pyapplication. Running py follows the same version selection rules as implicitly launching scripts, but a more specific version can be selected by passing appropriate arguments (such as -3 to request Python 3 when Python 2 is also installed, or -2.6 to specifclly request an earlier Python version when a more recent version is installed).

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

PEP 3151: Reworking the OS and IO exception hierarchy

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, IOError, EnvironmentError,WindowsError, mmap.error, socket.error orselect.error. All these exception types are now only one:OSError. 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 module, you can catch the adequateOSError subclass. The available subclasses are the following:

And the ConnectionError itself has finer-grained subclasses:

Thanks to the new exceptions, common usages of the errno 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 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")

See also

PEP 3151 - Reworking the OS and IO Exception Hierarchy

PEP written and implemented by Antoine Pitrou

PEP 380: Syntax for Delegating to a Subgenerator

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

While designed primarily for use in delegating to a subgenerator, the 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.

See also

PEP 380 - 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 "", line 1, in File "", 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 "", line 6, in getattr KeyError: 'x'

During handling of the above exception, another exception occurred:

Traceback (most recent call last): File "", line 1, in File "", 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',)

See also

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

See also

PEP 414 - Explicit Unicode literals

PEP written by Armin Ronacher.

PEP 3155: Qualified name for classes and functions

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

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

See also

PEP 3155 - Qualified name for classes and functions

PEP written and implemented by Antoine Pitrou.

PEP 412: Key-Sharing Dictionary

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.

See also

PEP 412 - Key-Sharing Dictionary

PEP written and implemented by Mark Shannon.

PEP 362: Function Signature Object

A new function inspect.signature() makes introspection of python callables easy and straightforward. A broad range of callables is supported: python functions, decorated or not, classes, and functools.partial()objects. New classes inspect.Signature, inspect.Parameterand inspect.BoundArguments 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.

See also

PEP 362: - 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 module exposes details specific to the implementation of the currently running interpreter. The initial set of attributes on sys.implementation are name, version,hexversion, and cache_tag.

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

One example of improved standard library portability is cache_tag. As of Python 3.3, sys.implementation.cache_tag is used by importlib to support PEP 3147 compliance. Any Python implementation that usesimportlib 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. In contrast to a mapping-based namespace, like dict, SimpleNamespace is attribute-based, likeobject. However, unlike object, SimpleNamespace instances are writable. This means that you can add, remove, and modify the namespace through normal attribute access.

See also

PEP 421 - Adding sys.implementation

PEP written and implemented by Eric Snow.

Using importlib as the Implementation of Import

issue 2377 - Replace __import__ w/ importlib.__import__issue 13959 - Re-implement parts of imp in pure Pythonissue 14605 - Make import machinery explicitissue 14646 - Require loaders set __loader__ and __package__

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

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

Visible Changes

For potential required changes to code, see the Porting Python codesection.

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

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

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

None is now inserted into sys.path_importer_cache when no finder can be found on sys.path_hooks. Since imp.NullImporter is not directly exposed on sys.path_hooks 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 section of this document.

(Implementation by Brett Cannon)

Other Language Changes

Some smaller changes made to the core Python language are:

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 thePyImport_ImportModuleNoBlock() C API function.

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

(Contributed by Antoine Pitrou in issue 9260.)

Builtin functions and types

New Modules

faulthandler

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

Example of a segmentation fault on Linux:

$ 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 "", line 1 in Segmentation fault

ipaddress

The new ipaddress 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 PEP 3144)

lzma

The newly-added lzma module provides data compression and decompression using the LZMA algorithm, including support for the .xz and .lzmafile formats.

(Contributed by Nadeem Vawda and Per Øyvind Karlsen in issue 6715)

Improved Modules

array

The array module supports the long long type using q andQ type codes.

(Contributed by Oren Tirosh and Hirokazu Yamamoto in issue 1172711)

base64

ASCII-only Unicode strings are now accepted by the decoding functions of thebase64 modern interface. For example, base64.b64decode('YWJj')returns b'abc'. (Contributed by Catalin Iacob in issue 13641.)

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

bz2

The bz2 module has been rewritten from scratch. In the process, several new features have been added:

codecs

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

A new Windows-only codec has been added: cp65001 (issue 13216). It is the Windows code page 65001 (Windows UTF-8, CP_UTF8). For example, it is used by sys.stdout if the console output code page is set to cp65001 (e.g., usingchcp 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.

(issue 12016)

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

$ ./python -q

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.

(issue 12100)

The unicode_internal codec has been deprecated.

collections

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

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

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

contextlib

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

(issue 13585)

crypt

Addition of salt and modular crypt format (hashing method) and the mksalt()function to the crypt module.

(issue 10924)

curses

(Contributed by Iñigo Serna in issue 6755)

datetime

decimal

issue 7652 - 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 http://www.bytereef.org/mpdecimal/quickstart.html.

| | decimal.py | _decimal | speedup | | | ------------- | --------- | ------- | ---- | | pi | 42.02s | 0.345s | 120x | | telco | 172.19s | 5.68s | 30x | | psycopg | 3.57s | 0.29s | 12x |

Features

API changes

email

Policy Framework

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

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

max_line_length The maximum length, excluding the linesep character(s), individual lines may have when a Message is serialized. Defaults to 78.
linesep The character used to separate individual lines when aMessage is serialized. Defaults to \n.
cte_type 7bit or 8bit. 8bit applies only to aBytes 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 Messageobject’s defects list.

A new policy instance, with new settings, is created using theclone() 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 specifylinesep='\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.

ftplib

gc

It is now possible to register callbacks invoked by the garbage collector before and after collection using the new callbacks list.

hmac

A new compare_digest() function has been added to prevent side channel attacks on digests through timing analysis. (Contributed by Nick Coghlan and Christian Heimes in issue 15061)

html

html.parser.HTMLParser is now able to parse broken markup without raising errors, therefore the strict argument of the constructor and theHTMLParseError 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 issue 15114, and issue 14538,issue 13993, issue 13960, issue 13358, issue 1745761,issue 755670, issue 13357, issue 12629, issue 1200313,issue 670664, issue 13273, issue 12888, issue 7311)

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

imaplib

The IMAP4_SSL constructor now accepts an SSLContext parameter to control parameters of the secure channel.

(Contributed by Sijin Joseph in issue 8808)

inspect

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

(Contributed by Meador Inge and Nick Coghlan in issue 13062)

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

(Contributed by Meador Inge in issue 15153)

io

The open() function has a new 'x' mode that can be used to exclusively create a new file, and raise a FileExistsError if the file already exists. It is based on the C11 ‘x’ mode to fopen().

(Contributed by David Townshend in issue 12760)

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

logging

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

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

math

The math module has a new function, log2(), which returns the base-2 logarithm of x.

(Written by Mark Dickinson in issue 11888).

mmap

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

nntplib

The nntplib.NNTP class now supports the context manager protocol to unconditionally consume socket.error 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 issue 9795)

os

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 issue 14210)

pydoc

The Tk GUI and the serve() function have been removed from thepydoc module: pydoc -g and serve() have been deprecated in Python 3.2.

re

str regular expressions now support \u and \U escapes.

(Contributed by Serhiy Storchaka in issue 3665.)

sched

select

Solaris and derivative platforms have a new class select.devpollfor high performance asynchronous sockets via /dev/poll. (Contributed by Jesús Cea Avión in issue 6397.)

shlex

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

shutil

signal

smtpd

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

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

smtplib

The SMTP, SMTP_SSL, andLMTP 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 inissue 11281.)

SMTP now supports the context manager protocol, allowing anSMTP instance to be used in a with statement. (Contributed by Giampaolo Rodolà in issue 11289.)

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

socket

ssl

stat

The undocumented tarfile.filemode function has been moved tostat.filemode(). It can be used to convert a file’s mode to a string of the form ‘-rwxrwxrwx’.

(Contributed by Giampaolo Rodolà in issue 14807)

struct

The struct module now supports ssize_t and size_t via the new codes n and N, respectively. (Contributed by Antoine Pitrou in issue 3163.)

subprocess

Command strings can now be bytes objects on posix platforms. (Contributed by Victor Stinner in issue 8513.)

A new constant DEVNULL allows suppressing output in a platform-independent fashion. (Contributed by Ross Lagerwall inissue 5870.)

tarfile

tarfile now supports lzma encoding via the lzma module. (Contributed by Lars Gustäbel in issue 5689.)

textwrap

The textwrap module has a new indent() that makes it straightforward to add a common prefix to selected lines in a block of text (issue 13857).

time

The PEP 418 added new functions to the time module:

Other new functions:

To improve cross platform consistency, sleep() now raises aValueError 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 class: Read-only proxy of a mapping. (issue 14386)

The new functions types.new_class and types.prepare_class provide support for PEP 3115 compliant dynamic type creation. (issue 14588)

urllib

The Request class, now accepts a method argument used by get_method() to determine what HTTP method should be used. For example, this will send a 'HEAD' request:

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

(issue 1673007)

webbrowser

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

xml.etree.ElementTree

The xml.etree.ElementTree module now imports its C accelerator by default; there is no longer a need to explicitly importxml.etree.cElementTree (this module stays for backwards compatibility, but is now deprecated). In addition, the iter family of methods ofElement 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 makes it possible to distinguish between a properly-formed compressed stream and an incomplete or truncated one. (Contributed by Nadeem Vawda in issue 12646.)

New attribute zlib.ZLIB_RUNTIME_VERSION reports the version string of the underlying zlib library that is loaded at runtime. (Contributed by Torsten Landschoff in issue 12306.)

Optimizations

Major performance enhancements have been added:

Build and C API Changes

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

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

Deprecated features

The array module’s 'u' format code is now deprecated and will be removed in Python 4 together with the rest of the (Py_UNICODE) 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

Porting C code

Building C extensions

Command Line Switch Changes