What's New In Python 2.6

Python 3.0

• development cycle for 2.6/3.0 synchronised
• some backporting done
• python2.6 -3

In cases where new features won’t cause existing code to break, they’ve been backported to 2.6 and are
described in this document in the appropriate place. For example alternate syntax for catching exceptions:
except TypeError as exc

Built-in functions that are new in 3.0 such as bin() have simply been added to Python 2.6, but existing
built-ins haven’t been changed; instead, the future_builtins module has versions with the new 3.0
semantics. Code written to be compatible with 3.0 can do from future_builtins import hex,
map as necessary.
A new command-line switch, -3, enables warnings about features that will be removed in Python 3.0.

The ‘with’ statement

from __future__ import with_statement

In 2.6 the statement no longer needs to be specially
enabled; this means that with is now always a keyword.

The rest of this section is a copy of the corresponding
section from the “What’s New in Python 2.5” document; if
you’re familiar with the ‘with‘ statement from Python
2.5, you can skip this section.


with expression [as variable]:
with-block

The ‘with‘ statement clarifies code that previously would use try...finally blocks to ensure that
clean-up code is executed.

The expression is evaluated, and it should result in an object that supports the context management
protocol (that is, has __enter__() and __exit__() methods.

The object’s __enter__() is called before with-block is executed and therefore can run set-up code.
It also may return a value that is bound to the name variable, if given. (Note carefully that variable
is not assigned the result of expression.)
After execution of the with-block is finished, the object’s __exit__() method is called, even if the
block raised an exception, and can therefore run clean-up code.


with open('/etc/passwd', 'r') as f:
for line in f:
print line
... more processing code ...

Some standard Python objects now support the context management protocol and can be used
with the ‘with‘ statement. File objects are one example:
After this statement has executed, the ﬁle object in f will have been automatically closed, even if
the for loop raised an exception part- way through the block.
Note
In this case, f is the same object created by open(), because file.__enter__() returns self.


lock = threading.Lock()
with lock:
# Critical section of code
...

The threading module’s locks and condition variables also
support the ‘with‘ statement:
The lock is acquired before the block is executed and always released
once the block is complete.


from decimal import Decimal, Context, localcontext

# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
# All code in this block uses a precision of 16 digits.
# The original context is restored on exiting the block.
print v.sqrt()

The new localcontext() function in the decimal
module makes it easy to save and restore the current decimal
context, which encapsulates the desired precision and
rounding characteristics for computations:

Writing Context Managers

• The expression is evaluated and should result in an object called a “context
manager”. The context manager must have __enter__() and __exit__()
methods.
• The context manager’s __enter__() method is called. The value returned is
assigned to VAR. If no 'as VAR' clause is present, the value is simply
discarded.
• The code in BLOCK is executed.
• If BLOCK raises an exception, the __exit__(type, value,
traceback)() is called with the exception details, the same values returned
by sys.exc_info(). The method’s return value controls whether the
exception is re-raised: any false value re-raises the exception, and True will
result in suppressing it. You’ll only rarely want to suppress the exception,
because if you do the author of the code containing the ‘with‘ statement will
never realize anything went wrong.
• If BLOCK didn’t raise an exception, the __exit__() method is still called,
but type, value, and traceback are all None.

Let’s assume there’s an object
representing a database
db_connection = DatabaseConnection() connection. Our goal will be to
with db_connection as cursor: let the user write code like this:

cursor.execute('insert into ...') The transaction should be
cursor.execute('delete from ...') committed if the code in the
block runs ﬂawlessly or rolled
# ... more operations ... back if there’s an exception.
Here’s the basic interface for
class DatabaseConnection: DatabaseConnection that
# Database interface
def cursor (self):
"Returns a cursor object and starts a new transaction"
def commit (self):
"Commits current transaction"
def rollback (self):
"Rolls back current transaction"

class DatabaseConnection:
...
def __enter__ (self):
# Code to start a new transaction
cursor = self.cursor()
return cursor
The __enter__() method is pretty easy, having
def __exit__ (self, type, only to start a new transaction. For this application
value, tb):
the resulting cursor object would be a useful result,
if tb is None: so the method will return it. The user can then add
# No exception, so commit their ‘with‘ statement to bind the
as cursor to
self.commit() cursor to a variable name.
else: The __exit__() method is the most complicated
# Exception occurred, it’s where most of the work has to be done. If
because so rollback.
self.rollback() otherwise no exception, the rolled back.is committed,
there was
the transaction is
transaction

# return False
Execution will just fall off the end of the function,
returning the default value of None. None is false, so
the exception will be re-raised automatically. If you
wished, you could be more explicit and add a
return statement at the marked location.

The contextlib module
from contextlib import contextmanager

@contextmanager
def db_transaction(connection):
cursor = connection.cursor()
try:
yield cursor
except:
contextmanager() lets you write a single
connection.rollback()
generator function instead of deﬁning a new class.
raise
The generator should yield exactly one value.
else:
connection.commit() up to the yield will be executed as the
The code
__enter__() method, and the value yielded will
be the method’s return value that will get bound to
db = DatabaseConnection() variable in the ‘with‘ statement’s as clause, if
the
with db_transaction(db) as cursor:
any.
... The code after the yield will be executed in the
__exit__() method.
Any exception raised in the block will be raised by the
yield statement.

The contextlib module also has a
nested(mgr1, mgr2, ...)()
function that combines a number of context
managers so you don’t need to write nested
‘with‘ statements. In this example, the
single ‘with‘ statement both starts a
database transaction and acquires a thread
lock:

lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
...

Finally, the closing(object)()
function returns object so that it can be
bound to a variable, and calls
object.close at the end of the
block.
import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://python.org')) as f:
for line in f:
sys.stdout.write(line)

Per-user site-packages
Directory

• Unix and Mac OS X: ~/.local/
• Windows: %APPDATA%/Python
• or PYTHONUSERBASE
• or disable entirely with “-s” or PYTHONUSERSITE

Python 2.6 introduces a convention for user-speciﬁc site directories. The
directory varies depending on the platform:
Within this directory, there will be version-speciﬁc subdirectories, such
as lib/python2.6/site-packages on Unix/Mac OS and
Python26/site-packages on Windows.

The new multiprocessing package lets Python
programs create new processes that will perform a
computation and return a result to the parent.

The parent and child processes can communicate using
queues and pipes, synchronize their operations using locks
and semaphores, and can share simple arrays of data.

multiprocessing
The multiprocessing module started out as an exact
emulation of the threading module using processes
instead of threads.
That goal was discarded along the path to Python 2.6, but
the general approach of the module is still similar.
The fundamental class is the Process, which is passed a
callable object and a collection of arguments.
The start() method sets the callable running in a
subprocess, after which you can call the is_alive()
method to check whether the subprocess is still running and
the join() method to wait for the process to exit.

multiprocessing
import time
from multiprocessing import Process, Queue

def factorial(queue, N):
"Compute a factorial."
# If N is a multiple of 4, this function will take much longer.
if (N % 4) == 0:
time.sleep(.05 * N/4)

# Calculate the result The subprocess will calculate a factorial.
fact = 1L
for i in range(1, N+1): A Queue is used to communicate the
fact = fact * i input parameter N and the result.
# Put the result on the queue The Queue object is stored in a global
queue.put(fact) variable.
if __name__ == '__main__': The child process will use the value of the
queue = Queue() variable when the child was created;
because it’s a Queue, parent and child can
N = 5
use the object to communicate.
p = Process(target=factorial, args=(queue, N))
(If the parent were to change the value of
p.start()
p.join() the global variable, the child’s value would
be unaffected, and vice versa.)
result = queue.get()
print 'Factorial', N, '=', result

multiprocessing
The other high-level interface, import time
the Manager class, creates a from multiprocessing import Pool, Manager

separate server process that def factorial(N, dictionary):
can hold master copies of "Compute a factorial."
Python data structures. # Calculate the result
fact = 1L
for i in range(1, N+1):
Other processes can then
fact = fact * i
access and modify these data
structures using proxy objects. # Store result in dictionary
dictionary[N] = fact
The following example
if __name__ == '__main__':
creates a shared dictionary by p = Pool(5)
calling the dict() method; mgr = Manager()
the worker processes then d = mgr.dict() # Create shared dictionary
insert values into the # Run tasks using the pool
dictionary. for N in range(1, 1000, 10):
p.apply_async(factorial, (N, d))
(Locking is not done for you
automatically, which doesn’t # Mark pool as closed -- no more tasks can be added.
p.close()
matter in this example.
Manager‘s methods also # Wait for tasks to exit
p.join()
include Lock(), RLock(),
and Semaphore() to create # Output results
shared locks.) for k, v in sorted(d.items()):
print k, v

multiprocessing

1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...

Advanced String Formatting

>>> "User ID: {0}".format("root")
'User ID: root'

>>> "User ID: {uid} Last seen: {last_login}".format(
... uid="root",
... last_login = "5 Mar 2008 07:20")
'User ID: root Last seen: 5 Mar 2008 07:20'

>>> "Empty dict: {{}}".format()
"Empty dict: {}"

In Python 3.0, the % operator is supplemented by a more powerful string
formatting method, format() which has been backported to Python 2.6.

In 2.6, both 8-bit and Unicode strings have a .format() method that treats the
string as a template and takes the arguments to be formatted. The formatting
template uses curly brackets ({, }) as special characters:
Field names can be integers indicating positional arguments, such as {0},
{1}, etc. or names of keyword arguments.


>>> import sys
>>> print 'Platform: {0.platform}nPython version: '
... '{0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

You can also supply compound ﬁeld names that read attributes or
access dictionary keys:
Note that when using dictionary-style notation such as [.mp4],
you don’t need to put any quotation marks around the string; it
will look up the value using .mp4 as the key. Strings beginning
with a number will be converted to an integer. You can’t write
more complicated expressions inside a format string.


>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration $ 35'
>>> fmt.format('Tutorial', 50)
'Tutorial $ 50'
>>> fmt.format('Banquet', 125)
'Banquet $ 125'

So far we’ve shown how to specify which ﬁeld to
substitute into the resulting string. The precise formatting
used is also controllable by adding a colon followed by a
format speciﬁer. For example:
>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters


The alignment of a Character Effect
ﬁeld within the
desired width can be < (default) Left-align
speciﬁed:
> Right-align

^ Center

(For numeric types only)
= Pad after the sign.

Format speciﬁers can reference
other ﬁelds through nesting:

>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '


>>> '{0:>20}'.format(-1)
' -1'
>>> '{0:<20}'.format(-1)
'-1 '
>>> '{0:=20}'.format(-1)
'- 1'


>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'

Format speciﬁers can also include a
presentation type, which controls
how the value is formatted. For
example, ﬂoating-point numbers can
be formatted as a general number or
in exponential notation:

b Binary. Outputs the number in base 2.
c Character. Converts the integer to the corresponding Unicode character before
printing.
d Decimal Integer. Outputs the number in base 10. Not a complete list

o Octal format. Outputs the number in base 8.

x Hex format. Outputs the number in base 16, using lower-case letters for the
digits above 9.
e Exponent notation. Prints the number in scientific notation using the letter ‘e’
to indicate the exponent.
g General format. This prints the number as a fixed-point number, unless the
number is too large, in which case it switches to ‘e’ exponent notation.
n Number. This is the same as ‘g’ (for floats) or ‘d’ (for integers), except that it
uses the current locale setting to insert the appropriate number separator
characters.
% Percentage. Multiplies the number by 100 and displays in fixed (‘f’) format,
followed by a percent sign.


def __format__(self, format_spec):
if isinstance(format_spec, unicode):
return unicode(str(self))
else:
return str(self)

Classes and types can deﬁne a
__format__() method to
control how they’re formatted. It
receives a single argument, the
format speciﬁer:

There’s also a format() built-in
that will format a single value. It
calls the type’s __format__()
method with the provided
speciﬁer:

>>> format(75.6564, '.2f')
'75.66'

print as a Function

>>> from __future__ import print_function
>>> print('# of entries', len(dictionary),
... file=sys.stderr)

The print statement becomes the print() function in Python 3.0. Making
print() a function makes it possible to replace the function by doing def
print(...) or importing a new function from somewhere else.

Python 2.6 has a __future__ import that removes print as language syntax, letting
you use the functional form instead.
def print(*args, sep=' ', end='n', file=None)
• args: positional arguments whose values will be printed out.
• sep: the separator, which will be printed between arguments.
• end: the ending text, which will be printed after all of the arguments have been output.
• ﬁle: the ﬁle object to which the output will be sent.

Exception-Handling
Changes

try:
...
except TypeError, ValueError: # Wrong!
...

The author is probably trying to catch both TypeError
and ValueError exceptions, but this code actually does
something different: it will catch TypeError and bind the
resulting exception object to the local name
"ValueError". The ValueError exception will not
be caught at all.

Exception-Handling
Changes

try:
...
except (TypeError, ValueError):
...

The correct code speciﬁes a tuple of
exceptions:
This error happens because the use of the
comma here is ambiguous: does it indicate
two different nodes in the parse tree, or a
single node that’s a tuple?

Exception-Handling
Changes

try:
...
except TypeError as exc:
...

Python 3.0 makes this unambiguous by replacing the comma with the
word “as”. To catch an exception and store the exception object in the
variable exc, you must write:
Python 3.0 will only support the use of “as”, and therefore interprets
the ﬁrst example as catching two different exceptions. Python 2.6
supports both the comma and “as”, so existing code will continue to
work. We therefore suggest using “as” when writing new Python code
that will only be executed with 2.6.

Byte Literals

Python 3.0 adopts Unicode as the language’s fundamental string type and denotes 8-
bit literals differently, either as b'string' or using a bytes constructor.

For future compatibility, Python 2.6 adds bytes as a synonym for the str type,
and it also supports the b'' notation.

Byte Literals

The 2.6 str differs from 3.0’s bytes type in various ways; most notably, the
constructor is completely different.
In 3.0, bytes([65, 66, 67]) is 3 elements long, containing the bytes
representing ABC; in 2.6, bytes([65, 66, 67]) returns the 12-byte string
representing the str() of the list.
The primary use of bytes in 2.6 will be to write tests of object type such as
isinstance(x, bytes).
This will help the 2to3 converter, which can’t tell whether 2.x code intends strings to
contain either characters or 8-bit bytes; you can now use either bytes or str to
represent your intention exactly, and the resulting code will also be correct in Python
3.0.

Byte Literals

>>> from __future__ import unicode_literals
>>> s = 'u751fu3080u304eu3000u751fu3054'
>>> s
u'u751fu3080u304eu3000u751fu3054
>>> len(s)
6
There’s also a __future__ import that causes all string literals to become
Unicode strings. This means that u escape sequences can be used to include
Unicode characters:
At the C level, Python 3.0 will rename the existing 8-bit string type, called
PyStringObject in Python 2.x, to PyBytesObject. Python 2.6 uses
#define to support using the names PyBytesObject(),
PyBytes_Check(), PyBytes_FromStringAndSize(), and all the
other functions and macros used with strings.

Byte Literals

>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'u21efu3244', 'utf-8')
>>> b
bytearray(b'xe2x87xafxe3x89x84')
>>> b[0] = 'xe3'
>>> b
bytearray(b'xe3x87xafxe3x89x84')
>>> unicode(str(b), 'utf-8')
u'u31ef u3244'

