FCL/sf/adapt/qemu: comparison symbian-qemu-0.9.1-12/python-2.6.1/Doc/whatsnew/2.6.rst

equal deleted inserted replaced

-:ffa851df0825
+:2fb8b9db1c86
+****************************
+What's New in Python 2.6
+****************************
+.. XXX add trademark info for Apple, Microsoft, SourceForge.
+:Author: A.M. Kuchling (amk at amk.ca)
+:Release: |release|
+:Date: |today|
+.. $Id: 2.6.rst 67146 2008-11-07 08:56:27Z georg.brandl $
+Rules for maintenance:
+* Anyone can add text to this document.  Do not spend very much time
+on the wording of your changes, because your text will probably
+get rewritten to some degree.
+* The maintainer will go through Misc/NEWS periodically and add
+changes; it's therefore more important to add your changes to
+Misc/NEWS than to this file.
+* This is not a complete list of every single change; completeness
+is the purpose of Misc/NEWS.  Some changes I consider too small
+or esoteric to include.  If such a change is added to the text,
+I'll just remove it.  (This is another reason you shouldn't spend
+too much time on writing your addition.)
+* If you want to draw your new text to the attention of the
+maintainer, add 'XXX' to the beginning of the paragraph or
+section.
+* It's OK to just add a fragmentary note about a change.  For
+example: "XXX Describe the transmogrify() function added to the
+socket module."  The maintainer will research the change and
+write the necessary text.
+* You can comment out your additions if you like, but it's not
+necessary (especially when a final release is some months away).
+* Credit the author of a patch or bugfix.   Just the name is
+sufficient; the e-mail address isn't necessary.
+* It's helpful to add the bug/patch number in a parenthetical comment.
+XXX Describe the transmogrify() function added to the socket
+module.
+(Contributed by P.Y. Developer; :issue:`12345`.)
+This saves the maintainer some effort going through the SVN logs
+when researching a change.
+This article explains the new features in Python 2.6, released on October 1
+2008.  The release schedule is described in :pep:`361`.
+The major theme of Python 2.6 is preparing the migration path to
+Python 3.0, a major redesign of the language.  Whenever possible,
+Python 2.6 incorporates new features and syntax from 3.0 while
+remaining compatible with existing code by not removing older features
+or syntax.  When it's not possible to do that, Python 2.6 tries to do
+what it can, adding compatibility functions in a
+:mod:`future_builtins` module and a :option:`-3` switch to warn about
+usages that will become unsupported in 3.0.
+Some significant new packages have been added to the standard library,
+such as the :mod:`multiprocessing` and :mod:`json` modules, but
+there aren't many new features that aren't related to Python 3.0 in
+some way.
+Python 2.6 also sees a number of improvements and bugfixes throughout
+the source.  A search through the change logs finds there were 259
+patches applied and 612 bugs fixed between Python 2.5 and 2.6.  Both
+figures are likely to be underestimates.
+This article doesn't attempt to provide a complete specification of
+the new features, but instead provides a convenient overview.  For
+full details, you should refer to the documentation for Python 2.6. If
+you want to understand the rationale for the design and
+implementation, refer to the PEP for a particular new feature.
+Whenever possible, "What's New in Python" links to the bug/patch item
+for each change.
+.. Compare with previous release in 2 - 3 sentences here.
+add hyperlink when the documentation becomes available online.
+.. ========================================================================
+.. Large, PEP-level features and changes should be described here.
+.. Should there be a new section here for 3k migration?
+.. Or perhaps a more general section describing module changes/deprecation?
+.. ========================================================================
+Python 3.0
+================
+The development cycle for Python versions 2.6 and 3.0 was
+synchronized, with the alpha and beta releases for both versions being
+made on the same days.  The development of 3.0 has influenced many
+features in 2.6.
+Python 3.0 is a far-ranging redesign of Python that breaks
+compatibility with the 2.x series.  This means that existing Python
+code will need some conversion in order to run on
+Python 3.0.  However, not all the changes in 3.0 necessarily break
+compatibility.  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.  Some of the 3.0-derived features
+are:
+* A :meth:`__complex__` method for converting objects to a complex number.
+* Alternate syntax for catching exceptions: ``except TypeError as exc``.
+* The addition of :func:`functools.reduce` as a synonym for the built-in
+:func:`reduce` function.
+Python 3.0 adds several new built-in functions and changes the
+semantics of some existing built-ins.  Functions that are new in 3.0
+such as :func:`bin` have simply been added to Python 2.6, but existing
+built-ins haven't been changed; instead, the :mod:`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, :option:`-3`, enables warnings
+about features that will be removed in Python 3.0.  You can run code
+with this switch to see how much work will be necessary to port
+code to 3.0.  The value of this switch is available
+to Python code as the boolean variable :data:`sys.py3kwarning`,
+and to C extension code as :cdata:`Py_Py3kWarningFlag`.
+.. seealso::
+The 3xxx series of PEPs, which contains proposals for Python 3.0.
+:pep:`3000` describes the development process for Python 3.0.
+Start with :pep:`3100` that describes the general goals for Python
+3.0, and then explore the higher-numbered PEPS that propose
+specific features.
+Changes to the Development Process
+==================================================
+While 2.6 was being developed, the Python development process
+underwent two significant changes: we switched from SourceForge's
+issue tracker to a customized Roundup installation, and the
+documentation was converted from LaTeX to reStructuredText.
+New Issue Tracker: Roundup
+--------------------------------------------------
+For a long time, the Python developers had been growing increasingly
+annoyed by SourceForge's bug tracker.  SourceForge's hosted solution
+doesn't permit much customization; for example, it wasn't possible to
+customize the life cycle of issues.
+The infrastructure committee of the Python Software Foundation
+therefore posted a call for issue trackers, asking volunteers to set
+up different products and import some of the bugs and patches from
+SourceForge.  Four different trackers were examined: `Jira
+<http://www.atlassian.com/software/jira/>`__,
+`Launchpad <http://www.launchpad.net>`__,
+`Roundup <http://roundup.sourceforge.net/>`__, and
+`Trac <http://trac.edgewall.org/>`__.
+The committee eventually settled on Jira
+and Roundup as the two candidates.  Jira is a commercial product that
+offers no-cost hosted instances to free-software projects; Roundup
+is an open-source project that requires volunteers
+to administer it and a server to host it.
+After posting a call for volunteers, a new Roundup installation was
+set up at http://bugs.python.org.  One installation of Roundup can
+host multiple trackers, and this server now also hosts issue trackers
+for Jython and for the Python web site.  It will surely find
+other uses in the future.  Where possible,
+this edition of "What's New in Python" links to the bug/patch
+item for each change.
+Hosting of the Python bug tracker is kindly provided by
+`Upfront Systems <http://www.upfrontsystems.co.za/>`__
+of Stellenbosch, South Africa.  Martin von Loewis put a
+lot of effort into importing existing bugs and patches from
+SourceForge; his scripts for this import operation are at
+http://svn.python.org/view/tracker/importer/ and may be useful to
+other projects wishing to move from SourceForge to Roundup.
+.. seealso::
+http://bugs.python.org
+The Python bug tracker.
+http://bugs.jython.org:
+The Jython bug tracker.
+http://roundup.sourceforge.net/
+Roundup downloads and documentation.
+http://svn.python.org/view/tracker/importer/
+Martin von Loewis's conversion scripts.
+New Documentation Format: reStructuredText Using Sphinx
+-----------------------------------------------------------
+The Python documentation was written using LaTeX since the project
+started around 1989.  In the 1980s and early 1990s, most documentation
+was printed out for later study, not viewed online. LaTeX was widely
+used because it provided attractive printed output while remaining
+straightforward to write once the basic rules of the markup were
+learned.
+Today LaTeX is still used for writing publications destined for
+printing, but the landscape for programming tools has shifted.  We no
+longer print out reams of documentation; instead, we browse through it
+online and HTML has become the most important format to support.
+Unfortunately, converting LaTeX to HTML is fairly complicated and Fred
+L. Drake Jr., the long-time Python documentation editor, spent a lot
+of time maintaining the conversion process.  Occasionally people would
+suggest converting the documentation into SGML and later XML, but
+performing a good conversion is a major task and no one ever committed
+the time required to finish the job.
+During the 2.6 development cycle, Georg Brandl put a lot of effort
+into building a new toolchain for processing the documentation.  The
+resulting package is called Sphinx, and is available from
+http://sphinx.pocoo.org/.
+Sphinx concentrates on HTML output, producing attractively styled and
+modern HTML; printed output is still supported through conversion to
+LaTeX.  The input format is reStructuredText, a markup syntax
+supporting custom extensions and directives that is commonly used in
+the Python community.
+Sphinx is a standalone package that can be used for writing, and
+almost two dozen other projects
+(`listed on the Sphinx web site <http://sphinx.pocoo.org/examples.html>`__)
+have adopted Sphinx as their documentation tool.
+.. seealso::
+:ref:`documenting-index`
+Describes how to write for Python's documentation.
+`Sphinx <http://sphinx.pocoo.org/>`__
+Documentation and code for the Sphinx toolchain.
+`Docutils <http://docutils.sf.net>`__
+The underlying reStructuredText parser and toolset.
+PEP 343: The 'with' statement
+=============================
+The previous version, Python 2.5, added the ':keyword:`with`'
+statement as an optional feature, to be enabled by a ``from __future__
+import with_statement`` directive.  In 2.6 the statement no longer needs to
+be specially enabled; this means that :keyword:`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 ':keyword:`with`' statement
+from Python 2.5, you can skip this section.
+The ':keyword:`with`' statement clarifies code that previously would use
+``try...finally`` blocks to ensure that clean-up code is executed.  In this
+section, I'll discuss the statement as it will commonly be used.  In the next
+section, I'll examine the implementation details and show how to write objects
+for use with this statement.
+The ':keyword:`with`' statement is a control-flow structure whose basic
+structure is::
+with expression [as variable]:
+with-block
+The expression is evaluated, and it should result in an object that supports the
+context management protocol (that is, has :meth:`__enter__` and :meth:`__exit__`
+methods.
+The object's :meth:`__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 :meth:`__exit__`
+method is called, even if the block raised an exception, and can therefore run
+clean-up code.
+Some standard Python objects now support the context management protocol and can
+be used with the ':keyword:`with`' statement. File objects are one example::
+with open('/etc/passwd', 'r') as f:
+for line in f:
+print line
+... more processing code ...
+After this statement has executed, the file object in *f* will have been
+automatically closed, even if the :keyword:`for` loop raised an exception part-
+way through the block.
+.. note::
+In this case, *f* is the same object created by :func:`open`, because
+:meth:`file.__enter__` returns *self*.
+The :mod:`threading` module's locks and condition variables  also support the
+':keyword:`with`' statement::
+lock = threading.Lock()
+with lock:
+# Critical section of code
+...
+The lock is acquired before the block is executed and always released once  the
+block is complete.
+The :func:`localcontext` function in the :mod:`decimal` module makes it easy
+to save and restore the current decimal context, which encapsulates the desired
+precision and rounding characteristics for computations::
+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()
+.. _new-26-context-managers:
+Writing Context Managers
+------------------------
+Under the hood, the ':keyword:`with`' statement is fairly complicated. Most
+people will only use ':keyword:`with`' in company with existing objects and
+don't need to know these details, so you can skip the rest of this section if
+you like.  Authors of new objects will need to understand the details of the
+underlying implementation and should keep reading.
+A high-level explanation of the context management protocol is:
+* The expression is evaluated and should result in an object called a "context
+manager".  The context manager must have :meth:`__enter__` and :meth:`__exit__`
+methods.
+* The context manager's :meth:`__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 :meth:`__exit__(type, value, traceback)`
+is called with the exception details, the same values returned by
+:func:`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 ':keyword:`with`' statement will
+never realize anything went wrong.
+* If *BLOCK* didn't raise an exception,  the :meth:`__exit__` method is still
+called, but *type*, *value*, and *traceback* are all ``None``.
+Let's think through an example.  I won't present detailed code but will only
+sketch the methods necessary for a database that supports transactions.
+(For people unfamiliar with database terminology: a set of changes to the
+database are grouped into a transaction.  Transactions can be either committed,
+meaning that all the changes are written into the database, or rolled back,
+meaning that the changes are all discarded and the database is unchanged.  See
+any database textbook for more information.)
+Let's assume there's an object representing a database connection. Our goal will
+be to let the user write code like this::
+db_connection = DatabaseConnection()
+with db_connection as cursor:
+cursor.execute('insert into ...')
+cursor.execute('delete from ...')
+# ... more operations ...
+The transaction should be committed if the code in the block runs flawlessly or
+rolled back if there's an exception. Here's the basic interface for
+:class:`DatabaseConnection` that I'll assume::
+class DatabaseConnection:
+# 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"
+The :meth:`__enter__` method is pretty easy, having only to start a new
+transaction.  For this application the resulting cursor object would be a useful
+result, so the method will return it.  The user can then add ``as cursor`` to
+their ':keyword:`with`' statement to bind the cursor to a variable name. ::
+class DatabaseConnection:
+...
+def __enter__(self):
+# Code to start a new transaction
+cursor = self.cursor()
+return cursor
+The :meth:`__exit__` method is the most complicated because it's where most of
+the work has to be done.  The method has to check if an exception occurred.  If
+there was no exception, the transaction is committed.  The transaction is rolled
+back if there was an exception.
+In the code below, 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 :keyword:`return` statement at the marked location. ::
+class DatabaseConnection:
+...
+def __exit__(self, type, value, tb):
+if tb is None:
+# No exception, so commit
+self.commit()
+else:
+# Exception occurred, so rollback.
+self.rollback()
+# return False
+.. _module-contextlib:
+The contextlib module
+---------------------
+The :mod:`contextlib` module provides some functions and a decorator that
+are useful when writing objects for use with the ':keyword:`with`' statement.
+The decorator is called :func:`contextmanager`, and lets you write a single
+generator function instead of defining a new class.  The generator should yield
+exactly one value.  The code up to the :keyword:`yield` will be executed as the
+:meth:`__enter__` method, and the value yielded will be the method's return
+value that will get bound to the variable in the ':keyword:`with`' statement's
+:keyword:`as` clause, if any.  The code after the :keyword:`yield` will be
+executed in the :meth:`__exit__` method.  Any exception raised in the block will
+be raised by the :keyword:`yield` statement.
+Using this decorator, our database example from the previous section
+could be written as::
+from contextlib import contextmanager
+@contextmanager
+def db_transaction(connection):
+cursor = connection.cursor()
+try:
+yield cursor
+except:
+connection.rollback()
+raise
+else:
+connection.commit()
+db = DatabaseConnection()
+with db_transaction(db) as cursor:
+...
+The :mod:`contextlib` module also has a :func:`nested(mgr1, mgr2, ...)` function
+that combines a number of context managers so you don't need to write nested
+':keyword:`with`' statements.  In this example, the single ':keyword:`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 :func:`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://www.yahoo.com')) as f:
+for line in f:
+sys.stdout.write(line)
+.. seealso::
+:pep:`343` - The "with" statement
+PEP written by Guido van Rossum and Nick Coghlan; implemented by Mike Bland,
+Guido van Rossum, and Neal Norwitz.  The PEP shows the code generated for a
+':keyword:`with`' statement, which can be helpful in learning how the statement
+works.
+The documentation  for the :mod:`contextlib` module.
+.. ======================================================================
+.. _pep-0366:
+PEP 366: Explicit Relative Imports From a Main Module
+============================================================
+Python's :option:`-m` switch allows running a module as a script.
+When you ran a module that was located inside a package, relative
+imports didn't work correctly.
+The fix for Python 2.6 adds a :attr:`__package__` attribute to
+modules.  When this attribute is present, relative imports will be
+relative to the value of this attribute instead of the
+:attr:`__name__` attribute.
+PEP 302-style importers can then set :attr:`__package__` as necessary.
+The :mod:`runpy` module that implements the :option:`-m` switch now
+does this, so relative imports will now work correctly in scripts
+running from inside a package.
+.. ======================================================================
+.. _pep-0370:
+PEP 370: Per-user ``site-packages`` Directory
+=====================================================
+When you run Python, the module search path ``sys.path`` usually
+includes a directory whose path ends in ``"site-packages"``.  This
+directory is intended to hold locally-installed packages available to
+all users using a machine or a particular site installation.
+Python 2.6 introduces a convention for user-specific site directories.
+The directory varies depending on the platform:
+* Unix and Mac OS X: :file:`~/.local/`
+* Windows: :file:`%APPDATA%/Python`
+Within this directory, there will be version-specific subdirectories,
+such as :file:`lib/python2.6/site-packages` on Unix/Mac OS and
+:file:`Python26/site-packages` on Windows.
+If you don't like the default directory, it can be overridden by an
+environment variable.  :envvar:`PYTHONUSERBASE` sets the root
+directory used for all Python versions supporting this feature.  On
+Windows, the directory for application-specific data can be changed by
+setting the :envvar:`APPDATA` environment variable.  You can also
+modify the :file:`site.py` file for your Python installation.
+The feature can be disabled entirely by running Python with the
+:option:`-s` option or setting the :envvar:`PYTHONNOUSERSITE`
+environment variable.
+.. seealso::
+:pep:`370` - Per-user ``site-packages`` Directory
+PEP written and implemented by Christian Heimes.
+.. ======================================================================
+.. _pep-0371:
+PEP 371: The ``multiprocessing`` Package
+=====================================================
+The new :mod:`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.
+The :mod:`multiprocessing` module started out as an exact emulation of
+the :mod:`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 :class:`Process`, which is passed a callable object and
+a collection of arguments.  The :meth:`start` method
+sets the callable running in a subprocess, after which you can call
+the :meth:`is_alive` method to check whether the subprocess is still running
+and the :meth:`join` method to wait for the process to exit.
+Here's a simple example where the subprocess will calculate a
+factorial.  The function doing the calculation is written strangely so
+that it takes significantly longer when the input argument is a
+multiple of 4.
+::
+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
+	fact = 1L
+	for i in range(1, N+1):
+	    fact = fact * i
+	# Put the result on the queue
+	queue.put(fact)
+if __name__ == '__main__':
+	queue = Queue()
+	N = 5
+	p = Process(target=factorial, args=(queue, N))
+	p.start()
+	p.join()
+	result = queue.get()
+	print 'Factorial', N, '=', result
+A :class:`Queue` is used to communicate the input parameter *N* and
+the result.  The :class:`Queue` object is stored in a global variable.
+The child process will use the value of the variable when the child
+was created; because it's a :class:`Queue`, parent and child can use
+the object to communicate.  (If the parent were to change the value of
+the global variable, the child's value would be unaffected, and vice
+versa.)
+Two other classes, :class:`Pool` and :class:`Manager`, provide
+higher-level interfaces.  :class:`Pool` will create a fixed number of
+worker processes, and requests can then be distributed to the workers
+by calling :meth:`apply` or :meth:`apply_async` to add a single request,
+and :meth:`map` or :meth:`map_async` to add a number of
+requests.  The following code uses a :class:`Pool` to spread requests
+across 5 worker processes and retrieve a list of results::
+from multiprocessing import Pool
+def factorial(N, dictionary):
+	"Compute a factorial."
+	...
+p = Pool(5)
+result = p.map(factorial, range(1, 1000, 10))
+for v in result:
+	print v
+This produces the following output::
+1
+39916800
+51090942171709440000
+8222838654177922817725562880000000
+33452526613163807108170062053440751665152000000000
+...
+The other high-level interface, the :class:`Manager` class, creates a
+separate server process that can hold master copies of Python data
+structures.  Other processes can then access and modify these data
+structures using proxy objects.  The following example creates a
+shared dictionary by calling the :meth:`dict` method; the worker
+processes then insert values into the dictionary.  (Locking is not
+done for you automatically, which doesn't matter in this example.
+:class:`Manager`'s methods also include :meth:`Lock`, :meth:`RLock`,
+and :meth:`Semaphore` to create shared locks.)
+::
+import time
+from multiprocessing import Pool, Manager
+def factorial(N, dictionary):
+"Compute a factorial."
+# Calculate the result
+fact = 1L
+for i in range(1, N+1):
+fact = fact * i
+# Store result in dictionary
+dictionary[N] = fact
+if __name__ == '__main__':
+p = Pool(5)
+mgr = Manager()
+d = mgr.dict()         # Create shared dictionary
+# Run tasks using the pool
+for N in range(1, 1000, 10):
+p.apply_async(factorial, (N, d))
+# Mark pool as closed -- no more tasks can be added.
+p.close()
+# Wait for tasks to exit
+p.join()
+# Output results
+for k, v in sorted(d.items()):
+print k, v
+This will produce the output::
+1 1
+11 39916800
+21 51090942171709440000
+31 8222838654177922817725562880000000
+41 33452526613163807108170062053440751665152000000000
+51 15511187532873822802242430164693032110632597200169861120000...
+.. seealso::
+The documentation for the :mod:`multiprocessing` module.
+:pep:`371` - Addition of the multiprocessing package
+PEP written by Jesse Noller and Richard Oudkerk;
+implemented by Richard Oudkerk and Jesse Noller.
+.. ======================================================================
+.. _pep-3101:
+PEP 3101: Advanced String Formatting
+=====================================================
+In Python 3.0, the `%` operator is supplemented by a more powerful string
+formatting method, :meth:`format`.  Support for the :meth:`str.format` method
+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::
+>>> # Substitute positional argument 0 into the string.
+>>> "User ID: {0}".format("root")
+'User ID: root'
+>>> # Use the named keyword arguments
+>>> "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'
+Curly brackets can be escaped by doubling them::
+>>> format("Empty dict: {{}}")
+"Empty dict: {}"
+Field names can be integers indicating positional arguments, such as
+``{0}``, ``{1}``, etc. or names of keyword arguments.  You can also
+supply compound field names that read attributes or access dictionary keys::
+>>> 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'
+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.
+So far we've shown how to specify which field to substitute into the
+resulting string.  The precise formatting used is also controllable by
+adding a colon followed by a format specifier.  For example::
+>>> # Field 0: left justify, pad to 15 characters
+>>> # Field 1: right justify, pad to 6 characters
+>>> fmt = '{0:15} ${1:>6}'
+>>> fmt.format('Registration', 35)
+'Registration    $    35'
+>>> fmt.format('Tutorial', 50)
+'Tutorial        $    50'
+>>> fmt.format('Banquet', 125)
+'Banquet         $   125'
+Format specifiers can reference other fields through nesting::
+>>> fmt = '{0:{1}}'
+>>> width = 15
+>>> fmt.format('Invoice #1234', width)
+'Invoice #1234  '
+>>> width = 35
+>>> fmt.format('Invoice #1234', width)
+'Invoice #1234                      '
+The alignment of a field within the desired width can be specified:
+================ ============================================
+Character        Effect
+================ ============================================
+< (default)      Left-align
+>                Right-align
+^                Center
+=                (For numeric types only) Pad after the sign.
+================ ============================================
+Format specifiers can also include a presentation type, which
+controls how the value is formatted.  For example, floating-point numbers
+can be formatted as a general number or in exponential notation::
+>>> '{0:g}'.format(3.75)
+'3.75'
+>>> '{0:e}'.format(3.75)
+'3.750000e+00'
+A variety of presentation types are available.  Consult the 2.6
+documentation for a :ref:`complete list <formatstrings>`; here's a sample:
+===== ========================================================================
+``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.
+``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.
+===== ========================================================================
+Classes and types can define a :meth:`__format__` method to control how they're
+formatted.  It receives a single argument, the format specifier::
+def __format__(self, format_spec):
+if isinstance(format_spec, unicode):
+return unicode(str(self))
+else:
+return str(self)
+There's also a :func:`format` built-in that will format a single
+value.  It calls the type's :meth:`__format__` method with the
+provided specifier::
+>>> format(75.6564, '.2f')
+'75.66'
+.. seealso::
+:ref:`formatstrings`
+The reference documentation for format fields.
+:pep:`3101` - Advanced String Formatting
+PEP written by Talin. Implemented by Eric Smith.
+.. ======================================================================
+.. _pep-3105:
+PEP 3105: ``print`` As a Function
+=====================================================
+The ``print`` statement becomes the :func:`print` function in Python 3.0.
+Making :func:`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.  For example::
+>>> from __future__ import print_function
+>>> print('# of entries', len(dictionary), file=sys.stderr)
+The signature of the new function is::
+def print(*args, sep=' ', end='\n', file=None)
+The parameters are:
+* *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.
+* *file*: the file object to which the output will be sent.
+.. seealso::
+:pep:`3105` - Make print a function
+PEP written by Georg Brandl.
+.. ======================================================================
+.. _pep-3110:
+PEP 3110: Exception-Handling Changes
+=====================================================
+One error that Python programmers occasionally make
+is writing the following code::
+try:
+...
+except TypeError, ValueError:  # Wrong!
+...
+The author is probably trying to catch both :exc:`TypeError` and
+:exc:`ValueError` exceptions, but this code actually does something
+different: it will catch :exc:`TypeError` and bind the resulting
+exception object to the local name ``"ValueError"``.  The
+:exc:`ValueError` exception will not be caught at all.  The correct
+code specifies a tuple of exceptions::
+try:
+...
+except (TypeError, ValueError):
+...
+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?
+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::
+try:
+...
+except TypeError as exc:
+...
+Python 3.0 will only support the use of "as", and therefore interprets
+the first 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.
+.. seealso::
+:pep:`3110` - Catching Exceptions in Python 3000
+PEP written and implemented by Collin Winter.
+.. ======================================================================
+.. _pep-3112:
+PEP 3112: 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 :class:`bytes` constructor.  For future compatibility,
+Python 2.6 adds :class:`bytes` as a synonym for the :class:`str` type,
+and it also supports the ``b''`` notation.
+The 2.6 :class:`str` differs from 3.0's :class:`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 :func:`str` of the list.
+The primary use of :class:`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 :class:`bytes` or :class:`str` to represent your intention
+exactly, and the resulting code will also be correct in Python 3.0.
+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::
+from __future__ import unicode_literals
+s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
+'\u3081\u3000\u751f\u305f\u307e\u3054')
+print len(s)               # 12 Unicode characters
+At the C level, Python 3.0 will rename the existing 8-bit
+string type, called :ctype:`PyStringObject` in Python 2.x,
+to :ctype:`PyBytesObject`.  Python 2.6 uses ``#define``
+to support using the names :cfunc:`PyBytesObject`,
+:cfunc:`PyBytes_Check`, :cfunc:`PyBytes_FromStringAndSize`,
+and all the other functions and macros used with strings.
+Instances of the :class:`bytes` type are immutable just
+as strings are.  A new :class:`bytearray` type stores a mutable
+sequence of bytes::
+>>> bytearray([65, 66, 67])
+bytearray(b'ABC')
+>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
+>>> b
+bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
+>>> b[0] = '\xe3'
+>>> b
+bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
+>>> unicode(str(b), 'utf-8')
+u'\u31ef \u3244'
+Byte arrays support most of the methods of string types, such as
+:meth:`startswith`/:meth:`endswith`, :meth:`find`/:meth:`rfind`,
+and some of the methods of lists, such as :meth:`append`,
+:meth:`pop`,  and :meth:`reverse`.
+::
+>>> b = bytearray('ABC')
+>>> b.append('d')
+>>> b.append(ord('e'))
+>>> b
+bytearray(b'ABCde')
+There's also a corresponding C API, with
+:cfunc:`PyByteArray_FromObject`,
+:cfunc:`PyByteArray_FromStringAndSize`,
+and various other functions.
+.. seealso::
+:pep:`3112` - Bytes literals in Python 3000
+PEP written by Jason Orendorff; backported to 2.6 by Christian Heimes.
+.. ======================================================================
+.. _pep-3116:
+PEP 3116: 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 :meth:`read` and :meth:`write`, but they
+may not support :meth:`readline`, for example.  Python 3.0 introduces
+a layered I/O library in the :mod:`io` module that separates buffering
+and text-handling features from the fundamental read and write
+operations.
+There are three levels of abstract base classes provided by
+the :mod:`io` module:
+* :class:`RawIOBase` defines raw I/O operations: :meth:`read`,
+:meth:`readinto`,
+:meth:`write`, :meth:`seek`, :meth:`tell`, :meth:`truncate`,
+and :meth:`close`.
+Most of the methods of this class will often map to a single system call.
+There are also :meth:`readable`, :meth:`writable`, and :meth:`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.
+.. XXX should 2.6 register them in io.py?
+* :class:`BufferedIOBase` is an abstract base class that
+buffers data in memory to reduce the number of
+system calls used, making I/O processing more efficient.
+It supports all of the methods of :class:`RawIOBase`,
+and adds a :attr:`raw` attribute holding the underlying raw object.
+There are five concrete classes implementing this ABC.
+:class:`BufferedWriter` and :class:`BufferedReader` are for objects
+that support write-only or read-only usage that have a :meth:`seek`
+method for random access.  :class:`BufferedRandom` objects support
+read and write access upon the same underlying stream, and
+:class:`BufferedRWPair` is for objects such as TTYs that have both
+read and write operations acting upon unconnected streams of data.
+The :class:`BytesIO` class supports reading, writing, and seeking
+over an in-memory buffer.
+* :class:`TextIOBase`: Provides functions for reading and writing
+strings (remember, strings will be Unicode in Python 3.0),
+and supporting universal newlines.  :class:`TextIOBase` defines
+the :meth:`readline` method and supports iteration upon
+objects.
+There are two concrete implementations.  :class:`TextIOWrapper`
+wraps a buffered I/O object, supporting all of the methods for
+text I/O and adding a :attr:`buffer` attribute for access
+to the underlying object.  :class:`StringIO` simply buffers
+everything in memory without ever writing anything to disk.
+(In Python 2.6, :class:`io.StringIO` is implemented in
+pure Python, so it's pretty slow.   You should therefore stick with the
+existing :mod:`StringIO` module or :mod:`cStringIO` for now.  At some
+point Python 3.0's :mod:`io` module will be rewritten into C for speed,
+and perhaps the C implementation will be  backported to the 2.x releases.)
+In Python 2.6, the underlying implementations haven't been
+restructured to build on top of the :mod:`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.
+.. seealso::
+:pep:`3116` - New I/O
+PEP written by Daniel Stutzbach, Mike Verdone, and Guido van Rossum.
+Code by Guido van Rossum, Georg Brandl, Walter Doerwald,
+Jeremy Hylton, Martin von Loewis, Tony Lownds, and others.
+.. ======================================================================
+.. _pep-3118:
+PEP 3118: Revised Buffer Protocol
+=====================================================
+The buffer protocol is a C-level API that lets Python types
+exchange pointers into their internal representations.  A
+memory-mapped file can be viewed as a buffer of characters, for
+example, and this lets another module such as :mod:`re`
+treat memory-mapped files as a string of characters to be searched.
+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 contents,
+so there's a corresponding ``PyBuffer_Release(Py_buffer *view)`` to
+indicate that the external caller is done.
+.. XXX PyObject_GetBuffer not documented in c-api
+The *flags* argument to :cfunc:`PyObject_GetBuffer` specifies
+constraints upon the memory returned.  Some examples are:
+* :const:`PyBUF_WRITABLE` indicates that the memory must be writable.
+* :const:`PyBUF_LOCK` requests a read-only or exclusive lock on the memory.
+* :const:`PyBUF_C_CONTIGUOUS` and :const:`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 :cfunc:`PyArg_ParseTuple`,
+``s*`` and ``z*``, return locked buffer objects for a parameter.
+.. seealso::
+:pep:`3118` - Revising the buffer protocol
+PEP written by Travis Oliphant and Carl Banks; implemented by
+Travis Oliphant.
+.. ======================================================================
+.. _pep-3119:
+PEP 3119: Abstract Base Classes
+=====================================================
+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 :mod:`abc` module
+containing a metaclass called :class:`ABCMeta`, special handling of
+this metaclass by the :func:`isinstance` and :func:`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 :meth:`keys`, :meth:`values`, and :meth:`items`
+methods?  What about the iterative variants  such as :meth:`iterkeys`?  :meth:`copy`
+and :meth:`update`?  Iterating over the object with :func:`iter`?
+The Python 2.6 :mod:`collections` module includes a number of
+different ABCs that represent these distinctions.  :class:`Iterable`
+indicates that a class defines :meth:`__iter__`, and
+:class:`Container` means the class defines a :meth:`__contains__`
+method and therefore supports ``x in y`` expressions.  The basic
+dictionary interface of getting items, setting items, and
+:meth:`keys`, :meth:`values`, and :meth:`items`, is defined by the
+:class:`MutableMapping` ABC.
+You can derive your own classes from a particular ABC
+to indicate they support that ABC's interface::
+import collections
+class Storage(collections.MutableMapping):
+...
+Alternatively, you could write the class without deriving from
+the desired ABC and instead register the class by
+calling the ABC's :meth:`register` method::
+import collections
+class Storage:
+...
+collections.MutableMapping.register(Storage)
+For classes that you write, deriving from the ABC is probably clearer.
+The :meth:`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 defined a :class:`PrintableType` ABC,
+it's legal to do::
+# Register Python's types
+PrintableType.register(int)
+PrintableType.register(float)
+PrintableType.register(str)
+Classes should obey the semantics specified 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::
+def func(d):
+if not isinstance(d, collections.MutableMapping):
+raise ValueError("Mapping object expected, not %r" % d)
+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.
+You can write your own ABCs by using ``abc.ABCMeta`` as the
+metaclass in a class definition::
+from abc import ABCMeta, abstractmethod
+class Drawable():
+__metaclass__ = ABCMeta
+@abstractmethod
+def draw(self, x, y, scale=1.0):
+pass
+def draw_doubled(self, x, y):
+self.draw(x, y, scale=2.0)
+class Square(Drawable):
+def draw(self, x, y, scale):
+...
+In the :class:`Drawable` ABC above, the :meth:`draw_doubled` method
+renders the object at twice its size and can be implemented in terms
+of other methods described in :class:`Drawable`.  Classes implementing
+this ABC therefore don't need to provide their own implementation
+of :meth:`draw_doubled`, though they can do so.  An implementation
+of :meth:`draw` is necessary, though; the ABC can't provide
+a useful generic implementation.
+You can apply the ``@abstractmethod`` decorator to methods such as
+:meth:`draw` that must be implemented; Python will then raise an
+exception for classes that don't define the method.
+Note that the exception is only raised when you actually
+try to create an instance of a subclass lacking the method::
+>>> 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
+>>>
+Abstract data attributes can be declared using the
+``@abstractproperty`` decorator::
+from abc import abstractproperty
+...
+@abstractproperty
+def readonly(self):
+return self._x
+Subclasses must then define a :meth:`readonly` property.
+.. seealso::
+:pep:`3119` - Introducing Abstract Base Classes
+PEP written by Guido van Rossum and Talin.
+Implemented by Guido van Rossum.
+Backported to 2.6 by Benjamin Aranguren, with Alex Martelli.
+.. ======================================================================
+.. _pep-3127:
+PEP 3127: Integer Literal Support and Syntax
+=====================================================
+Python 3.0 changes the syntax for octal (base-8) integer literals,
+prefixing them with "0o" or "0O" instead of a leading zero, and adds
+support for binary (base-2) integer literals, signalled by a "0b" or
+"0B" prefix.
+Python 2.6 doesn't drop support for a leading 0 signalling
+an octal number, but it does add support for "0o" and "0b"::
+>>> 0o21, 2*8 + 1
+(17, 17)
+>>> 0b101111
+47
+The :func:`oct` built-in still returns numbers
+prefixed with a leading zero, and a new :func:`bin`
+built-in returns the binary representation for a number::
+>>> oct(42)
+'052'
+>>> future_builtins.oct(42)
+'0o52'
+>>> bin(173)
+'0b10101101'
+The :func:`int` and :func:`long` built-ins will now accept the "0o"
+and "0b" prefixes when base-8 or base-2 are requested, or when the
+*base* argument is zero (signalling that the base used should be
+determined from the string)::
+>>> int ('0o52', 0)
+42
+>>> int('1101', 2)
+13
+>>> int('0b1101', 2)
+13
+>>> int('0b1101', 0)
+13
+.. seealso::
+:pep:`3127` - Integer Literal Support and Syntax
+PEP written by Patrick Maupin; backported to 2.6 by
+Eric Smith.
+.. ======================================================================
+.. _pep-3129:
+PEP 3129: Class Decorators
+=====================================================
+Decorators have been extended from functions to classes.  It's now legal to
+write::
+@foo
+@bar
+class A:
+pass
+This is equivalent to::
+class A:
+pass
+A = foo(bar(A))
+.. seealso::
+:pep:`3129` - Class Decorators
+PEP written by Collin Winter.
+.. ======================================================================
+.. _pep-3141:
+PEP 3141: 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 :mod:`numbers` module.
+The most general ABC is :class:`Number`.  It defines no operations at
+all, and only exists to allow checking if an object is a number by
+doing ``isinstance(obj, Number)``.
+:class:`Complex` is a subclass of :class:`Number`.  Complex numbers
+can undergo the basic operations of addition, subtraction,
+multiplication, division, and exponentiation, and you can retrieve the
+real and imaginary parts and obtain a number's conjugate.  Python's built-in
+complex type is an implementation of :class:`Complex`.
+:class:`Real` further derives from :class:`Complex`, and adds
+operations that only work on real numbers: :func:`floor`, :func:`trunc`,
+rounding, taking the remainder mod N, floor division,
+and comparisons.
+:class:`Rational` numbers derive from :class:`Real`, have
+:attr:`numerator` and :attr:`denominator` properties, and can be
+converted to floats.  Python 2.6 adds a simple rational-number class,
+:class:`Fraction`, in the :mod:`fractions` module.  (It's called
+:class:`Fraction` instead of :class:`Rational` to avoid
+a name clash with :class:`numbers.Rational`.)
+:class:`Integral` numbers derive from :class:`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
+:func:`round`, :func:`math.floor`, :func:`math.ceil`, and adds a new
+one, :func:`math.trunc`, that's been backported to Python 2.6.
+:func:`math.trunc` rounds toward zero, returning the closest
+:class:`Integral` that's between the function's argument and zero.
+.. seealso::
+:pep:`3141` - A Type Hierarchy for Numbers
+PEP written by Jeffrey Yasskin.
+`Scheme's numerical tower <http://www.gnu.org/software/guile/manual/html_node/Numerical-Tower.html#Numerical-Tower>`__, from the Guile manual.
+`Scheme's number datatypes <http://schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-9.html#%_sec_6.2>`__ from the R5RS Scheme specification.
+The :mod:`fractions` Module
+--------------------------------------------------
+To fill out the hierarchy of numeric types, the :mod:`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 floating-point numbers
+can only approximate.
+The :class:`Fraction` constructor takes two :class:`Integral` values
+that will be the numerator and denominator of the resulting fraction. ::
+>>> 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
+Fraction(5, 3)
+For converting floating-point numbers to rationals,
+the float type now has an :meth:`as_integer_ratio()` method that returns
+the numerator and denominator for a fraction that evaluates to the same
+floating-point value::
+>>> (2.5) .as_integer_ratio()
+(5, 2)
+>>> (3.1415) .as_integer_ratio()
+(7074029114692207L, 2251799813685248L)
+>>> (1./3) .as_integer_ratio()
+(6004799503160661L, 18014398509481984L)
+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**.
+The :mod:`fractions` module is based upon an implementation by Sjoerd
+Mullender that was in Python's :file:`Demo/classes/` directory for a
+long time.  This implementation was significantly updated by Jeffrey
+Yasskin.
+Other Language Changes
+======================
+Some smaller changes made to the core Python language are:
+* The :func:`hasattr` function was catching and ignoring all errors,
+under the assumption that they meant a :meth:`__getattr__` method
+was failing somehow and the return value of :func:`hasattr` would
+therefore be ``False``.  This logic shouldn't be applied to
+:exc:`KeyboardInterrupt` and :exc:`SystemExit`, however; Python 2.6
+will no longer discard such exceptions when :func:`hasattr`
+encounters them.  (Fixed by Benjamin Peterson; :issue:`2196`.)
+* When calling a function using the ``**`` syntax to provide keyword
+arguments, you are no longer required to use a Python dictionary;
+any mapping will now work::
+>>> def f(**kw):
+...    print sorted(kw)
+...
+>>> ud=UserDict.UserDict()
+>>> ud['a'] = 1
+>>> ud['b'] = 'string'
+>>> f(**ud)
+['a', 'b']
+(Contributed by Alexander Belopolsky; :issue:`1686487`.)
+It's also become legal to provide keyword arguments after a ``*args`` argument
+to a function call. ::
+>>> def f(*args, **kw):
+...     print args, kw
+...
+>>> f(1,2,3, *(4,5,6), keyword=13)
+(1, 2, 3, 4, 5, 6) {'keyword': 13}
+Previously this would have been a syntax error.
+(Contributed by Amaury Forgeot d'Arc; :issue:`3473`.)
+* A new built-in, ``next(iterator, [default])`` returns the next item
+from the specified iterator.  If the *default* argument is supplied,
+it will be returned if *iterator* has been exhausted; otherwise,
+the :exc:`StopIteration` exception will be raised.  (Backported
+in :issue:`2719`.)
+* Tuples now have :meth:`index` and :meth:`count` methods matching the
+list type's :meth:`index` and :meth:`count` methods::
+>>> t = (0,1,2,3,4,0,1,2)
+>>> t.index(3)
+3
+>>> t.count(0)
+2
+(Contributed by Raymond Hettinger)
+* The built-in types now have improved support for extended slicing syntax,
+accepting various combinations of ``(start, stop, step)``.
+Previously, the support was partial and certain corner cases wouldn't work.
+(Implemented by Thomas Wouters.)
+.. Revision 57619
+* Properties now have three attributes, :attr:`getter`, :attr:`setter`
+and :attr:`deleter`, that are decorators providing useful shortcuts
+for adding a getter, setter or deleter function to an existing
+property. You would use them like this::
+class C(object):
+@property
+def x(self):
+return self._x
+@x.setter
+def x(self, value):
+self._x = value
+@x.deleter
+def x(self):
+del self._x
+class D(C):
+@C.x.getter
+def x(self):
+return self._x * 2
+@x.setter
+def x(self, value):
+self._x = value / 2
+* Several methods of the built-in set types now accept multiple iterables:
+:meth:`intersection`,
+:meth:`intersection_update`,
+:meth:`union`, :meth:`update`,
+:meth:`difference` and :meth:`difference_update`.
+::
+>>> s=set('1234567890')
+>>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
+set(['2'])
+>>> s.difference('246', '789')
+set(['1', '0', '3', '5'])
+(Contributed by Raymond Hettinger.)
+* Many floating-point features were added.  The :func:`float` function
+will now turn the string ``nan`` into an
+IEEE 754 Not A Number value, and ``+inf`` and ``-inf`` into
+positive or negative infinity.  This works on any platform with
+IEEE 754 semantics.  (Contributed by Christian Heimes; :issue:`1635`.)
+Other functions in the :mod:`math` module, :func:`isinf` and
+:func:`isnan`, return true if their floating-point argument is
+infinite or Not A Number.  (:issue:`1640`)
+Conversion functions were added to convert floating-point numbers
+into hexadecimal strings (:issue:`3008`).  These functions
+convert floats to and from a string representation without
+introducing rounding errors from the conversion between decimal and
+binary.  Floats have a :meth:`hex` method that returns a string
+representation, and the ``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 floats
+on systems that support signed zeros (-0 and +0), the
+:func:`complex` constructor will now preserve the sign
+of the zero.  (Fixed by Mark T. Dickinson; :issue:`1507`.)
+* Classes that inherit a :meth:`__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 :exc:`TypeError`
+and the class will not be indicated as implementing the
+:class:`Hashable` ABC.
+You should do this when you've defined a :meth:`__cmp__` or
+:meth:`__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
+:meth:`__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
+:cfunc:`PyObject_HashNotImplemented`.
+(Fixed by Nick Coghlan and Amaury Forgeot d'Arc; :issue:`2235`.)
+* Changes to the :class:`Exception` interface
+as dictated by :pep:`352` continue to be made.  For 2.6,
+the :attr:`message` attribute is being deprecated in favor of the
+:attr:`args` attribute.
+* The :exc:`GeneratorExit` exception now subclasses
+:exc:`BaseException` instead of :exc:`Exception`.  This means
+that an exception handler that does ``except Exception:``
+will not inadvertently catch :exc:`GeneratorExit`.
+(Contributed by Chad Austin; :issue:`1537`.)
+* Generator objects now have a :attr:`gi_code` attribute that refers to
+the original code object backing the generator.
+(Contributed by Collin Winter; :issue:`1473257`.)
+* The :func:`compile` built-in function now accepts keyword arguments
+as well as positional parameters.  (Contributed by Thomas Wouters;
+:issue:`1444529`.)
+* The :func:`complex` constructor now accepts strings containing
+parenthesized complex numbers, meaning that ``complex(repr(cplx))``
+will now round-trip values.  For example, ``complex('(3+4j)')``
+now returns the value (3+4j).  (:issue:`1491866`)
+* The string :meth:`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.  (Contributed by Bengt Richter and
+implemented by Raymond Hettinger; :issue:`1193128`.)
+* The built-in :func:`dir` function now checks for a :meth:`__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 :func:`dir` produces.
+Objects that have :meth:`__getattr__` or :meth:`__getattribute__`
+methods can use this to advertise pseudo-attributes they will honor.
+(:issue:`1591665`)
+* Instance method objects have new attributes for the object and function
+comprising the method; the new synonym for :attr:`im_self` is
+:attr:`__self__`, and :attr:`im_func` is also available as :attr:`__func__`.
+The old names are still supported in Python 2.6, but are gone in 3.0.
+* An obscure change: when you use the the :func:`locals` function inside a
+:keyword:`class` statement, the resulting dictionary no longer returns free
+variables.  (Free variables, in this case, are variables referenced in the
+:keyword:`class` statement  that aren't attributes of the class.)
+.. ======================================================================
+Optimizations
+-------------
+* The :mod:`warnings` module has been rewritten in C.  This makes
+it possible to invoke warnings from the parser, and may also
+make the interpreter's startup faster.
+(Contributed by Neal Norwitz and Brett Cannon; :issue:`1631171`.)
+* Type objects now have a cache of methods that can reduce
+the work required to find the correct method implementation
+for a particular class; once cached, the interpreter doesn't need to
+traverse base classes to figure out the right method to call.
+The cache is cleared if a base class or the class itself is modified,
+so the cache should remain correct even in the face of Python's dynamic
+nature.
+(Original optimization implemented by Armin Rigo, updated for
+Python 2.6 by Kevin Jacobs; :issue:`1700288`.)
+By default, this change is only applied to types that are included with
+the Python core.  Extension modules may not necessarily be compatible with
+this cache,
+so they must explicitly add :cmacro:`Py_TPFLAGS_HAVE_VERSION_TAG`
+to the module's ``tp_flags`` field to enable the method cache.
+(To be compatible with the method cache, the extension module's code
+must not directly access and modify the ``tp_dict`` member of
+any of the types it implements.  Most modules don't do this,
+but it's impossible for the Python interpreter to determine that.
+See :issue:`1878` for some discussion.)
+* Function calls that use keyword arguments are significantly faster
+by doing a quick pointer comparison, usually saving the time of a
+full string comparison.  (Contributed by Raymond Hettinger, after an
+initial implementation by Antoine Pitrou; :issue:`1819`.)
+* All of the functions in the :mod:`struct` module have been rewritten in
+C, thanks to work at the Need For Speed sprint.
+(Contributed by Raymond Hettinger.)
+* Some of the standard built-in types now set a bit in their type
+objects.  This speeds up checking whether an object is a subclass of
+one of these types.  (Contributed by Neal Norwitz.)
+* Unicode strings now use faster code for detecting
+whitespace and line breaks; this speeds up the :meth:`split` method
+by about 25% and :meth:`splitlines` by 35%.
+(Contributed by Antoine Pitrou.)  Memory usage is reduced
+by using pymalloc for the Unicode string's data.
+* The ``with`` statement now stores the :meth:`__exit__` method on the stack,
+producing a small speedup.  (Implemented by Jeffrey Yasskin.)
+* To reduce memory usage, the garbage collector will now clear internal
+free lists when garbage-collecting the highest generation of objects.
+This may return memory to the operating system sooner.
+.. ======================================================================
+.. _new-26-interpreter:
+Interpreter Changes
+-------------------------------
+Two command-line options have been reserved for use by other Python
+implementations.  The :option:`-J` switch has been reserved for use by
+Jython for Jython-specific options, such as switches that are passed to
+the underlying JVM.  :option:`-X` has been reserved for options
+specific to a particular implementation of Python such as CPython,
+Jython, or IronPython.  If either option is used with Python 2.6, the
+interpreter will report that the option isn't currently used.
+Python can now be prevented from writing :file:`.pyc` or :file:`.pyo`
+files by supplying the :option:`-B` switch to the Python interpreter,
+or by setting the :envvar:`PYTHONDONTWRITEBYTECODE` environment
+variable before running the interpreter.  This setting is available to
+Python programs as the ``sys.dont_write_bytecode`` variable, and
+Python code can change the value to modify the interpreter's
+behaviour.  (Contributed by Neal Norwitz and Georg Brandl.)
+The encoding used for standard input, output, and standard error can
+be specified by setting the :envvar:`PYTHONIOENCODING` environment
+variable before running the interpreter.  The value should be a string
+in the form ``<encoding>`` or ``<encoding>:<errorhandler>``.
+The *encoding* part specifies the encoding's name, e.g. ``utf-8`` or
+``latin-1``; the optional *errorhandler* part specifies
+what to do with characters that can't be handled by the encoding,
+and  should be one of "error", "ignore", or "replace".   (Contributed
+by Martin von Loewis.)
+.. ======================================================================
+New, Improved, and Deprecated Modules
+=====================================
+As in every release, Python's standard library received a number of
+enhancements and bug fixes.  Here's a partial list of the most notable
+changes, sorted alphabetically by module name. Consult the
+:file:`Misc/NEWS` file in the source tree for a more complete list of
+changes, or look through the Subversion logs for all the details.
+* (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:
+:mod:`audiodev`,
+:mod:`bgenlocations`,
+:mod:`buildtools`,
+:mod:`bundlebuilder`,
+:mod:`Canvas`,
+:mod:`compiler`,
+:mod:`dircache`,
+:mod:`dl`,
+:mod:`fpformat`,
+:mod:`gensuitemodule`,
+:mod:`ihooks`,
+:mod:`imageop`,
+:mod:`imgfile`,
+:mod:`linuxaudiodev`,
+:mod:`mhlib`,
+:mod:`mimetools`,
+:mod:`multifile`,
+:mod:`new`,
+:mod:`pure`,
+:mod:`statvfs`,
+:mod:`sunaudiodev`,
+:mod:`test.testall`, and
+:mod:`toaiff`.
+* The :mod:`asyncore` and :mod:`asynchat` modules are
+being actively maintained again, and a number of patches and bugfixes
+were applied.  (Maintained by Josiah Carlson; see :issue:`1736190` for
+one patch.)
+* The :mod:`bsddb` module also has a new maintainer, Jesús Cea, and the package
+is now available as a standalone package.  The web page for the package is
+`www.jcea.es/programacion/pybsddb.htm
+<http://www.jcea.es/programacion/pybsddb.htm>`__.
+The plan is to remove the package from the standard library
+in Python 3.0, because its pace of releases is much more frequent than
+Python's.
+The :mod:`bsddb.dbshelve` module now uses the highest pickling protocol
+available, instead of restricting itself to protocol 1.
+(Contributed by W. Barnes; :issue:`1551443`.)
+* The :mod:`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".  (Contributed by Alexandre Fiori and
+Nubis; :issue:`1817`.)
+The :func:`parse_qs` and :func:`parse_qsl` functions have been
+relocated from the :mod:`cgi` module to the :mod:`urlparse` module.
+The versions still available in the :mod:`cgi` module will
+trigger :exc:`PendingDeprecationWarning` messages in 2.6
+(:issue:`600362`).
+* The :mod:`cmath` module underwent extensive revision,
+contributed by Mark Dickinson and Christian Heimes.
+Five new functions were added:
+* :func:`polar` converts a complex number to polar form, returning
+the modulus and argument of the complex number.
+* :func:`rect` does the opposite, turning a modulus, argument pair
+back into the corresponding complex number.
+* :func:`phase` returns the argument (also called the angle) of a complex
+number.
+* :func:`isnan` returns True if either
+the real or imaginary part of its argument is a NaN.
+* :func:`isinf` returns True if either the real or imaginary part of
+its argument is infinite.
+The revisions also improved the numerical soundness of the
+:mod:`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.  See :issue:`1381` for the
+details.  The branch cuts for :func:`asinh`, :func:`atanh`: and
+:func:`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 :mod:`cmath` module now handles IEEE 754
+special values and floating-point exceptions in a manner consistent
+with Annex 'G' of the C99 standard.
+* A new data type in the :mod:`collections` module: :class:`namedtuple(typename,
+fieldnames)` is a factory function that creates subclasses of the standard tuple
+whose fields are accessible by name as well as index.  For example::
+>>> var_type = collections.namedtuple('variable',
+...             'id name type size')
+>>> # Names are separated by spaces or commas.
+>>> # 'id, name, type, size' would also work.
+>>> var_type._fields
+('id', 'name', 'type', 'size')
+>>> var = var_type(1, 'frequency', 'int', 4)
+>>> print var[0], var.id		# Equivalent
+1 1
+>>> print var[2], var.type          # Equivalent
+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)
+Several places in the standard library that returned tuples have
+been modified to return :class:`namedtuple` instances.  For example,
+the :meth:`Decimal.as_tuple` method now returns a named tuple with
+:attr:`sign`, :attr:`digits`, and :attr:`exponent` fields.
+(Contributed by Raymond Hettinger.)
+* Another change to the :mod:`collections` module is that the
+:class:`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.
+::
+>>> 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)
+(Contributed by Raymond Hettinger.)
+* The :mod:`Cookie` module's :class:`Morsel` objects now support an
+:attr:`httponly` attribute.  In some browsers. cookies with this attribute
+set cannot be accessed or manipulated by JavaScript code.
+(Contributed by Arvin Schnell; :issue:`1638033`.)
+* A new window method in the :mod:`curses` module,
+:meth:`chgat`, changes the display attributes for a certain number of
+characters on a single line.  (Contributed by Fabian Kreutz.)
+::
+# Boldface text starting at y=0,x=21
+# and affecting the rest of the line.
+stdscr.chgat(0, 21, curses.A_BOLD)
+The :class:`Textbox` class in the :mod:`curses.textpad` module
+now supports editing in insert mode as well as overwrite mode.
+Insert mode is enabled by supplying a true value for the *insert_mode*
+parameter when creating the :class:`Textbox` instance.
+* The :mod:`datetime` module's :meth:`strftime` methods now support a
+``%f`` format code that expands to the number of microseconds in the
+object, zero-padded on
+the left to six places.  (Contributed by Skip Montanaro; :issue:`1158`.)
+* The :mod:`decimal` module was updated to version 1.66 of
+`the General Decimal Specification <http://www2.hursley.ibm.com/decimal/decarith.html>`__.  New features
+include some methods for some basic mathematical functions such as
+:meth:`exp` and :meth:`log10`::
+>>> Decimal(1).exp()
+Decimal("2.718281828459045235360287471")
+>>> Decimal("2.7182818").ln()
+Decimal("0.9999999895305022877376682436")
+>>> Decimal(1000).log10()
+Decimal("3")
+The :meth:`as_tuple` method of :class:`Decimal` objects now returns a
+named tuple with :attr:`sign`, :attr:`digits`, and :attr:`exponent` fields.
+(Implemented by Facundo Batista and Mark Dickinson.  Named tuple
+support added by Raymond Hettinger.)
+* The :mod:`difflib` module's :class:`SequenceMatcher` class
+now returns named tuples representing matches,
+with :attr:`a`, :attr:`b`, and :attr:`size` attributes.
+(Contributed by Raymond Hettinger.)
+* An optional ``timeout`` parameter, specifying a timeout measured in
+seconds, was added to the :class:`ftplib.FTP` class constructor as
+well as the :meth:`connect` method.  (Added by Facundo Batista.)
+Also, the :class:`FTP` class's :meth:`storbinary` and
+:meth:`storlines` now take an optional *callback* parameter that
+will be called with each block of data after the data has been sent.
+(Contributed by Phil Schwartz; :issue:`1221598`.)
+* The :func:`reduce` built-in function is also available in the
+:mod:`functools` module.  In Python 3.0, the built-in has been
+dropped and :func:`reduce` is only available from :mod:`functools`;
+currently there are no plans to drop the built-in in the 2.x series.
+(Patched by Christian Heimes; :issue:`1739906`.)
+* When possible, the :mod:`getpass` module will now use
+:file:`/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.  (Contributed by Gregory P. Smith.)
+* The :func:`glob.glob` function can now return Unicode filenames if
+a Unicode path was used and Unicode filenames are matched within the
+directory.  (:issue:`1001604`)
+* The :mod:`gopherlib` module has been removed.
+* A new function in the :mod:`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::
+>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
+[1, 2, 3, 5, 8, 9, 16]
+Another new function, ``heappushpop(heap, item)``,
+pushes *item* onto *heap*, then pops off and returns the smallest item.
+This is more efficient than making a call to :func:`heappush` and then
+:func:`heappop`.
+:mod:`heapq` is now implemented to only use less-than comparison,
+instead of the less-than-or-equal comparison it previously used.
+This makes :mod:`heapq`'s usage of a type match the
+:meth:`list.sort` method.
+(Contributed by Raymond Hettinger.)
+* An optional ``timeout`` parameter, specifying a timeout measured in
+seconds, was added to the :class:`httplib.HTTPConnection` and
+:class:`HTTPSConnection` class constructors.  (Added by Facundo
+Batista.)
+* Most of the :mod:`inspect` module's functions, such as
+:func:`getmoduleinfo` and :func:`getargs`, now return named tuples.
+In addition to behaving like tuples, the elements of the  return value
+can also be accessed as attributes.
+(Contributed by Raymond Hettinger.)
+Some new functions in the module include
+:func:`isgenerator`, :func:`isgeneratorfunction`,
+and :func:`isabstract`.
+* The :mod:`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 *fillvalue*.  For example::
+>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
+((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
+``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. ::
+>>> 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)]
+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::
+>>> 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)]
+With two iterables, *2N*-tuples are returned. ::
+>>> 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)]
+``combinations(iterable, r)`` returns sub-sequences of length *r* from
+the elements of *iterable*. ::
+>>> list(itertools.combinations('123', 2))
+[('1', '2'), ('1', '3'), ('2', '3')]
+>>> list(itertools.combinations('123', 3))
+[('1', '2', '3')]
+>>> list(itertools.combinations('1234', 3))
+[('1', '2', '3'), ('1', '2', '4'),
+('1', '3', '4'), ('2', '3', '4')]
+``permutations(iter[, r])`` returns all the permutations of length *r* of
+the iterable's elements.  If *r* is not specified, it will default to the
+number of elements produced by the iterable. ::
+>>> 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)]
+``itertools.chain(*iterables)`` is an existing function in
+:mod:`itertools` that gained a new constructor in Python 2.6.
+``itertools.chain.from_iterable(iterable)`` takes a single
+iterable that should return other iterables.  :func:`chain` will
+then return all the elements of the first iterable, then
+all the elements of the second, and so on. ::
+>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
+[1, 2, 3, 4, 5, 6]
+(All contributed by Raymond Hettinger.)
+* The :mod:`logging` module's :class:`FileHandler` class
+and its subclasses :class:`WatchedFileHandler`, :class:`RotatingFileHandler`,
+and :class:`TimedRotatingFileHandler` now
+have an optional *delay* parameter to their constructors.  If *delay*
+is true, opening of the log file is deferred until the first
+:meth:`emit` call is made.  (Contributed by Vinay Sajip.)
+:class:`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.
+* Several new functions were added to the :mod:`math` module:
+* :func:`~math.isinf` and :func:`~math.isnan` determine whether a given float
+is a (positive or negative) infinity or a NaN (Not a Number), respectively.
+* :func:`~math.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.
+(Contributed by Christian Heimes.)
+* :func:`~math.factorial` computes the factorial of a number.
+(Contributed by Raymond Hettinger; :issue:`2138`.)
+* :func:`~math.fsum` adds up the stream of numbers from an iterable,
+and is careful to avoid loss of precision through using partial sums.
+(Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson;
+:issue:`2819`.)
+* :func:`~math.acosh`, :func:`~math.asinh`
+and :func:`~math.atanh` compute the inverse hyperbolic functions.
+* :func:`~math.log1p` returns the natural logarithm of *1+x*
+(base *e*).
+* :func:`trunc` rounds a number toward zero, returning the closest
+:class:`Integral` that's between the function's argument and zero.
+Added as part of the backport of
+`PEP 3141's type hierarchy for numbers <#pep-3141>`__.
+* The :mod:`math` module has been improved to give more consistent
+behaviour across platforms, especially with respect to handling of
+floating-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 :exc:`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 :exc:`ValueError`.
+Where Annex 'F' of the C99 standard recommends signaling 'overflow',
+Python will raise :exc:`OverflowError`.  (See :issue:`711019` and
+:issue:`1640`.)
+(Contributed by Christian Heimes and Mark Dickinson.)
+* The :mod:`MimeWriter` module and :mod:`mimify` module
+have been deprecated; use the :mod:`email`
+package instead.
+* The :mod:`md5` module has been deprecated; use the :mod:`hashlib` module
+instead.
+* :class:`mmap` objects now have a :meth:`rfind` method that searches for a
+substring beginning at the end of the string and searching
+backwards.  The :meth:`find` method also gained an *end* parameter
+giving an index at which to stop searching.
+(Contributed by John Lenton.)
+* The :mod:`operator` module gained a
+:func:`methodcaller` function that takes a 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')
+>>> replacer = operator.methodcaller('replace', 'old', 'new')
+>>> replacer('old wine in old bottles')
+'new wine in new bottles'
+(Contributed by Georg Brandl, after a suggestion by Gregory Petrosyan.)
+The :func:`attrgetter` function now accepts dotted names and performs
+the corresponding attribute lookups::
+>>> inst_name = operator.attrgetter(
+...        '__class__.__name__')
+>>> inst_name('')
+'str'
+>>> inst_name(help)
+'_Helper'
+(Contributed by Georg Brandl, after a suggestion by Barry Warsaw.)
+* The :mod:`os` module now wraps several new system calls.
+``fchmod(fd, mode)`` and ``fchown(fd, uid, gid)`` change the mode
+and ownership of an opened file, and ``lchmod(path, mode)`` changes
+the mode of a symlink.  (Contributed by Georg Brandl and Christian
+Heimes.)
+:func:`chflags` and :func:`lchflags` are wrappers for the
+corresponding system calls (where they're available), changing the
+flags set on a file.  Constants for the flag values are defined in
+the :mod:`stat` module; some possible values include
+:const:`UF_IMMUTABLE` to signal the file may not be changed and
+:const:`UF_APPEND` to indicate that data can only be appended to the
+file.  (Contributed by M. Levinson.)
+``os.closerange(low, high)`` efficiently closes all file descriptors
+from *low* to *high*, ignoring any errors and not including *high* itself.
+This function is now used by the :mod:`subprocess` module to make starting
+processes faster.  (Contributed by Georg Brandl; :issue:`1663329`.)
+* The ``os.environ`` object's :meth:`clear` method will now unset the
+environment variables using :func:`os.unsetenv` in addition to clearing
+the object's keys.  (Contributed by Martin Horcicka; :issue:`1181`.)
+* The :func:`os.walk` function now has a ``followlinks`` parameter. 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.  (:issue:`1273829`)
+* In the :mod:`os.path` module, the :func:`splitext` function
+has been changed to not split on leading period characters.
+This produces better results when operating on Unix's dot-files.
+For example, ``os.path.splitext('.ipython')``
+now returns ``('.ipython', '')`` instead of ``('', '.ipython')``.
+(:issue:`115886`)
+A new function, ``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``.  (Contributed by
+Richard Barran; :issue:`1339796`.)
+On Windows, :func:`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.  (Contributed by Josiah Carlson;
+:issue:`957650`.)
+* The Python debugger provided by the :mod:`pdb` module
+gained a new command: "run" restarts the Python program being debugged
+and can optionally take new command-line arguments for the program.
+(Contributed by Rocky Bernstein; :issue:`1393667`.)
+* The :mod:`posixfile` module has been deprecated; :func:`fcntl.lockf`
+provides better locking.
+The :func:`post_mortem` function, used to begin debugging a
+traceback, will now use the traceback returned by :func:`sys.exc_info`
+if no traceback is supplied.   (Contributed by Facundo Batista;
+:issue:`1106316`.)
+* The :mod:`pickletools` module now has an :func:`optimize` function
+that takes a string containing a pickle and removes some unused
+opcodes, returning a shorter pickle that contains the same data structure.
+(Contributed by Raymond Hettinger.)
+* The :mod:`popen2` module has been deprecated; use the :mod:`subprocess`
+module.
+* A :func:`get_data` function was added to the :mod:`pkgutil`
+module that returns the contents of resource files included
+with an installed Python package.  For example::
+>>> import pkgutil
+>>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
+BaseException
++-- SystemExit
++-- KeyboardInterrupt
++-- GeneratorExit
++-- Exception
++-- StopIteration
++-- StandardError
+...
+(Contributed by Paul Moore; :issue:`2439`.)
+* The :mod:`pyexpat` module's :class:`Parser` objects now allow setting
+their :attr:`buffer_size` attribute to change the size of the buffer
+used to hold character data.
+(Contributed by Achim Gaedke; :issue:`1137`.)
+* The :mod:`Queue` module now provides queue variants that retrieve entries
+in different orders.  The :class:`PriorityQueue` class stores
+queued items in a heap and retrieves them in priority order,
+and :class:`LifoQueue` retrieves the most recently added entries first,
+meaning that it behaves like a stack.
+(Contributed by Raymond Hettinger.)
+* The :mod:`random` module's :class:`Random` objects can
+now be pickled on a 32-bit system and unpickled on a 64-bit
+system, and vice versa.  Unfortunately, this change also means
+that Python 2.6's :class:`Random` objects can't be unpickled correctly
+on earlier versions of Python.
+(Contributed by Shawn Ligocki; :issue:`1727780`.)
+The new ``triangular(low, high, mode)`` function returns random
+numbers following a triangular distribution.   The returned values
+are between *low* and *high*, not including *high* itself, and
+with *mode* as the most frequently occurring value
+in the distribution.  (Contributed by Wladmir van der Laan and
+Raymond Hettinger; :issue:`1681432`.)
+* Long regular expression searches carried out by the  :mod:`re`
+module will check for signals being delivered, so
+time-consuming searches can now be interrupted.
+(Contributed by Josh Hoyt and Ralf Schmitt; :issue:`846388`.)
+The regular expression module is implemented by compiling bytecodes
+for a tiny regex-specific virtual machine.  Untrusted code
+could create malicious strings of bytecode directly and cause crashes,
+so Python 2.6 includes a verifier for the regex bytecode.
+(Contributed by Guido van Rossum from work for Google App Engine;
+:issue:`3487`.)
+* The :mod:`rgbimg` module has been removed.
+* The :mod:`rlcompleter` module's :meth:`Completer.complete()` method
+will now ignore exceptions triggered while evaluating a name.
+(Fixed by Lorenz Quack; :issue:`2250`.)
+* The :mod:`sched` module's :class:`scheduler` instances now
+have a read-only :attr:`queue` attribute that returns the
+contents of the scheduler's queue, represented as a list of
+named tuples with the fields ``(time, priority, action, argument)``.
+(Contributed by Raymond Hettinger; :issue:`1861`.)
+* The :mod:`select` module now has wrapper functions
+for the Linux :cfunc:`epoll` and BSD :cfunc:`kqueue` system calls.
+:meth:`modify` method was added to the existing :class:`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.
+(Contributed by Christian Heimes; :issue:`1657`.)
+* The :mod:`sets` module has been deprecated; it's better to
+use the built-in :class:`set` and :class:`frozenset` types.
+* The :mod:`sha` module has been deprecated; use the :mod:`hashlib` module
+instead.
+* The :func:`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 :mod:`shutil` module also provides an :func:`ignore_patterns`
+function for use with this new parameter.  :func:`ignore_patterns`
+takes an arbitrary number of glob-style patterns and returns a
+callable that will ignore any files and directories that match any
+of these patterns.  The following example copies a directory tree,
+but skips both :file:`.svn` directories and Emacs backup files,
+which have names ending with '~'::
+shutil.copytree('Doc/library', '/tmp/library',
+ignore=shutil.ignore_patterns('*~', '.svn'))
+(Contributed by Tarek Ziadé; :issue:`2663`.)
+* 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 :mod:`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,
+:cfunc:`PySignal_SetWakeupFd`, for setting the descriptor.
+Event loops will use this by opening a pipe to create two descriptors,
+one for reading and one for writing.  The writable descriptor
+will be passed to :func:`set_wakeup_fd`, and the readable descriptor
+will be added to the list of descriptors monitored by the event loop via
+:cfunc:`select` or :cfunc:`poll`.
+On receiving a signal, a byte will be written and the main event loop
+will be woken up, avoiding the need to poll.
+(Contributed by Adam Olsen; :issue:`1583`.)
+The :func:`siginterrupt` function is now available from Python code,
+and allows changing whether signals can interrupt system calls or not.
+(Contributed by Ralf Schmitt.)
+The :func:`setitimer` and :func:`getitimer` functions have also been
+added (where they're available).  :func:`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.  (Contributed by Guilherme Polo; :issue:`2240`.)
+* The :mod:`smtplib` module now supports SMTP over SSL thanks to the
+addition of the :class:`SMTP_SSL` class. This class supports an
+interface identical to the existing :class:`SMTP` class.
+(Contributed by Monty Taylor.)  Both class constructors also have an
+optional ``timeout`` parameter that specifies a timeout for the
+initial connection attempt, measured in seconds.  (Contributed by
+Facundo Batista.)
+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.  (LMTP
+implemented by Leif Hedstrom; :issue:`957003`.)
+SMTP.starttls() now complies with :rfc:`3207` and forgets any
+knowledge obtained from the server not obtained from the TLS
+negotiation itself.  (Patch contributed by Bill Fenner;
+:issue:`829951`.)
+* The :mod:`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.
+(Contributed by Alberto Bertogli; :issue:`1646`.)
+A new function, :func:`create_connection`, takes an address
+and connects to it using an optional timeout value, returning
+the connected socket object.
+* The base classes in the :mod:`SocketServer` module now support
+calling a :meth:`handle_timeout` method after a span of inactivity
+specified by the server's :attr:`timeout` attribute.  (Contributed
+by Michael Pomraning.)  The :meth:`serve_forever` method
+now takes an optional poll interval measured in seconds,
+controlling how often the server will check for a shutdown request.
+(Contributed by Pedro Werneck and Jeffrey Yasskin;
+:issue:`742598`, :issue:`1193577`.)
+* The :mod:`sqlite3` module, maintained by Gerhard Haering,
+has been updated from version 2.3.2 in Python 2.5 to
+version 2.4.1.
+* The :mod:`struct` module now supports the C99 :ctype:`_Bool` type,
+using the format character ``'?'``.
+(Contributed by David Remahl.)
+* The :class:`Popen` objects provided by the :mod:`subprocess` module
+now have :meth:`terminate`, :meth:`kill`, and :meth:`send_signal` methods.
+On Windows, :meth:`send_signal` only supports the :const:`SIGTERM`
+signal, and all these methods are aliases for the Win32 API function
+:cfunc:`TerminateProcess`.
+(Contributed by Christian Heimes.)
+* A new variable in the :mod:`sys` module, :attr:`float_info`, is an
+object containing information derived from the :file:`float.h` file
+about the platform's floating-point support.  Attributes of this
+object include :attr:`mant_dig` (number of digits in the mantissa),
+:attr:`epsilon` (smallest difference between 1.0 and the next
+largest value representable), and several others.  (Contributed by
+Christian Heimes; :issue:`1534`.)
+Another new variable, :attr:`dont_write_bytecode`, controls whether Python
+writes any :file:`.pyc` or :file:`.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 :option:`-B`
+switch to the Python interpreter, or by setting the
+:envvar:`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.
+(Contributed by Neal Norwitz and Georg Brandl.)
+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 :attr:`verbose`
+attribute is true if Python
+was executed in verbose mode, :attr:`debug` is true in debugging mode, etc.
+These attributes are all read-only.
+(Contributed by Christian Heimes.)
+A new function, :func:`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 define a :meth:`__sizeof__` method to return the
+object's size.
+(Contributed by Robert Schuppenies; :issue:`2898`.)
+It's now possible to determine the current profiler and tracer functions
+by calling :func:`sys.getprofile` and :func:`sys.gettrace`.
+(Contributed by Georg Brandl; :issue:`1648`.)
+* The :mod:`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.)
+The :meth:`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 :meth:`add`
+and to the names of files in recursively-added directories.
+(All changes contributed by Lars Gustäbel).
+* An optional ``timeout`` parameter was added to the
+:class:`telnetlib.Telnet` class constructor, specifying a timeout
+measured in seconds.  (Added by Facundo Batista.)
+* The :class:`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.  (Contributed by Damien Miller; :issue:`1537850`.)
+A new class, :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.  (Contributed by Dustin J. Mitchell.)
+The :class:`NamedTemporaryFile` and :class:`SpooledTemporaryFile` classes
+both work as context managers, so you can write
+``with tempfile.NamedTemporaryFile() as tmp: ...``.
+(Contributed by Alexander Belopolsky; :issue:`2021`.)
+* The :mod:`test.test_support` module gained a number
+of context managers useful for writing tests.
+:func:`EnvironmentVarGuard` is a
+context manager that temporarily changes environment variables and
+automatically restores them to their old values.
+Another context manager, :class:`TransientResource`, can surround calls
+to resources that may or may not be available; it will catch and
+ignore a specified 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')
+...
+Finally, :func:`check_warnings` resets the :mod:`warning` module's
+warning filters and returns an object that will record all warning
+messages triggered (:issue:`3781`)::
+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"
+(Contributed by Brett Cannon.)
+* The :mod:`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::
+>>> 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.
+>>>
+(Contributed by Dwayne Bailey; :issue:`1581073`.)
+* The :mod:`threading` module API is being changed to use properties
+such as :attr:`daemon` instead of :meth:`setDaemon` and
+:meth:`isDaemon` methods, and some methods have been renamed to use
+underscores instead of camel-case; for example, the
+:meth:`activeCount` method is renamed to :meth:`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.
+(Carried out by several people, most notably Benjamin Peterson.)
+The :mod:`threading` module's :class:`Thread` objects
+gained an :attr:`ident` property that returns the thread's
+identifier, a nonzero integer.  (Contributed by Gregory P. Smith;
+:issue:`2871`.)
+* The :mod:`timeit` module now accepts callables as well as strings
+for the statement being timed and for the setup code.
+Two convenience functions were added for creating
+:class:`Timer` instances:
+``repeat(stmt, setup, time, repeat, number)`` and
+``timeit(stmt, setup, time, number)`` create an instance and call
+the corresponding method. (Contributed by Erik Demaine;
+:issue:`1533909`.)
+* The :mod:`Tkinter` module now accepts lists and tuples for options,
+separating the elements by spaces before passing the resulting value to
+Tcl/Tk.
+(Contributed by Guilherme Polo; :issue:`2906`.)
+* The :mod:`turtle` module for turtle graphics was greatly enhanced by
+Gregor Lingl.  New features in the module include:
+* Better animation of turtle movement and rotation.
+* Control over turtle movement using the new :meth:`delay`,
+:meth:`tracer`, and :meth:`speed` methods.
+* The ability to set new shapes for the turtle, and to
+define a new coordinate system.
+* Turtles now have an :meth:`undo()` method that can roll back actions.
+* Simple support for reacting to input events such as mouse and keyboard
+activity, making it possible to write simple games.
+* A :file:`turtle.cfg` file can be used to customize the starting appearance
+of the turtle's screen.
+* The module's docstrings can be replaced by new docstrings that have been
+translated into another language.
+(:issue:`1513695`)
+* An optional ``timeout`` parameter was added to the
+:func:`urllib.urlopen` function and the
+:class:`urllib.ftpwrapper` class constructor, as well as the
+:func:`urllib2.urlopen` function.  The parameter specifies a timeout
+measured in seconds.   For example::
+>>> u = urllib2.urlopen("http://slow.example.com",
+timeout=3)
+Traceback (most recent call last):
+...
+urllib2.URLError: <urlopen error timed out>
+>>>
+(Added by Facundo Batista.)
+* The Unicode database provided by the :mod:`unicodedata` module
+has been updated to version 5.1.0.  (Updated by
+Martin von Loewis; :issue:`3811`.)
+* The :mod:`warnings` module's :func:`formatwarning` and :func:`showwarning`
+gained an optional *line* argument that can be used to supply the
+line of source code.  (Added as part of :issue:`1631171`, which re-implemented
+part of the :mod:`warnings` module in C code.)
+A new function, :func:`catch_warnings`, is a context manager
+intended for testing purposes that lets you temporarily modify the
+warning filters and then restore their original values (:issue:`3781`).
+* The XML-RPC :class:`SimpleXMLRPCServer` and :class:`DocXMLRPCServer`
+classes can now be prevented from immediately opening and binding to
+their socket by passing True as the ``bind_and_activate``
+constructor parameter.  This can be used to modify the instance's
+:attr:`allow_reuse_address` attribute before calling the
+:meth:`server_bind` and :meth:`server_activate` methods to
+open the socket and begin listening for connections.
+(Contributed by Peter Parente; :issue:`1599845`.)
+:class:`SimpleXMLRPCServer` also has a :attr:`_send_traceback_header`
+attribute; if true, the exception and formatted traceback are returned
+as HTTP headers "X-Exception" and "X-Traceback".  This feature is
+for debugging purposes only and should not be used on production servers
+because the tracebacks might reveal passwords or other sensitive
+information.  (Contributed by Alan McIntyre as part of his
+project for Google's Summer of Code 2007.)
+* The :mod:`xmlrpclib` module no longer automatically converts
+:class:`datetime.date` and :class:`datetime.time` to the
+:class:`xmlrpclib.DateTime` type; the conversion semantics were
+not necessarily correct for all applications.  Code using
+:mod:`xmlrpclib` should convert :class:`date` and :class:`time`
+instances. (:issue:`1330538`)  The code can also handle
+dates before 1900 (contributed by Ralf Schmitt; :issue:`2014`)
+and 64-bit integers represented by using ``<i8>`` in XML-RPC responses
+(contributed by Riku Lindblad; :issue:`2985`).
+* The :mod:`zipfile` module's :class:`ZipFile` class now has
+:meth:`extract` and :meth:`extractall` methods that will unpack
+a single file or all the files in the archive to the current directory, or
+to a specified directory::
+z = zipfile.ZipFile('python-251.zip')
+# Unpack a single file, writing it relative
+# to the /tmp directory.
+z.extract('Python/sysmodule.c', '/tmp')
+# Unpack all the files in the archive.
+z.extractall()
+(Contributed by Alan McIntyre; :issue:`467924`.)
+The :meth:`open`, :meth:`read` and :meth:`extract` methods can now
+take either a filename or a :class:`ZipInfo` object.  This is useful when an
+archive accidentally contains a duplicated filename.
+(Contributed by Graham Horler; :issue:`1775025`.)
+Finally, :mod:`zipfile` now supports using Unicode filenames
+for archived files.  (Contributed by Alexey Borzenkov; :issue:`1734346`.)
+.. ======================================================================
+.. whole new modules get described in subsections here
+The :mod:`ast` module
+----------------------
+The :mod:`ast` module provides an Abstract Syntax Tree
+representation of Python code, and Armin Ronacher
+contributed a set of helper functions that perform a variety of
+common tasks.  These will be useful for HTML templating
+packages, code analyzers, and similar tools that process
+Python code.
+The :func:`parse` function takes an expression and returns an AST.
+The :func:`dump` function outputs a representation of a tree, suitable
+for debugging::
+import ast
+t = ast.parse("""
+d = {}
+for i in 'abcdefghijklm':
+d[i + i] = ord(i) - ord('a') + 1
+print d
+""")
+print ast.dump(t)
+This outputs a deeply nested tree::
+Module(body=[
+Assign(targets=[
+Name(id='d', ctx=Store())
+], value=Dict(keys=[], values=[]))
+For(target=Name(id='i', ctx=Store()),
+iter=Str(s='abcdefghijklm'), body=[
+Assign(targets=[
+Subscript(value=
+Name(id='d', ctx=Load()),
+slice=
+Index(value=
+BinOp(left=Name(id='i', ctx=Load()), op=Add(),
+right=Name(id='i', ctx=Load()))), ctx=Store())
+], value=
+BinOp(left=
+BinOp(left=
+Call(func=
+Name(id='ord', ctx=Load()), args=[
+Name(id='i', ctx=Load())
+], keywords=[], starargs=None, kwargs=None),
+op=Sub(), right=Call(func=
+Name(id='ord', ctx=Load()), args=[
+Str(s='a')
+], keywords=[], starargs=None, kwargs=None)),
+op=Add(), right=Num(n=1)))
+], orelse=[])
+Print(dest=None, values=[
+Name(id='d', ctx=Load())
+], nl=True)
+])
+The :func:`literal_eval` method takes a string or an AST
+representing a literal expression, parses and evaluates it, and
+returns the resulting value.  A literal expression is a Python
+expression containing only strings, numbers, dictionaries,
+etc. but no statements or function calls.  If you need to
+evaluate an expression but cannot accept the security risk of using an
+:func:`eval` call, :func:`literal_eval` will handle it safely::
+>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
+>>> print ast.literal_eval(literal)
+('a', 'b', {1: 2, 2: 4, 3: 8})
+>>> print ast.literal_eval('"a" + "b"')
+Traceback (most recent call last):
+...
+ValueError: malformed string
+The module also includes :class:`NodeVisitor` and
+:class:`NodeTransformer` classes for traversing and modifying an AST,
+and functions for common transformations such as changing line
+numbers.
+.. ======================================================================
+The :mod:`future_builtins` module
+--------------------------------------
+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 :mod:`future_builtins` module provides versions
+of these built-in functions that can be imported when writing
+3.0-compatible code.
+The functions in this module currently include:
+* ``ascii(obj)``: equivalent to :func:`repr`.  In Python 3.0,
+:func:`repr` will return a Unicode string, while :func:`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
+:meth:`__hex__` or :meth:`__oct__` methods, these versions will
+call the :meth:`__index__` method and convert the result to hexadecimal
+or octal.  :func:`oct` will use the new ``0o`` notation for its
+result.
+.. ======================================================================
+The :mod:`json` module: JavaScript Object Notation
+--------------------------------------------------------------------
+The new :mod:`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.
+:mod:`json` comes with support for decoding and encoding most builtin Python
+types. The following example encodes and decodes a dictionary::
+>>> 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}
+It's also possible to write your own decoders and encoders to support
+more types. Pretty-printing of the JSON strings is also supported.
+:mod:`json` (originally called simplejson) was written by Bob
+Ippolito.
+.. ======================================================================
+The :mod:`plistlib` module: A Property-List Parser
+--------------------------------------------------
+The ``.plist`` format is commonly used on Mac OS X to
+store basic data types (numbers, strings, lists,
+and dictionaries) by serializing them into an XML-based format.
+It resembles the XML-RPC serialization of data types.
+Despite being primarily used on Mac OS X, the format
+has nothing Mac-specific about it and the Python implementation works
+on any platform that Python supports, so the :mod:`plistlib` module
+has been promoted to the standard library.
+Using the module is simple::
+import sys
+import plistlib
+import datetime
+# Create data structure
+data_struct = dict(lastAccessed=datetime.datetime.now(),
+version=1,
+categories=('Personal','Shared','Private'))
+# Create string containing XML.
+plist_str = plistlib.writePlistToString(data_struct)
+new_struct = plistlib.readPlistFromString(plist_str)
+print data_struct
+print new_struct
+# Write data structure to a file and read it back.
+plistlib.writePlist(data_struct, '/tmp/customizations.plist')
+new_struct = plistlib.readPlist('/tmp/customizations.plist')
+# read/writePlist accepts file-like objects as well as paths.
+plistlib.writePlist(data_struct, sys.stdout)
+.. ======================================================================
+ctypes Enhancements
+--------------------------------------------------
+Thomas Heller continued to maintain and enhance the
+:mod:`ctypes` module.
+:mod:`ctypes` now supports a :class:`c_bool` datatype
+that represents the C99 ``bool`` type.  (Contributed by David Remahl;
+:issue:`1649190`.)
+The :mod:`ctypes` string, buffer and array types have improved
+support for extended slicing syntax,
+where various combinations of ``(start, stop, step)`` are supplied.
+(Implemented by Thomas Wouters.)
+.. Revision 57769
+All :mod:`ctypes` data types now support
+:meth:`from_buffer` and :meth:`from_buffer_copy`
+methods that create a ctypes instance based on a
+provided buffer object.  :meth:`from_buffer_copy` copies
+the contents of the object,
+while :meth:`from_buffer` will share the same memory area.
+A new calling convention tells :mod:`ctypes` to clear the ``errno`` or
+Win32 LastError variables at the outset of each wrapped call.
+(Implemented by Thomas Heller; :issue:`1798`.)
+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 :func:`DLL` function
+and then call the module-level methods :meth:`set_errno` and
+:meth:`get_errno` to set and retrieve the error value.
+The Win32 LastError variable is similarly supported by
+the :func:`DLL`, :func:`OleDLL`, and :func:`WinDLL` functions.
+You supply ``use_last_error=True`` as a keyword parameter
+and then call the module-level methods :meth:`set_last_error`
+and :meth:`get_last_error`.
+The :func:`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.
+.. ======================================================================
+Improved SSL Support
+--------------------------------------------------
+Bill Janssen made extensive improvements to Python 2.6's support for
+the Secure Sockets Layer by adding a new module, :mod:`ssl`, that's
+built atop the `OpenSSL <http://www.openssl.org/>`__ 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 :mod:`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 :func:`ssl.wrap_socket` function.
+It's possible to specify whether a certificate is required, and to
+obtain certificate info by calling the :meth:`getpeercert` method.
+.. seealso::
+The documentation for the :mod:`ssl` module.
+.. ======================================================================
+Build and C API Changes
+=======================
+Changes to Python's build process and to the C API include:
+* Python now must be compiled with C89 compilers (after 19
+years!).  This means that the Python source tree has dropped its
+own implementations of :cfunc:`memmove` and :cfunc:`strerror`, which
+are in the C89 standard library.
+* Python 2.6 can be built with Microsoft Visual Studio 2008 (version
+9.0), and this is the new default compiler.  See the
+:file:`PCbuild` directory for the build files.  (Implemented by
+Christian Heimes.)
+* On Mac OS X, Python 2.6 can be compiled as a 4-way universal build.
+The :program:`configure` script
+can take a :option:`--with-universal-archs=[32-bit|64-bit|all]`
+switch, controlling whether the binaries are built for 32-bit
+architectures (x86, PowerPC), 64-bit (x86-64 and PPC-64), or both.
+(Contributed by Ronald Oussoren.)
+* The BerkeleyDB module now has a C API object, available as
+``bsddb.db.api``.   This object can be used by other C extensions
+that wish to use the :mod:`bsddb` module for their own purposes.
+(Contributed by Duncan Grisby; :issue:`1551895`.)
+* The new buffer interface, previously described in
+`the PEP 3118 section <#pep-3118-revised-buffer-protocol>`__,
+adds :cfunc:`PyObject_GetBuffer` and :cfunc:`PyBuffer_Release`,
+as well as a few other functions.
+* Python's use of the C stdio library is now thread-safe, or at least
+as thread-safe as the underlying library is.  A long-standing potential
+bug occurred if one thread closed a file object while another thread
+was reading from or writing to the object.  In 2.6 file objects
+have a reference count, manipulated by the
+:cfunc:`PyFile_IncUseCount` and :cfunc:`PyFile_DecUseCount`
+functions.  File objects can't be closed unless the reference count
+is zero.  :cfunc:`PyFile_IncUseCount` should be called while the GIL
+is still held, before carrying out an I/O operation using the
+``FILE *`` pointer, and :cfunc:`PyFile_DecUseCount` should be called
+immediately after the GIL is re-acquired.
+(Contributed by Antoine Pitrou and Gregory P. Smith.)
+* Importing modules simultaneously in two different threads no longer
+deadlocks; it will now raise an :exc:`ImportError`.  A new API
+function, :cfunc:`PyImport_ImportModuleNoBlock`, will look for a
+module in ``sys.modules`` first, then try to import it after
+acquiring an import lock.  If the import lock is held by another
+thread, an :exc:`ImportError` is raised.
+(Contributed by Christian Heimes.)
+* Several functions return information about the platform's
+floating-point support.  :cfunc:`PyFloat_GetMax` returns
+the maximum representable floating point value,
+and :cfunc:`PyFloat_GetMin` returns the minimum
+positive value.  :cfunc:`PyFloat_GetInfo` returns an object
+containing more information from the :file:`float.h` file, such as
+``"mant_dig"`` (number of digits in the mantissa), ``"epsilon"``
+(smallest difference between 1.0 and the next largest value
+representable), and several others.
+(Contributed by Christian Heimes; :issue:`1534`.)
+* C functions and methods that use
+:cfunc:`PyComplex_AsCComplex` will now accept arguments that
+have a :meth:`__complex__` method.  In particular, the functions in the
+:mod:`cmath` module will now accept objects with this method.
+This is a backport of a Python 3.0 change.
+(Contributed by Mark Dickinson; :issue:`1675423`.)
+* Python's C API now includes two functions for case-insensitive string
+comparisons, ``PyOS_stricmp(char*, char*)``
+and ``PyOS_strnicmp(char*, char*, Py_ssize_t)``.
+(Contributed by Christian Heimes; :issue:`1635`.)
+* Many C extensions define their own little macro for adding
+integers and strings to the module's dictionary in the
+``init*`` function.  Python 2.6 finally defines standard macros
+for adding values to a module, :cmacro:`PyModule_AddStringMacro`
+and :cmacro:`PyModule_AddIntMacro()`.  (Contributed by
+Christian Heimes.)
+* Some macros were renamed in both 3.0 and 2.6 to make it clearer that
+they are macros,
+not functions.  :cmacro:`Py_Size()` became :cmacro:`Py_SIZE()`,
+:cmacro:`Py_Type()` became :cmacro:`Py_TYPE()`, and
+:cmacro:`Py_Refcnt()` became :cmacro:`Py_REFCNT()`.
+The mixed-case macros are still available
+in Python 2.6 for backward compatibility.
+(:issue:`1629`)
+* Distutils now places C extensions it builds in a
+different directory when running on a debug version of Python.
+(Contributed by Collin Winter; :issue:`1530959`.)
+* Several basic data types, such as integers and strings, maintain
+internal free lists of objects that can be re-used.  The data
+structures for these free lists now follow a naming convention: the
+variable is always named ``free_list``, the counter is always named
+``numfree``, and a macro ``Py<typename>_MAXFREELIST`` is
+always defined.
+* A new Makefile target, "make patchcheck", prepares the Python source tree
+for making a patch: it fixes trailing whitespace in all modified
+``.py`` files, checks whether the documentation has been changed,
+and reports whether the :file:`Misc/ACKS` and :file:`Misc/NEWS` files
+have been updated.
+(Contributed by Brett Cannon.)
+Another new target, "make profile-opt", compiles a Python binary
+using GCC's profile-guided optimization.  It compiles Python with
+profiling enabled, runs the test suite to obtain a set of profiling
+results, and then compiles using these results for optimization.
+(Contributed by Gregory P. Smith.)
+.. ======================================================================
+Port-Specific Changes: Windows
+-----------------------------------
+* The support for Windows 95, 98, ME and NT4 has been dropped.
+Python 2.6 requires at least Windows 2000 SP4.
+* The new default compiler on Windows is Visual Studio 2008 (version
+9.0). The build directories for Visual Studio 2003 (version 7.1) and
+2005 (version 8.0) were moved into the PC/ directory. The new
+:file:`PCbuild` directory supports cross compilation for X64, debug
+builds and Profile Guided Optimization (PGO). PGO builds are roughly
+10% faster than normal builds.  (Contributed by Christian Heimes
+with help from Amaury Forgeot d'Arc and Martin von Loewis.)
+* The :mod:`msvcrt` module now supports
+both the normal and wide char variants of the console I/O
+API.  The :func:`getwch` function reads a keypress and returns a Unicode
+value, as does the :func:`getwche` function.  The :func:`putwch` function
+takes a Unicode character and writes it to the console.
+(Contributed by Christian Heimes.)
+* :func:`os.path.expandvars` will now expand environment variables in
+the form "%var%", and "~user" will be expanded into the user's home
+directory path.  (Contributed by Josiah Carlson; :issue:`957650`.)
+* The :mod:`socket` module's socket objects now have an
+:meth:`ioctl` method that provides a limited interface to the
+:cfunc:`WSAIoctl` system interface.
+* The :mod:`_winreg` module now has a function,
+:func:`ExpandEnvironmentStrings`,
+that expands environment variable references such as ``%NAME%``
+in an input string.  The handle objects provided by this
+module now support the context protocol, so they can be used
+in :keyword:`with` statements. (Contributed by Christian Heimes.)
+:mod:`_winreg` also has better support for x64 systems,
+exposing the :func:`DisableReflectionKey`, :func:`EnableReflectionKey`,
+and :func:`QueryReflectionKey` functions, which enable and disable
+registry reflection for 32-bit processes running on 64-bit systems.
+(:issue:`1753245`)
+* The :mod:`msilib` module's :class:`Record` object
+gained :meth:`GetInteger` and :meth:`GetString` methods that
+return field values as an integer or a string.
+(Contributed by Floris Bruynooghe; :issue:`2125`.)
+.. ======================================================================
+Port-Specific Changes: Mac OS X
+-----------------------------------
+* When compiling a framework build of Python, you can now specify the
+framework name to be used by providing the
+:option:`--with-framework-name=` option to the
+:program:`configure` script.
+* The :mod:`macfs` module has been removed.  This in turn required the
+:func:`macostools.touched` function to be removed because it depended on the
+:mod:`macfs` module.  (:issue:`1490190`)
+* Many other Mac OS modules have been deprecated and will removed in
+Python 3.0:
+:mod:`_builtinSuites`,
+:mod:`aepack`,
+:mod:`aetools`,
+:mod:`aetypes`,
+:mod:`applesingle`,
+:mod:`appletrawmain`,
+:mod:`appletrunner`,
+:mod:`argvemulator`,
+:mod:`Audio_mac`,
+:mod:`autoGIL`,
+:mod:`Carbon`,
+:mod:`cfmfile`,
+:mod:`CodeWarrior`,
+:mod:`ColorPicker`,
+:mod:`EasyDialogs`,
+:mod:`Explorer`,
+:mod:`Finder`,
+:mod:`FrameWork`,
+:mod:`findertools`,
+:mod:`ic`,
+:mod:`icglue`,
+:mod:`icopen`,
+:mod:`macerrors`,
+:mod:`MacOS`,
+:mod:`macfs`,
+:mod:`macostools`,
+:mod:`macresource`,
+:mod:`MiniAEFrame`,
+:mod:`Nav`,
+:mod:`Netscape`,
+:mod:`OSATerminology`,
+:mod:`pimp`,
+:mod:`PixMapWrapper`,
+:mod:`StdSuites`,
+:mod:`SystemEvents`,
+:mod:`Terminal`, and
+:mod:`terminalcommand`.
+.. ======================================================================
+Port-Specific Changes: IRIX
+-----------------------------------
+A number of old IRIX-specific modules were deprecated and will
+be removed in Python 3.0:
+:mod:`al` and :mod:`AL`,
+:mod:`cd`,
+:mod:`cddb`,
+:mod:`cdplayer`,
+:mod:`CL` and :mod:`cl`,
+:mod:`DEVICE`,
+:mod:`ERRNO`,
+:mod:`FILE`,
+:mod:`FL` and :mod:`fl`,
+:mod:`flp`,
+:mod:`fm`,
+:mod:`GET`,
+:mod:`GLWS`,
+:mod:`GL` and :mod:`gl`,
+:mod:`IN`,
+:mod:`IOCTL`,
+:mod:`jpeg`,
+:mod:`panelparser`,
+:mod:`readcd`,
+:mod:`SV` and :mod:`sv`,
+:mod:`torgb`,
+:mod:`videoreader`, and
+:mod:`WAIT`.
+.. ======================================================================
+Porting to Python 2.6
+=====================
+This section lists previously described changes and other bugfixes
+that may require changes to your code:
+* Classes that aren't supposed to be hashable should
+set ``__hash__ = None`` in their definitions to indicate
+the fact.
+* The :meth:`__init__` method of :class:`collections.deque`
+now clears any existing contents of the deque
+before adding elements from the iterable.  This change makes the
+behavior match ``list.__init__()``.
+* :meth:`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 :exc:`TypeError`.  This will affect
+:meth:`__init__` methods that end up calling the corresponding
+method on :class:`object` (perhaps through using :func:`super`).
+See :issue:`1683368` for discussion.
+* The :class:`Decimal` constructor now accepts leading and trailing
+whitespace when passed a string.  Previously it would raise an
+:exc:`InvalidOperation` exception.  On the other hand, the
+:meth:`create_decimal` method of :class:`Context` objects now
+explicitly disallows extra whitespace, raising a
+:exc:`ConversionSyntax` exception.
+* Due to an implementation accident, if you passed a file path to
+the built-in  :func:`__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 :exc:`ImportError`.
+* C API: the :cfunc:`PyImport_Import` and :cfunc:`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 define their ``tp_hash`` slot to
+:cfunc:`PyObject_HashNotImplemented`.
+* The :mod:`socket` module exception :exc:`socket.error` now inherits
+from :exc:`IOError`.  Previously it wasn't a subclass of
+:exc:`StandardError` but now it is, through :exc:`IOError`.
+(Implemented by Gregory P. Smith; :issue:`1706815`.)
+* The :mod:`xmlrpclib` module no longer automatically converts
+:class:`datetime.date` and :class:`datetime.time` to the
+:class:`xmlrpclib.DateTime` type; the conversion semantics were
+not necessarily correct for all applications.  Code using
+:mod:`xmlrpclib` should convert :class:`date` and :class:`time`
+instances. (:issue:`1330538`)
+* (3.0-warning mode) The :class:`Exception` class now warns
+when accessed using slicing or index access; having
+:class:`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.
+.. ======================================================================
+.. _26acks:
+Acknowledgements
+================
+The author would like to thank the following people for offering
+suggestions, corrections and assistance with various drafts of this
+article: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy,
+Jim Jewett, Kent Johnson, Chris Lambacher,  Martin Michlmayr,
+Antoine Pitrou, Brian Warner.