Instances of the bytes type are
immutable just as strings are. A
new bytearray type stores a
mutable sequence of bytes:

Byte Literals

>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')

Byte arrays support most of the methods of string types, such as
startswith()/endswith(), find()/rfind(), and some of
the methods of lists, such as append(), pop(), and reverse().
There’s also a corresponding C API, with
PyByteArray_FromObject(),
PyByteArray_FromStringAndSize(), and various other
functions.

New I/O Library
Python’s built-in file objects support a number of
methods, but file-like objects don’t necessarily
support all of them. Objects that imitate files
usually support read() and write(), but they
may not support readline(), for example.
Python 3.0 introduces a layered I/O library in the
io module that separates buffering and text-
handling features from the fundamental read and
write operations.

New I/O Library

RawIOBase defines raw I/O operations: read(), readinto(), write(),
seek(), tell(), truncate(), and close().
Most of the methods of this class will often map to a single system call.
There are also readable(), writable(), and seekable() methods for
determining what operations a given object will allow.

Python 3.0 has concrete
implementations of this class for files
and sockets, but Python 2.6 hasn’t
restructured its file and socket objects
in this way.

New I/O Library

BufferedIOBase is an abstract base class that buffers data in memory to reduce
the number of system calls used, making I/O processing more efﬁcient.
It supports all of the methods of RawIOBase, and adds a raw attribute holding the
underlying raw object.
There are ﬁve concrete classes implementing this ABC.
BufferedWriter and BufferedReader are for objects that support write-
only or read-only usage that have a seek() method for random access.
BufferedRandom objects support read and write access upon the same
underlying stream, and BufferedRWPair is for objects such as TTYs that have
both read and write operations acting upon unconnected streams of data.
The BytesIO class supports reading, writing, and seeking over an in-memory
buffer.

New I/O Library

TextIOBase: Provides functions for reading and writing strings (remember,
strings will be Unicode in Python 3.0), and supporting universal newlines.
TextIOBase deﬁnes the readline() method and supports iteration upon
objects.
There are two concrete implementations.
TextIOWrapper wraps a buffered I/O object, supporting all of the methods for
text I/O and adding a buffer attribute for access to the underlying object.
StringIO simply buffers everything in memory without ever writing anything to
disk.
(In Python 2.6, io.StringIO is implemented in pure Python, so it’s pretty slow.
You should therefore stick with cStringIO for now.
In Python 2.6, the underlying implementations haven’t been restructured to build
on top of the io module’s classes. The module is being provided to make it easier
to write code that’s forward-compatible with 3.0, and to save developers the effort
of writing their own implementations of buffering and text I/O.

Revised Buffer Protocol
The buffer protocol is a C-level API that lets Python
types exchange pointers into their internal
representations. A memory-mapped ﬁle can be
viewed as a buffer of characters, for example, and
this lets another module such as re treat memory-
mapped ﬁles as a string of characters to be searched.

Revised Buffer Protocol
The primary users of the buffer protocol are numeric-processing packages such as NumPy,
which expose the internal representation of arrays so that callers can write data directly into an
array instead of going through a slower API. This PEP updates the buffer protocol in light of
experience from NumPy development, adding a number of new features such as indicating the
shape of an array or locking a memory region.
The most important new C API function is PyObject_GetBuffer(PyObject *obj,
Py_buffer *view, int flags), which takes an object and a set of flags, and fills in the
Py_buffer structure with information about the object’s memory representation. Objects can
use this operation to lock memory in place while an external caller could be modifying the
PyObject_GetBuffer(PyObject *obj, Py_buffer *view, *view) to
contents, so there’s a corresponding PyBuffer_Release(Py_buffer
indicate that the external caller is done.
int flags)
The flags argument to PyObject_GetBuffer() specifies constraints upon the memory
returned. Some examples are:
• PyBUF_WRITABLE indicates that the memory must be writable.
• PyBUF_LOCK requests a read-only or exclusive lock on the memory.
• PyBUF_C_CONTIGUOUS and PyBUF_F_CONTIGUOUS requests a C-contiguous (last
dimension varies the fastest) or Fortran-contiguous (first dimension varies the fastest) array
layout.

Two new argument codes for PyArg_ParseTuple(), s* and z*, return locked buffer objects
for a parameter.

Some object-oriented languages such as Java support interfaces, declaring that a class
has a given set of methods or supports a given access protocol. Abstract Base Classes
(or ABCs) are an equivalent feature for Python. The ABC support consists of an abc
module containing a metaclass called ABCMeta, special handling of this metaclass
by the isinstance() and issubclass() built-ins, and a collection of basic
ABCs that the Python developers think will be widely useful. Future versions of
Python will probably add more ABCs.

Let’s say you have a particular class and wish to know whether it supports dictionary-
style access. The phrase “dictionary-style” is vague, however. It probably means that
accessing items with obj[1] works. Does it imply that setting items with obj[2]
= value works? Or that the object will have keys(), values(), and items()
methods? What about the iterative variants such as iterkeys()? copy() and
update()? Iterating over the object with iter()?

Abstract Base Classes

import collections

class Storage(collections.MutableMapping):
...

or:

import collections
The Python 2.6 collections module includes a
number of different ABCs that represent these
class Storage: distinctions. Iterable indicates that a class defines
... __iter__(), and Container means the class
defines a __contains__() method and therefore
supports x in y expressions. The
collections.MutableMapping.register(Storage)basic dictionary
interface of getting items, setting items, and keys(),
values(), and items(), is defined by the
MutableMapping ABC.
You can derive your own classes from a particular ABC
to indicate they support that ABC’s interface:


PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

For classes that you write, deriving from the ABC
is probably clearer. The register() method is
useful when you’ve written a new ABC that can
describe an existing type or class, or if you want
to declare that some third-party class implements
an ABC. For example, if you deﬁned a
PrintableType ABC, it’s legal to do:


def func(d):
if not isinstance(d, collections.MutableMapping):
raise ValueError("Mapping object expected, not %r" % d)

Classes should obey the semantics speciﬁed by an ABC, but Python can’t check this; it’s
up to the class author to understand the ABC’s requirements and to implement the code
accordingly.
To check whether an object supports a particular interface, you can now write:
Don’t feel that you must now begin writing lots of checks as in the above example.
Python has a strong tradition of duck-typing, where explicit type-checking is never done
and code simply calls methods on an object, trusting that those methods will be there and
raising an exception if they aren’t. Be judicious in checking for ABCs and only do it where
it’s absolutely necessary.

from abc import ABCMeta, abstractmethod

class Drawable(): You can write your own ABCs
by using abc.ABCMeta as
__metaclass__ = ABCMeta the metaclass in a class
deﬁnition:
@abstractmethod In the Drawable ABC
def draw(self, x, y, scale=1.0): above, the
pass draw_doubled() method
renders the object at twice its
size and can be implemented
def draw_doubled(self, x, y): in terms of other methods
self.draw(x, y, scale=2.0) described in Drawable.
Classes implementing this
class Square(Drawable): ABC therefore don’t need to
def draw(self, x, y, scale): provide their own
... implementation of
draw_doubled(), though
they can do so.
An implementation of
draw() is necessary, though;
the ABC can’t provide a useful
generic implementation.


>>> class Circle(Drawable):
... pass
...
>>> c = Circle()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle
with abstract methods draw

You can apply the @abstractmethod decorator to
methods such as draw() that must be implemented;
Python will then raise an exception for classes that
don’t deﬁne the method. Note that the exception is
only raised when you actually try to create an
instance of a subclass lacking the method:


from abc import abstractproperty
...

@abstractproperty
def readonly(self):
return self._x

Abstract data attributes can be declared using the
@abstractproperty decorator:
Subclasses must then deﬁne a readonly()
property.

Integer Literals
Python 3.0 changes the syntax for
octal (base-8) integer literals, >>> 0o21, 2*8 + 1
prefixing them with “0o” or “0O” (17, 17)
instead of a leading zero, and adds
support for binary (base-2) integer
>>> 0b101111
literals, signalled by a “0b” or “0B” 47
prefix. >>> oct(42)
'052'
Python 2.6 doesn’t drop support for
a leading 0 signalling an octal
>>> future_builtins.oct(42)
number, but it does add support for '0o52'
“0o” and “0b”: >>> bin(173)
The oct() built-in still returns '0b10101101'
numbers prefixed with a leading >>> int ('0o52', 0)
zero, and a new bin() built-in 42
returns the binary representation for
a number: >>> int('1101', 2)
13
The int() and long() built-ins
will now accept the “0o” and “0b” >>> int('0b1101', 2)
prefixes when base-8 or base-2 are 13
requested, or when the base
argument is zero (signalling that the
base used should be determined
from the string):

Class Decorators

@foo
Decorators have been @bar
extended from functions class A:
to classes. It’s now legal pass
to write:

This is equivalent to:
class A:
pass

A = foo(bar(A))

A Type Hierarchy for
Numbers
Python 3.0 adds several abstract base classes for numeric types inspired by Scheme’s numeric tower.
These classes were backported to 2.6 as the numbers module.

The most general ABC is Number. It defines no operations at all, and only exists to allow checking if
an object is a number by doing isinstance(obj, Number).
Complex is a subclass of Number. Complex numbers can undergo the basic operations of addition,
subtraction, multiplication, division, and exponentiation, and you can retrieve the real and imaginary
numbers.Number
parts and obtain a number’s conjugate. Python’s built-in complex type is an implementation of
Complex.
numbers.Complex(numbers.Number)
Real further derives from Complex, and adds operations that only work on real numbers: floor(),
numbers.Real(numbers.Complex)
trunc(), rounding, taking the remainder mod N, floor division, and comparisons.
Rational numbers derive from Real, have numerator and denominator properties, and can be
numbers.Rational(numbers.Real)
converted to floats. Python 2.6 adds a simple rational-number class, Fraction, in the fractions
module. (It’s called Fraction instead of Rational to avoid a name clash with
numbers.Integral(numbers.Rational)
numbers.Rational.)
Integral numbers derive from Rational, and can be shifted left and right with << and >>,
combined using bitwise operations such as & and |, and can be used as array indexes and slice
boundaries.
In Python 3.0, the PEP slightly redefines the existing built-ins round(), math.floor(),
math.ceil(), and adds a new one, math.trunc(), that’s been backported to Python 2.6.
math.trunc() rounds toward zero, returning the closest Integral that’s between the function’s
argument and zero.

The fractions Module

>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b To ﬁll out the hierarchy of numeric types, the
Fraction(5, 3) fractions module provides a rational-number class.
Rational numbers store their values as a numerator and
denominator forming a fraction, and can exactly represent
numbers such as 2/3 that ﬂoating-point numbers can
only approximate.

The Fraction constructor takes two Integral values
that will be the numerator and denominator of the
resulting fraction.

The fractions Module

>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)

For converting floating-point numbers to rationals, the float type now
has an as_integer_ratio() method that returns the numerator
and denominator for a fraction that evaluates to the same floating-point
value

Note that values that can only be approximated by floating-point
numbers, such as 1./3, are not simplified to the number being
approximated; the fraction attempts to match the floating-point value
exactly.

Other Language Changes

The hasattr() function was catching and ignoring all errors, under the
assumption that they meant a __getattr__() method was failing somehow and
the return value of hasattr() would therefore be False.

This logic shouldn’t be applied to KeyboardInterrupt and SystemExit,
however; Python 2.6 will no longer discard such exceptions when hasattr()
encounters them.

When calling a function using the
>>> def f(**kw): ** syntax to provide keyword
... print sorted(kw) arguments, you are no longer
... required to use a Python
>>> ud=UserDict.UserDict() dictionary; any mapping will now
work:
>>> ud['a'] = 1
>>> ud['b'] = 'string' It’s also become legal to provide
>>> f(**ud) keyword arguments after a *args
['a', 'b'] argument to a function call.
Previously this would have been a
syntax error.
>>> def f(*args, **kw):
... print args, kw
...
>>> f(1,2,3, *(4,5,6), keyword=13)
(1, 2, 3, 4, 5, 6) {'keyword': 13}


A new built-in, next(iterator, [default]) returns the next item from the
speciﬁed iterator.
If the default argument is supplied, it will be returned if iterator has been exhausted;
otherwise, the StopIteration exception will be raised.


>>> t = (0,1,2,3,4,0,1,2)
>>> t.index(3)
3
>>> t.count(0)
2
Tuples now have index()
and count() methods
matching the list type’s
index() and count()
methods:

class C(object):
@property
def x(self):
return self._x
Properties now have @x.setter
three attributes, def x(self, value):
getter, setter
and deleter, that self._x = value
are decorators @x.deleter
providing useful def x(self):
shortcuts for adding a
del self._x
getter, setter or deleter
function to an existing
property. You would class D(C):
use them like this: @C.x.getter
def x(self):
return self._x * 2
@x.setter
def x(self, value):
self._x = value / 2


>>> s = set('1234567890')
>>> s.intersection('abc123', 'cdf246')
set(['2'])
>>> s.difference('246', '789')
set(['1', '0', '3', '5'])

Several methods of the built-in set types now accept
multiple iterables: intersection(),
intersection_update(), union(), update(),
difference() and difference_update().

Other Language Changes “nan”, “-inf”, “+inf” works on any platform with IEEE 754
semantics.
Other functions in the math module, isinf() and isnan(),
return true if their floating-point argument is infinite or Not A
>>> float('nan') Number.
nan Conversion functions were added to convert floating-point
>>> float('-inf') numbers into hexadecimal strings. These functions convert floats to
-inf and from a string representation without introducing rounding
>>> float('+inf') errors from the conversion between decimal and binary. Floats have
a hex() method that returns a string representation, and the
inf float.fromhex() method converts a string back into a number:
>>> a = 3.75
>>> a.hex()
'0x1.e000000000000p+1'
>>> float.fromhex('0x1.e000000000000p+1')
3.75
>>> b=1./3
>>> b.hex()
'0x1.5555555555555p-2'


A numerical nicety: when creating a complex number from two ﬂoats on
systems that support signed zeros (-0 and +0), the complex()
constructor will now preserve the sign of the zero.


Classes that inherit a __hash__() method from a parent class can set __hash__
= None to indicate that the class isn’t hashable.
This will make hash(obj) raise a TypeError and the class will not be indicated
as implementing the Hashable ABC.
You should do this when you’ve deﬁned a __cmp__() or __eq__() method that
compares objects by their value rather than by identity.
All objects have a default hash method that uses id(obj) as the hash value.
There’s no tidy way to remove the __hash__() method inherited from a parent
class, so assigning None was implemented as an override.
At the C level, extensions can set tp_hash to
PyObject_HashNotImplemented().


The string translate() method now accepts None as the translation table
parameter, which is treated as the identity transformation. This makes it easier to
carry out operations that only delete characters.


The built-in dir() function now checks for a __dir__() method on the objects
it receives.
This method must return a list of strings containing the names of valid attributes for
the object, and lets the object control the value that dir() produces.
Objects that have __getattr__() or __getattribute__() methods can use
this to advertise pseudo-attributes they will honor.


Instance method objects have new attributes for the object and
function comprising the method:
im_self → __self__
im_func → __func__.

The old names are
still supported in
Python 2.6, but are
gone in 3.0.


An obscure change: when you use the locals() function inside a class
statement, the resulting dictionary no longer returns free variables. (Free variables,
in this case, are variables referenced in the class statement that aren’t attributes of
the class.)

Modules

The asyncore and asynchat modules are being actively maintained again, and
a number of patches and bugﬁxes were applied.

Modules

The cgi module will now read variables from the query string of an HTTP POST
request. This makes it possible to use form actions with URLs that include query
strings such as “/cgi-bin/add.py?category=1”.
The parse_qs() and parse_qsl() functions have been relocated from the
cgi module to the urlparse module. The versions still available in the cgi
module will trigger PendingDeprecationWarning messages in 2.6

Modules
The cmath module had Five new functions added.
The revisions also improved the numerical soundness of the cmath module. For all
functions, the real and imaginary parts of the results are accurate to within a few units
of least precision (ulps) whenever possible. The branch cuts for asinh(),
atanh(): and atan() have also been corrected.
The tests for the module have been greatly expanded; nearly 2000 new test cases
exercise the algebraic functions.
On IEEE 754 platforms, the cmath module now handles IEEE 754 special values and
ﬂoating-point exceptions in a manner consistent with Annex ‘G’ of the C99 standard.

• polar() converts a complex number to polar form, returning the modulus and
argument of the complex number.
• rect() does the opposite, turning a modulus, argument pair back into the
corresponding complex number.
• phase() returns the argument (also called the angle) of a complex number.
• isnan() returns True if either the real or imaginary part of its argument is a
NaN.
• isinf() returns True if either the real or imaginary part of its argument is
inﬁnite.

Modules
>>> var_type = collections.namedtuple('variable',
... 'id name type size')
>>> var_type._fields
('id', 'name', 'type', 'size')
>>> var = var_type(1, 'frequency', 'int', 4)
>>> print var[0], var.id
1 1
>>> print var[2], var.type
int int
>>> var._asdict()
{'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
>>> v2 = var._replace(name='amplitude')
>>> v2
variable(id=1, name='amplitude', type='int', size=4)

A new data type in the collections module: namedtuple(typename, fieldnames) is a factory function
that creates tuples whose fields are accessible by name as well as index. Names are separated by spaces or commas.
Several places in the standard library that returned tuples have been modified to return namedtuple instances. For
example, the Decimal.as_tuple() method now returns a named tuple with sign, digits, and exponent fields.

Modules

>>> from collections import deque
>>> dq=deque(maxlen=3)
>>> dq
deque([], maxlen=3)
>>> dq.append(1) ; dq.append(2) ; dq.append(3)
>>> dq
deque([1, 2, 3], maxlen=3)
>>> dq.append(4)
>>> dq
deque([2, 3, 4], maxlen=3)

Another change to the collections module is that
the deque type now supports an optional maxlen
parameter; if supplied, the deque’s size will be
restricted to no more than maxlen items. Adding more
items to a full deque causes old items to be discarded.

Modules

>>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
>>> Decimal("2.7182818").ln()
Decimal("0.9999999895305022877376682436")
>>> Decimal(1000).log10()
Decimal("3")

The decimal module was updated to version 1.66 of the
General Decimal Speciﬁcation. New features include some
methods for some basic mathematical functions such as
exp() and log10():
The as_tuple() method of Decimal objects now returns
a named tuple with sign, digits, and exponent ﬁelds.

Modules

The difflib module’s SequenceMatcher class now returns named tuples
representing matches, with a, b, and size attributes.

Modules

An optional timeout parameter, specifying a timeout measured in seconds, was
added to the ftplib.FTP class constructor as well as the connect() method.
Also, the FTP class’s storbinary() and storlines() now take an optional
callback parameter that will be called with each block of data after the data has been
sent.
An optional timeout parameter, specifying a timeout measured in seconds, was
added to the httplib.HTTPConnection and HTTPSConnection class
constructors.

Modules

The reduce() built-in function is also available in the functools module.
In Python 3.0, the built-in has been dropped and reduce() is only available from
functools; currently there are no plans to drop the built-in in the 2.x series.

Modules

When possible, the getpass module will now use /dev/tty to print a prompt
message and read the password, falling back to standard error and standard input.
If the password may be echoed to the terminal, a warning is printed before the
prompt is displayed.

Modules

>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
[1, 2, 3, 5, 8, 9, 16]

A new function in the heapq module, merge(iter1, iter2, ...), takes any
number of iterables returning data in sorted order, and returns a new generator that returns
the contents of all the iterators, also in sorted order. For example:
Another new function, heappushpop(heap, item), pushes item onto heap, then
pops off and returns the smallest item. This is more efﬁcient than making a call to
heappush() and then heappop().
heapq is now implemented to only use less-than comparison, instead of the less-than-or-
equal comparison it previously used. This makes heapq‘s usage of a type match the
list.sort() method.

Modules

>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))

>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5],
... fillvalue=0))
((1, 1), (2, 2), (3, 3), (0, 4), (0, 5))

The itertools module gained several new
functions.
izip_longest(iter1, iter2, ...[,
fillvalue]) makes tuples from each of the
elements; if some of the iterables are shorter than
others, the missing values are set to ﬁllvalue.

Modules
>>> list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
(2, 4), (2, 5), (2, 6),
(3, 4), (3, 5), (3, 6)]

>>> list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
(2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]

>>> list(itertools.product([1,2], [3,4], repeat=2))
[(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
(1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
(2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
(2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
product(iter1, iter2, ..., [repeat=N]) returns the Cartesian product of the supplied
iterables, a set of tuples containing every possible combination of the elements returned from each iterable.
The optional repeat keyword argument is used for taking the product of an iterable or a set of iterables with
themselves, repeated N times. With a single iterable argument, N-tuples are returned:
With two iterables, 2N-tuples are returned.

Modules

>>> list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]

[('1', '2', '3')]

[('1', '2', '3'), ('1', '2', '4'),
('1', '3', '4'), ('2', '3', '4')]

combinations(iterable, r)
returns sub-sequences of length r from the
elements of iterable.

Modules

>>> list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
(2, 1), (2, 3), (2, 4),
(3, 1), (3, 2), (3, 4),
(4, 1), (4, 2), (4, 3)]

permutations(iter[, r]) returns all the
permutations of length r of the iterable’s elements.
If r is not speciﬁed, it will default to the number of
elements produced by the iterable.

Modules

>>> list(itertools.chain.from_iterable([[1,2,3],
... [4,5,6]]))
[1, 2, 3, 4, 5, 6]

itertools.chain(*iterables) is an existing function
in itertools that gained a new constructor in Python 2.6.
itertools.chain.from_iterable(iterable) takes
a single iterable that should return other iterables. chain()
will then return all the elements of the ﬁrst iterable, then all the
elements of the second, and so on.

Modules

The logging module’s FileHandler class and its subclasses
WatchedFileHandler, RotatingFileHandler, and
TimedRotatingFileHandler now have an optional delay parameter to their
constructors. If delay is true, opening of the log file is deferred until the first
emit() call is made.
TimedRotatingFileHandler also has a utc constructor parameter. If the
argument is true, UTC time will be used in determining when midnight occurs and
in generating filenames; otherwise local time will be used.

Modules

Several new functions were added to the math module:
• isinf() and isnan() determine whether a given ﬂoat is a (positive or
negative) inﬁnity or a NaN (Not a Number), respectively.
• copysign() copies the sign bit of an IEEE 754 number, returning the absolute
value of x combined with the sign bit of y. For example, math.copysign(1,
-0.0) returns -1.0.
• factorial() computes the factorial of a number.
• fsum() adds up the stream of numbers from an iterable, and is careful to avoid
loss of precision through using partial sums.
• acosh(), asinh() and atanh() compute the inverse hyperbolic functions.
• log1p() returns the natural logarithm of 1+x (base e).
• trunc() rounds a number toward zero, returning the closest Integral that’s
between the function’s argument and zero. Added as part of the backport of PEP
3141’s type hierarchy for numbers.

Modules

The math module has been improved to give more consistent behaviour across
platforms, especially with respect to handling of ﬂoating-point exceptions and IEEE
754 special values.
Whenever possible, the module follows the recommendations of the C99 standard
about 754’s special values. For example, sqrt(-1.) should now give a
ValueError across almost all platforms, while sqrt(float('NaN')) should
return a NaN on all IEEE 754 platforms. Where Annex ‘F’ of the C99 standard
recommends signaling ‘divide-by-zero’ or ‘invalid’, Python will raise
ValueError. Where Annex ‘F’ of the C99 standard recommends signaling
‘overﬂow’, Python will raise OverflowError.

Modules

>>> replacer = operator.methodcaller('replace', 'old', 'new')
>>> replacer('old wine in old bottles')
'new wine in new bottles'

>>> inst_name = operator.attrgetter('__class__.__name__')
>>> inst_name('')
'str'
>>> inst_name(help)
The operator module gained a methodcaller() function that takes a
'_Helper'
name and an optional set of arguments, returning a callable that will call the
named function on any arguments passed to it. For example:
>>> # Equivalent to lambda s: s.replace('old',
'new')

The attrgetter() function now accepts dotted names and performs the
corresponding attribute lookups:

Modules

• os.fchmod(fd, mode) and os.fchown(fd, uid, gid) change the
mode and ownership of an opened file
• os.lchmod(path, mode) changes the mode of a symlink.
• os.chflags() and os.lchflags() change the flags set on a file/symlink.
• os.closerange(low, high) efficiently closes all file descriptors from
low to high, ignoring any errors and not including high itself.
• os.environ object’s clear() method will now unset the environment
variables using os.unsetenv() in addition to clearing the object’s keys..
• os.walk() now has a followlinks parameter.

The os module now wraps several new system calls.
chflags: Constants for the flag values are defined in the stat module; some possible values include UF_IMMUTABLE
to signal the file may not be changed and UF_APPEND to indicate that data can only be appended to the file.
walk: If set to True, it will follow symlinks pointing to directories and visit the directory’s contents. For backward
compatibility, the parameter’s default value is false. Note that the function can fall into an infinite recursion if there’s a
symlink that points to a parent directory.

Modules

• In the os.path module, the splitext() function has been changed to not
split on leading period characters. This produces better results when operating on
Unix’s dot-ﬁles. For example, os.path.splitext('.ipython') now
returns ('.ipython', '') instead of ('', '.ipython').
• os.path.relpath(path, start='.'), returns a relative path from the
start path, if it’s supplied, or from the current working directory to the
destination path.
• On Windows, os.path.expandvars() will now expand environment
variables given in the form “%var%”, and “~user” will be expanded into the
user’s home directory path.

Modules

Long regular expression searches carried out by the re module will check for
signals being delivered, so time-consuming searches can now be interrupted.
The regular expression module is implemented by compiling bytecodes for a tiny
regex-speciﬁc virtual machine.
Untrusted code could create malicious strings of bytecode directly and cause
crashes, so Python 2.6 includes a veriﬁer for the regex bytecode.

Modules

The sched module’s scheduler instances now have a read-only queue
attribute that returns the contents of the scheduler’s queue, represented as a list of
named tuples with the ﬁelds (time, priority, action, argument).

Modules

The select module now has wrapper functions for the Linux epoll() and BSD
kqueue() system calls. modify() method was added to the existing poll
objects; pollobj.modify(fd, eventmask) takes a file descriptor or file
object and an event mask, modifying the recorded event mask for that file.

Modules

The shutil.copytree() function now has an optional ignore argument that takes a
callable object. This callable will receive each directory path and a list of the directory’s
contents, and returns a list of names that will be ignored, not copied.
The shutil module also provides an ignore_patterns() function for use with
this new parameter. ignore_patterns() takes an arbitrary number of glob-style
patterns and returns a callable that will ignore any ﬁles and directories that match any of
these patterns. The following example copies a directory tree, but skips both .svn
directories and Emacs backup ﬁles, which have names ending with ‘~’:
shutil.copytree('Doc/library', '/tmp/library',
ignore=shutil.ignore_patterns('*~', '.svn'))

Modules
Integrating signal handling with GUI handling event loops like
those used by Tkinter or GTk+ has long been a problem; most
software ends up polling, waking up every fraction of a second
to check if any GUI events have occurred. The signal module
can now make this more efficient. Calling
signal.set_wakeup_fd(fd) sets a file descriptor to be
used; when a signal is received, a byte is written to that file
descriptor. There’s also a C-level function,
PySignal_SetWakeupFd(), for setting the descriptor.
Event loops will use this by opening a pipe to create two
signal.set_wakeup_fd(fd) descriptors, one for reading and one for writing. The writable
descriptor will be passed to set_wakeup_fd(), and the
signal.siginterrupt() readable descriptor will be added to the list of descriptors
monitored by the event loop via select() or poll(). On
signal.setitimer() receiving a signal, a byte will be written and the main event loop
will be woken up, avoiding the need to poll.
signal.getitimer()
The siginterrupt() function is now available from Python
code, and allows changing whether signals can interrupt system
calls or not.
The setitimer() and getitimer() functions have also
been added (where they’re available). setitimer() allows
setting interval timers that will cause a signal to be delivered to
the process after a specified time, measured in wall-clock time,
consumed process time, or combined process+system time.

Modules

The smtplib module now supports SMTP over SSL thanks to the addition of the
SMTP_SSL class. This class supports an interface identical to the existing SMTP
class. Both class constructors also have an optional timeout parameter that
speciﬁes a timeout for the initial connection attempt, measured in seconds.
An implementation of the LMTP protocol (RFC 2033) was also added to the
module. LMTP is used in place of SMTP when transferring e-mail between agents
that don’t manage a mail queue.

Modules

SMTP.starttls() now complies with RFC 3207 and forgets any knowledge
obtained from the server not obtained from the TLS negotiation itself.
The socket module now supports TIPC (http://tipc.sf.net), a high-performance
non-IP-based protocol designed for use in clustered environments. TIPC addresses
are 4- or 5-tuples.
A new function, create_connection(), takes an address and connects to it
using an optional timeout value, returning the connected socket object. This function
also looks up the address’s type and connects to it using IPv4 or IPv6 as appropriate.
Changing your code to use create_connection() instead of
socket(socket.AF_INET, ...) may be all that’s required to make your
code work with IPv6.

Modules

The base classes in the SocketServer module now support calling a
handle_timeout() method after a span of inactivity speciﬁed by the
server’s timeout attribute. The serve_forever() method now takes an
optional poll interval measured in seconds, controlling how often the server will
check for a shutdown request.

Modules

The Popen objects provided by the subprocess module now have
terminate(), kill(), and send_signal() methods.
On Windows, send_signal() only supports the SIGTERM signal, and all
these methods are aliases for the Win32 API function TerminateProcess().

Modules

A new variable in the sys module, float_info, is an object containing
information derived from the float.h ﬁle about the platform’s ﬂoating-point
support.
Attributes of this object include mant_dig (number of digits in the mantissa),
epsilon (smallest difference between 1.0 and the next largest value
representable), and several others.

Modules

Another new variable, dont_write_bytecode, controls whether Python
writes any .pyc or .pyo files on importing a module.
If this variable is true, the compiled files are not written.
The variable is initially set on start-up by supplying the -B switch to the Python
interpreter, or by setting the PYTHONDONTWRITEBYTECODE environment
variable before running the interpreter.
Python code can subsequently change the value of this variable to control whether
bytecode files are written or not.

Modules

Information about the command-line arguments supplied to the Python interpreter is
available by reading attributes of a named tuple available as sys.flags.
For example, the verbose attribute is true if Python was executed in verbose
mode, debug is true in debugging mode, etc.
These attributes are all read-only.

Modules

A new function, getsizeof(), takes a Python object and returns the amount of
memory used by the object, measured in bytes.
Built-in objects return correct results; third-party extensions may not, but can deﬁne
a __sizeof__() method to return the object’s size.

Modules

It’s now possible to determine the current proﬁler and tracer functions by calling
sys.getprofile() and sys.gettrace().

Modules

The tarfile module now supports POSIX.1-2001 (pax) tarfiles in addition to the
POSIX.1-1988 (ustar) and GNU tar formats that were already supported. The default
format is GNU tar; specify the format parameter to open a file using a different
format:
tar = tarfile.open("output.tar", "w",
format=tarfile.PAX_FORMAT)

The new encoding and errors parameters specify an encoding and an error
handling scheme for character conversions. 'strict', 'ignore', and
'replace' are the three standard ways Python can handle errors,; 'utf-8' is a
special value that replaces bad characters with their UTF-8 representation.
(Character conversions occur because the PAX format supports Unicode filenames,
defaulting to UTF-8 encoding.)

Modules

The TarFile.add() method now accepts an exclude argument that’s a
function that can be used to exclude certain filenames from an archive. The function
must take a filename and return true if the file should be excluded or false if it
should be archived. The function is applied to both the name initially passed to
add() and to the names of files in recursively-added directories.

Modules

An optional timeout parameter was added to the telnetlib.Telnet class
constructor, specifying a timeout measured in seconds.

Modules

The tempfile.NamedTemporaryFile class usually deletes the temporary file
it created when the file is closed. This behaviour can now be changed by passing
delete=False to the constructor.
A new class, SpooledTemporaryFile, behaves like a temporary file but stores
its data in memory until a maximum size is exceeded. On reaching that limit, the
contents will be written to an on-disk temporary file.
The NamedTemporaryFile and SpooledTemporaryFile classes both work
as context managers, so you can write

with tempfile.NamedTemporaryFile() as tmp: ....

Modules

The test.test_support module gained a number of context managers useful
for writing tests. EnvironmentVarGuard() is a context manager that
temporarily changes environment variables and automatically restores them to their
old values.
Another context manager, TransientResource, can surround calls to resources
that may or may not be available; it will catch and ignore a speciﬁed list of
exceptions. For example, a network test may ignore certain failures when connecting
to an external web site:
with test_support.TransientResource(IOError,
errno=errno.ETIMEDOUT):
f = urllib.urlopen('https://sf.net')
...

Modules

check_warnings() resets the warning module’s warning ﬁlters and returns an object
that will record all warning messages triggered:
with test_support.check_warnings() as wrec:
warnings.simplefilter("always")
# ... code that triggers a warning ...
assert str(wrec.message) == "function is outdated"
assert len(wrec.warnings) == 1, "Multiple warnings raised"

Modules
>>> S = """This sentence has a bunch of
... extra whitespace."""
>>> print textwrap.fill(S, width=15)
This sentence
has a bunch
of extra
whitespace.
>>> print textwrap.fill(S, drop_whitespace=False, width=15)
This sentence
has a bunch
of extra
whitespace.
>>> The textwrap module can now preserve
existing whitespace at the beginnings and
ends of the newly-created lines by
specifying drop_whitespace=False
as an argument:

Modules

The threading module API is being changed to use properties such as daemon
instead of setDaemon() and isDaemon() methods, and some methods have
been renamed to use underscores instead of camel-case; for example, the
activeCount() method is renamed to active_count().
Both the 2.6 and 3.0 versions of the module support the same properties and
renamed methods, but don’t remove the old methods.
No date has been set for the deprecation of the old APIs in Python 3.x; the old APIs
won’t be removed in any 2.x version.
The threading module’s Thread objects gained an ident property that returns
the thread’s identiﬁer, a nonzero integer.

Modules

>>> u = urllib2.urlopen("http://slow.example.com",
timeout=3)
Traceback (most recent call last):
...
urllib2.URLError: <urlopen error timed out>
>>>

An optional timeout parameter was added to
the urllib.urlopen() function and the
urllib.ftpwrapper class constructor, as
well as the urllib2.urlopen() function. The
parameter speciﬁes a timeout measured in seconds.

The future_builtins module

The functions in this module currently include:
• ascii(obj): equivalent to repr(). In Python 3.0, repr() will return a
Unicode string, while ascii() will return a pure ASCII bytestring.
• filter(predicate, iterable), map(func, iterable1, ...):
the 3.0 versions return iterators, unlike the 2.x built-ins which return lists.
• hex(value), oct(value): instead of calling the __hex__() or
__oct__() methods, these versions will call the __index__() method and
convert the result to hexadecimal or octal. oct() will use the new 0o notation
for its result.

Python 3.0 makes many changes to the repertoire of built-in functions, and most of
the changes can’t be introduced in the Python 2.x series because they would break
compatibility. The future_builtins module provides versions of these built-in
functions that can be imported when writing 3.0-compatible code.

The json module

>>> import json
>>> data = {"spam" : "foo", "parrot" : 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam" : "foo", "parrot" : 42}

The new json module supports the encoding and decoding of Python types in JSON
(Javascript Object Notation). JSON is a lightweight interchange format often used in web
applications. For more information about JSON, see http://www.json.org.

json comes with support for decoding and encoding most built-in Python types. The
following example encodes and decodes a dictionary:
It’s also possible to write your own decoders and encoders to support more types. Pretty-
printing of the JSON strings is also supported.

ctypes Enhancements

• ctypes now supports a c_bool datatype that represents the C99 bool type.
• The ctypes string, buffer and array types have improved support for extended
slicing syntax, where various combinations of (start, stop, step) are
supplied.
• All ctypes data types now support from_buffer() and
from_buffer_copy() methods that create a ctypes instance based on a
provided buffer object. from_buffer_copy() copies the contents of the
object, while from_buffer() will share the same memory area.
• A new calling convention tells ctypes to clear the errno or Win32 LastError
variables at the outset of each wrapped call.

ctypes Enhancements

• You can now retrieve the Unix errno variable after a function call. When
creating a wrapped function, you can supply use_errno=True as a keyword
parameter to the DLL() function and then call the module-level methods
set_errno() and get_errno() to set and retrieve the error value.
• The Win32 LastError variable is similarly supported by the DLL(), OleDLL(),
and WinDLL() functions. You supply use_last_error=True as a
keyword parameter and then call the module-level methods
set_last_error() and get_last_error().
• The byref() function, used to retrieve a pointer to a ctypes instance, now has
an optional offset parameter that is a byte count that will be added to the returned
pointer.

The ssl module

There is a new module, ssl, that’s built atop the OpenSSL library.

This new module provides more control over the protocol negotiated, the X.509
certificates used, and has better support for writing SSL servers (as opposed to
clients) in Python.

The existing SSL support in the socket module hasn’t been removed and
continues to work, though it will be removed in Python 3.0.

To use the new module, you must first create a TCP connection in the usual way and
then pass it to the ssl.wrap_socket() function.
It’s possible to specify whether a certificate is required, and to obtain certificate info
by calling the getpeercert() method.

Deprecations and Removals

• String exceptions have been removed. Attempting to use them raises a
TypeError.
• Changes to the Exception interface as dictated by PEP 352 continue to be
made. For 2.6, the message attribute is being deprecated in favor of the args
attribute.
• (3.0-warning mode) Python 3.0 will feature a reorganized standard library that
will drop many outdated modules and rename others. Python 2.6 running in 3.0-
warning mode will warn about these modules when they are imported.
The list of deprecated modules is: audiodev, bgenlocations,
buildtools, bundlebuilder, Canvas, compiler, dircache, dl,
fpformat, gensuitemodule, ihooks, imageop, imgfile,
linuxaudiodev, mhlib, mimetools, multifile, new, pure,
statvfs, sunaudiodev, test.testall, and toaiff.

Deprecations and Removals

• The gopherlib module has been removed.
• The MimeWriter module and mimify module have been deprecated; use the
email package instead.
• The md5 module has been deprecated; use the hashlib module instead.
• The posixfile module has been deprecated; fcntl.lockf() provides
better locking.
• The popen2 module has been deprecated; use the subprocess module.
• The rgbimg module has been removed.
• The sets module has been deprecated; it’s better to use the built-in set and
frozenset types.
• The sha module has been deprecated; use the hashlib module instead.

Porting to Python 2.6

• Classes that aren’t supposed to be hashable should set __hash__ = None in
their deﬁnitions to indicate the fact.
• String exceptions have been removed. Attempting to use them raises a
TypeError.
• The __init__() method of collections.deque now clears any existing
contents of the deque before adding elements from the iterable. This change
makes the behavior match list.__init__().
• object.__init__() previously accepted arbitrary arguments and keyword
arguments, ignoring them. In Python 2.6, this is no longer allowed and will
result in a TypeError. This will affect __init__() methods that end up
calling the corresponding method on object (perhaps through using
super()).


The Decimal constructor now accepts leading and trailing whitespace when
passed a string. Previously it would raise an InvalidOperation exception.
On the other hand, the create_decimal() method of Context objects
now explicitly disallows extra whitespace, raising a ConversionSyntax
exception.
• Due to an implementation accident, if you passed a file path to the built-in
__import__() function, it would actually import the specified file. This was
never intended to work, however, and the implementation now explicitly checks
for this case and raises an ImportError.
• C API: the PyImport_Import() and PyImport_ImportModule()
functions now default to absolute imports, not relative imports. This will affect C
extensions that import other modules.


• C API: extension data types that shouldn’t be hashable should deﬁne their
tp_hash slot to PyObject_HashNotImplemented().
• The socket module exception socket.error now inherits from IOError.
Previously it wasn’t a subclass of StandardError but now it is, through
IOError.
• The xmlrpclib module no longer automatically converts datetime.date
and datetime.time to the xmlrpclib.DateTime type; the conversion
semantics were not necessarily correct for all applications. Code using
xmlrpclib should convert date and time instances.
• (3.0-warning mode) The Exception class now warns when accessed using
slicing or index access; having Exception behave like a tuple is being phased
out.


• (3.0-warning mode) inequality comparisons between two dictionaries or two
objects that don’t implement comparison methods are reported as warnings.
dict1 == dict2 still works, but dict1 < dict2 is being phased out.
Comparisons between cells, which are an implementation detail of Python’s
scoping rules, also cause warnings because such comparisons are forbidden
entirely in 3.0.

What's New In Python 2.6

More Related Content

What's hot (20)

Similar to What's New In Python 2.6 (20)

More from Richard Jones (11)

Recently uploaded (20)

What's New In Python 2.6