2070 lines
77 KiB
ReStructuredText
2070 lines
77 KiB
ReStructuredText
****************************
|
|
What's New in Python 2.6
|
|
****************************
|
|
|
|
.. XXX add trademark info for Apple, Microsoft, SourceForge.
|
|
|
|
:Author: A.M. Kuchling
|
|
:Release: |release|
|
|
:Date: |today|
|
|
|
|
.. $Id: whatsnew26.tex 55746 2007-06-02 18:33:53Z neal.norwitz $
|
|
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 as a comment:
|
|
|
|
.. Patch 12345
|
|
XXX Describe the transmogrify() function added to the socket
|
|
module.
|
|
(Contributed by P.Y. Developer.)
|
|
|
|
This saves the maintainer the effort of going through the SVN logs
|
|
when researching a change.
|
|
|
|
This article explains the new features in Python 2.6. No release date for
|
|
Python 2.6 has been set; it will probably be released in mid 2008.
|
|
|
|
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
|
|
complete implementation and design rationale, refer to the PEP for a particular
|
|
new feature.
|
|
|
|
.. 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 2.6 also saw the release of the first
|
|
alphas of Python 3.0, and the development of 3.0 has influenced
|
|
a number of 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 a certain amount of 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.
|
|
|
|
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 ``sys.py3kwarning``,
|
|
and to C extension code as :cdata:`Py_Py3kWarningFlag`.
|
|
|
|
Python 3.0 adds several new built-in functions and change the
|
|
semantics of some existing built-ins. Entirely new functions 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.
|
|
|
|
.. seealso::
|
|
|
|
The 3xxx series of PEPs, which describes the development process for
|
|
Python 3.0 and various features that have been accepted, rejected,
|
|
or are still under consideration.
|
|
|
|
|
|
Development Changes
|
|
==================================================
|
|
|
|
While 2.6 was being developed, the Python development process
|
|
underwent two significant changes: the developer group
|
|
switched from SourceForge's issue tracker to a customized
|
|
Roundup installation, and the documentation was converted from
|
|
LaTeX to reStructured Text.
|
|
|
|
|
|
New Issue Tracker: Roundup
|
|
--------------------------------------------------
|
|
|
|
For a long time, the Python developers have 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: Atlassian's `Jira
|
|
<XXX>`__, `Launchpad <http://www.launchpad.net>`__, ` `Roundup
|
|
<XXX>`__, and Trac <XXX>`__. The committee eventually settled on Jira
|
|
and Roundup as the two candidates. Jira is a commercial product that
|
|
offers a no-cost hosted instance 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.
|
|
|
|
Hosting is kindly provided by `Upfront <XXX>`__ of XXX. Martin von
|
|
Loewis put a lot of effort into importing existing bugs and patches
|
|
from SourceForge; his scripts for this import are at XXX.
|
|
|
|
.. seealso::
|
|
|
|
XXX Roundup web site.
|
|
|
|
bugs.python.org
|
|
|
|
bugs.jython.org
|
|
|
|
Python web site bug tracker
|
|
|
|
|
|
New Documentation Format: ReStructured Text
|
|
--------------------------------------------------
|
|
|
|
Since the Python project's inception around 1989, the documentation
|
|
had been written using LaTeX. At that time, 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 have been
|
|
learned.
|
|
|
|
LaTeX is still used today for writing technical 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 Python documentation editor for many years,
|
|
spent a lot of time wrestling the conversion process into shape.
|
|
Occasionally people would suggest converting the documentation into
|
|
SGML or, later, XML, but performing a good conversion is a major task
|
|
and no one pursued the task to completion.
|
|
|
|
During the 2.6 development cycle, Georg Brandl put a substantial
|
|
effort into building a new toolchain called Sphinx
|
|
for processing the documentation.
|
|
The input format is reStructured Text,
|
|
a markup commonly used in the Python community that supports
|
|
custom extensions and directives. Sphinx concentrates
|
|
on HTML output, producing attractively styled
|
|
and modern HTML, but printed output is still supported through
|
|
conversion to LaTeX as an output format.
|
|
|
|
.. seealso::
|
|
|
|
`Docutils <http://docutils.sf.net>`__: The fundamental
|
|
reStructured Text parser and toolset.
|
|
|
|
:ref:`documenting-index`: Describes how to write for
|
|
Python's documentation.
|
|
|
|
|
|
PEP 343: The 'with' statement
|
|
=============================
|
|
|
|
The previous version, Python 2.5, added the ':keyword:`with`'
|
|
statement 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 "What's New in Python 2.5" document; if you read
|
|
it back when Python 2.5 came out, you can skip the rest of 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 new 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 new :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 new :mod:`contextlib` module provides some functions and a decorator that
|
|
are useful for 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.
|
|
|
|
Our database example from the previous section could be written using this
|
|
decorator 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 in Python 2.6 adds a :attr:`__package__` attribute to modules.
|
|
When 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__`. The :mod:`runpy` module
|
|
that implements the :option:`-m` switch now does this, so relative imports
|
|
can now be used in scripts running from inside a package.
|
|
|
|
.. ======================================================================
|
|
|
|
.. ::
|
|
|
|
.. _pep-0370:
|
|
|
|
PEP 370: XXX
|
|
=====================================================
|
|
|
|
When you run Python, the module search page ``sys.modules`` usually
|
|
includes a directory whose path ends in ``"site-packages"``. This
|
|
directory is intended to hold locally-installed packages available to
|
|
all users on a machine or using a particular site installation.
|
|
|
|
Python 2.6 introduces a convention for user-specific site directories.
|
|
|
|
.. seealso::
|
|
|
|
:pep:`370` - XXX
|
|
|
|
PEP written by XXX; implemented by Christian Heimes.
|
|
|
|
|
|
.. ======================================================================
|
|
|
|
.. _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:`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
|
|
uid = 'root'
|
|
|
|
'User ID: {uid} Last seen: {last_login}'.format(uid='root',
|
|
last_login = '5 Mar 2008 07:20') ->
|
|
'User ID: root Last seen: 5 Mar 2008 07:20'
|
|
|
|
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
|
|
'Platform: {0.platform}\nPython version: {0.version}'.format(sys) ->
|
|
'Platform: darwin\n
|
|
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41) \n
|
|
[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}}'
|
|
fmt.format('Invoice #1234', 15) ->
|
|
'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 complete list (XXX add link, once it's in the 2.6
|
|
docs), but 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', 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 __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 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::
|
|
|
|
:pep:`3101` - Advanced String Formatting
|
|
PEP written by Talin.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _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 easier to replace within a
|
|
module 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 the following::
|
|
|
|
try:
|
|
...
|
|
except TypeError, ValueError:
|
|
...
|
|
|
|
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 correct code
|
|
would have specified a tuple::
|
|
|
|
try:
|
|
...
|
|
except (TypeError, ValueError):
|
|
...
|
|
|
|
This error is possible 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 changes the syntax to make 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.
|
|
|
|
.. 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.
|
|
|
|
.. seealso::
|
|
|
|
:pep:`3112` - Bytes literals in Python 3000
|
|
PEP written by Jason Orendorff; backported to 2.6 by Christian Heimes.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _pep-3118:
|
|
|
|
PEP 3118: Revised Buffer Protocol
|
|
=====================================================
|
|
|
|
The buffer protocol is a C-level API that lets Python extensions
|
|
XXX
|
|
|
|
.. seealso::
|
|
|
|
:pep:`3118` - Revising the buffer protocol
|
|
PEP written by Travis Oliphant and Carl Banks.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _pep-3119:
|
|
|
|
PEP 3119: Abstract Base Classes
|
|
=====================================================
|
|
|
|
XXX write this -- this section is currently just brief notes.
|
|
|
|
How to identify a file object?
|
|
|
|
ABCs are a collection of classes describing various interfaces.
|
|
Classes can derive from an ABC to indicate they support that ABC's
|
|
interface. Concrete classes should obey the semantics specified by
|
|
an ABC, but Python can't check this; it's up to the implementor.
|
|
|
|
A metaclass lets you declare that an existing class or type
|
|
derives from a particular ABC. You can even
|
|
|
|
class AppendableSequence:
|
|
__metaclass__ = ABCMeta
|
|
|
|
AppendableSequence.register(list)
|
|
assert issubclass(list, AppendableSequence)
|
|
assert isinstance([], AppendableSequence)
|
|
|
|
@abstractmethod decorator -- you can't instantiate classes w/
|
|
an abstract method.
|
|
|
|
::
|
|
|
|
@abstractproperty decorator
|
|
@abstractproperty
|
|
def readonly(self):
|
|
return self._x
|
|
|
|
|
|
.. seealso::
|
|
|
|
:pep:`3119` - Introducing Abstract Base Classes
|
|
PEP written by Guido van Rossum and Talin.
|
|
Implemented by XXX.
|
|
Backported to 2.6 by Benjamin Aranguren, with Alex Martelli.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _pep-3127:
|
|
|
|
PEP 3127: Integer Literal Support and Syntax
|
|
=====================================================
|
|
|
|
XXX write this -- this section is currently just brief notes.
|
|
|
|
Python 3.0 changes the syntax for octal integer literals, and
|
|
adds supports for binary integers: 0o instad of 0,
|
|
and 0b for binary. Python 2.6 doesn't support this, but a bin()
|
|
builtin was added.
|
|
|
|
XXX changes to the hex/oct builtins
|
|
|
|
|
|
New bin() built-in returns the binary form of a number.
|
|
|
|
.. seealso::
|
|
|
|
:pep:`3127` - Integer Literal Support and Syntax
|
|
PEP written by Patrick Maupin.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _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))
|
|
|
|
XXX need to find a good motivating example.
|
|
|
|
.. seealso::
|
|
|
|
:pep:`3129` - Class Decorators
|
|
PEP written by Collin Winter.
|
|
|
|
.. ======================================================================
|
|
|
|
.. _pep-3141:
|
|
|
|
PEP 3141: A Type Hierarchy for Numbers
|
|
=====================================================
|
|
|
|
In Python 3.0, several abstract base classes for numeric types,
|
|
inspired by Scheme's numeric tower, are being added.
|
|
This change was 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)``.
|
|
|
|
Numbers are further divided into :class:`Exact` and :class:`Inexact`.
|
|
Exact numbers can represent values precisely and operations never
|
|
round off the results or introduce tiny errors that may break the
|
|
commutativity and associativity properties; inexact numbers may
|
|
perform such rounding or introduce small errors. Integers, long
|
|
integers, and rational numbers are exact, while floating-point
|
|
and complex numbers are inexact.
|
|
|
|
: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.
|
|
|
|
XXX link: Discusses Scheme's numeric tower.
|
|
|
|
|
|
|
|
The :mod:`fractions` Module
|
|
--------------------------------------------------
|
|
|
|
To fill out the hierarchy of numeric types, a rational-number class
|
|
has been added as the :mod:`fractions` module. Rational numbers are
|
|
represented as a fraction, and can exactly represent
|
|
numbers such as two-thirds 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)
|
|
|
|
To help in converting floating-point numbers to rationals,
|
|
the float type now has a :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
|
|
======================
|
|
|
|
Here are all of the changes that Python 2.6 makes to the core Python language.
|
|
|
|
* 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']
|
|
|
|
.. Patch 1686487
|
|
|
|
* The built-in types now have improved support for extended slicing syntax,
|
|
where various combinations of ``(start, stop, step)`` are supplied.
|
|
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 useful shortcuts for
|
|
adding or modifying 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
|
|
|
|
|
|
* 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.)
|
|
|
|
.. Patch #1675423
|
|
|
|
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.
|
|
|
|
.. Patch 1507
|
|
|
|
* More floating-point features were also added. The :func:`float` function
|
|
will now turn the strings ``+nan`` and ``-nan`` into the corresponding
|
|
IEEE 754 Not A Number values, and ``+inf`` and ``-inf`` into
|
|
positive or negative infinity. This works on any platform with
|
|
IEEE 754 semantics. (Contributed by Christian Heimes.)
|
|
|
|
.. Patch 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.
|
|
|
|
.. Patch 1640
|
|
|
|
The ``math.copysign(x, y)`` function
|
|
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.)
|
|
|
|
* 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.)
|
|
|
|
.. Patch #1537
|
|
|
|
* Generator objects now have a :attr:`gi_code` attribute that refers to
|
|
the original code object backing the generator.
|
|
(Contributed by Collin Winter.)
|
|
|
|
.. Patch #1473257
|
|
|
|
* The :func:`compile` built-in function now accepts keyword arguments
|
|
as well as positional parameters. (Contributed by Thomas Wouters.)
|
|
|
|
.. Patch 1444529
|
|
|
|
* The :func:`complex` constructor now accepts strings containing
|
|
parenthesized complex numbers, letting ``complex(repr(cmplx))``
|
|
will now round-trip values. For example, ``complex('(3+4j)')``
|
|
now returns the value (3+4j).
|
|
|
|
.. Patch 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.)
|
|
|
|
.. Patch 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.
|
|
|
|
.. Patch 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; they're 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 referred to in the
|
|
:keyword:`class` statement that aren't attributes of the class.)
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
Optimizations
|
|
-------------
|
|
|
|
* Type objects now have a cache of methods that can reduce
|
|
the amount of 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.)
|
|
|
|
.. Patch 1700288
|
|
|
|
* 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.)
|
|
|
|
* Internally, a bit is now set in type objects to indicate some of the standard
|
|
built-in types. This speeds up checking if an object is a subclass of one of
|
|
these types. (Contributed by Neal Norwitz.)
|
|
|
|
* Unicode strings now uses 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 OS sooner.
|
|
|
|
The net result of the 2.6 optimizations is that Python 2.6 runs the pystone
|
|
benchmark around XX% faster than Python 2.5.
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
New, Improved, and Deprecated Modules
|
|
=====================================
|
|
|
|
As usual, 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 CVS logs for all the details.
|
|
|
|
* The :mod:`bsddb.dbshelve` module now uses the highest pickling protocol
|
|
available, instead of restricting itself to protocol 1.
|
|
(Contributed by W. Barnes.)
|
|
|
|
.. Patch 1551443
|
|
|
|
* 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)
|
|
|
|
Where the new :class:`namedtuple` type proved suitable, the standard
|
|
library has been modified to return them. 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:`ctypes` module now supports a :class:`c_bool` datatype
|
|
that represents the C99 ``bool`` type. (Contributed by David Remahl.)
|
|
|
|
.. Patch 1649190
|
|
|
|
The :mod:`ctypes` string, buffer and array types also have improved
|
|
support for extended slicing syntax,
|
|
where various combinations of ``(start, stop, step)`` are supplied.
|
|
(Implemented by Thomas Wouters.)
|
|
|
|
.. Revision 57769
|
|
|
|
* A new method in the :mod:`curses` module: for a window, :meth:`chgat` changes
|
|
the display characters 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 XXX.)
|
|
|
|
.. Patch 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.
|
|
In addition to behaving like tuples, the returned values
|
|
also have :attr:`a`, :attr:`b`, and :attr:`size` attributes.
|
|
(Contributed by Raymond Hettinger.)
|
|
|
|
* An optional ``timeout`` parameter was added to the
|
|
:class:`ftplib.FTP` class constructor as well as the :meth:`connect`
|
|
method, specifying a timeout measured in seconds. (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.)
|
|
|
|
.. Patch 1221598
|
|
|
|
* The :func:`reduce` built-in function is also available in the
|
|
:mod:`functools` module. In Python 3.0, the built-in is dropped and it's
|
|
only available from :mod:`functools`; currently there are no plans
|
|
to drop the built-in in the 2.x series. (Patched by
|
|
Christian Heimes.)
|
|
|
|
.. Patch 1739906
|
|
|
|
* The :func:`glob.glob` function can now return Unicode filenames if
|
|
a Unicode path was used and Unicode filenames are matched within the directory.
|
|
|
|
.. Patch #1001604
|
|
|
|
* The :mod:`gopherlib` module has been removed.
|
|
|
|
* A new function in the :mod:`heapq` module: ``merge(iter1, iter2, ...)``
|
|
takes any number of iterables that return data *in sorted
|
|
order*, and returns a new iterator that returns the contents of all
|
|
the iterators, also in sorted order. For example::
|
|
|
|
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`.
|
|
|
|
(Contributed by Raymond Hettinger.)
|
|
|
|
* An optional ``timeout`` parameter was added to the
|
|
:class:`httplib.HTTPConnection` and :class:`HTTPSConnection`
|
|
class constructors, specifying a timeout measured in seconds.
|
|
(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::
|
|
|
|
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. ::
|
|
|
|
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::
|
|
|
|
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. ::
|
|
|
|
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*. ::
|
|
|
|
itertools.combinations('123', 2) ->
|
|
[('1', '2'), ('1', '3'), ('2', '3')]
|
|
|
|
itertools.combinations('123', 3) ->
|
|
[('1', '2', '3')]
|
|
|
|
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.
|
|
|
|
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. ::
|
|
|
|
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 its constructor. If *delay*
|
|
is true, opening of the log file is deferred until the first
|
|
:meth:`emit` call is made. (Contributed by Vinay Sajip.)
|
|
|
|
* 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.
|
|
|
|
.. Patch #1490190
|
|
|
|
* :class:`mmap` objects now have a :meth:`rfind` method that finds
|
|
a substring, beginning at the end of the string and searching
|
|
backwards. The :meth:`find` method
|
|
also gained an *end* parameter containing the index at which to stop
|
|
the forward search.
|
|
(Contributed by John Lenton.)
|
|
|
|
* (3.0-warning mode) The :mod:`new` module has been removed from
|
|
Python 3.0. Importing it therefore triggers a warning message.
|
|
|
|
* 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.)
|
|
|
|
* New functions in the :mod:`os` module include
|
|
``fchmod(fd, mode)``, ``fchown(fd, uid, gid)``,
|
|
and ``lchmod(path, mode)``, on operating systems that support these
|
|
functions. :func:`fchmod` and :func:`fchown` let you change the mode
|
|
and ownership of an opened file, and :func:`lchmod` changes the mode
|
|
of a symlink.
|
|
|
|
(Contributed by Georg Brandl and Christian Heimes.)
|
|
|
|
* 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.
|
|
|
|
.. Patch 1273829
|
|
|
|
* 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.)
|
|
|
|
.. Patch #1181
|
|
|
|
* 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')``.
|
|
|
|
.. Bug #115886
|
|
|
|
A new function, :func:`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.)
|
|
|
|
.. Patch 1339796
|
|
|
|
On Windows, :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.)
|
|
|
|
.. Patch 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.)
|
|
|
|
.. Patch #1393667
|
|
|
|
* 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.)
|
|
|
|
* New functions in the :mod:`posix` module: :func:`chflags` and :func:`lchflags`
|
|
are wrappers for the corresponding system calls (where they're available).
|
|
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.)
|
|
|
|
.. Patch #1663329
|
|
|
|
* 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.)
|
|
|
|
.. Patch 1137
|
|
|
|
* The :mod:`Queue` module now provides queue classes 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 mode, the most frequently occurring value
|
|
in the distribution. (Contributed by Raymond Hettinger. XXX check)
|
|
|
|
.. Patch 1681432
|
|
|
|
* Long regular expression searches carried out by the :mod:`re`
|
|
module will now check for signals being delivered, so especially
|
|
long searches can now be interrupted.
|
|
(Contributed by Josh Hoyt and Ralf Schmitt.)
|
|
|
|
.. Patch 846388
|
|
|
|
* The :mod:`rgbimg` module has been removed.
|
|
|
|
* 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 XXX check.)
|
|
|
|
.. Patch 1861
|
|
|
|
* The :mod:`select` module now has wrapper functions
|
|
for the Linux :cfunc:`epoll` and BSD :cfunc:`kqueue` system calls.
|
|
Also, a :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,
|
|
|
|
(Contributed by XXX.)
|
|
|
|
.. Patch 1657
|
|
|
|
* The :mod:`sets` module has been deprecated; it's better to
|
|
use the built-in :class:`set` and :class:`frozenset` types.
|
|
|
|
* 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.
|
|
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 writeable 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, without the need to poll.
|
|
|
|
(Contributed by Adam Olsen.)
|
|
|
|
.. Patch 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 :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. Both
|
|
class constructors also have an optional ``timeout`` parameter
|
|
that specifies a timeout for the initial connection attempt, measured in
|
|
seconds.
|
|
|
|
An implementation of the LMTP protocol (:rfc:`2033`) was also added to
|
|
the module. LMTP is used in place of SMTP when transferring e-mail
|
|
between agents that don't manage a mail queue.
|
|
|
|
(SMTP over SSL contributed by Monty Taylor; timeout parameter
|
|
added by Facundo Batista; LMTP implemented by Leif
|
|
Hedstrom.)
|
|
|
|
.. Patch #957003
|
|
|
|
* In the :mod:`smtplib` module, 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.)
|
|
|
|
.. Patch #1646
|
|
|
|
* 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.)
|
|
|
|
.. Patch #742598
|
|
|
|
* The :mod:`struct` module now supports the C99 :ctype:`_Bool` type,
|
|
using the format character ``'?'``.
|
|
(Contributed by David Remahl.)
|
|
|
|
* A new variable in the :mod:`sys` module,
|
|
:attr:`float_info`, is an object
|
|
containing information about the platform's floating-point support
|
|
derived from the :file:`float.h` file. 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.)
|
|
|
|
.. Patch 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 are available as attributes of a ``sys.flags`` named
|
|
tuple. 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.)
|
|
|
|
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.)
|
|
|
|
.. Patch #1648
|
|
|
|
* The :mod:`tarfile` module now supports POSIX.1-2001 (pax) and
|
|
POSIX.1-1988 (ustar) format tarfiles, in addition to the GNU tar
|
|
format that was 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 ``errors`` parameter lets you specify an error handling
|
|
scheme for character conversions: the three standard ways Python can
|
|
handle errors ``'strict'``, ``'ignore'``, ``'replace'`` , or the
|
|
special value ``'utf-8'``, which 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 a ``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.)
|
|
|
|
.. Patch #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 now contains a
|
|
:func:`EnvironmentVarGuard`
|
|
context manager that supports temporarily changing 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')
|
|
...
|
|
|
|
(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.)
|
|
|
|
.. Patch #1581073
|
|
|
|
* 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.)
|
|
|
|
.. Patch #1533909
|
|
|
|
* 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 XML-RPC classes :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.)
|
|
|
|
.. Patch 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 could possibly reveal passwords or other sensitive
|
|
information. (Contributed by Alan McIntyre as part of his
|
|
project for Google's Summer of Code 2007.)
|
|
|
|
* 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.)
|
|
|
|
.. Patch 467924
|
|
|
|
.. ======================================================================
|
|
.. whole new modules get described in subsections here
|
|
|
|
Improved SSL Support
|
|
--------------------------------------------------
|
|
|
|
Bill Janssen made extensive improvements to Python 2.6's support for
|
|
SSL.
|
|
|
|
XXX use ssl.sslsocket - subclass of socket.socket.
|
|
|
|
XXX Can specify if certificate is required, and obtain certificate info
|
|
by calling getpeercert method.
|
|
|
|
XXX sslwrap() behaves like socket.ssl
|
|
|
|
XXX Certain features require the OpenSSL package to be installed, notably
|
|
the 'openssl' binary.
|
|
|
|
.. seealso::
|
|
|
|
SSL module documentation.
|
|
|
|
|
|
.. ======================================================================
|
|
|
|
plistlib: A Property-List Parser
|
|
--------------------------------------------------
|
|
|
|
A commonly-used format on MacOS X is the ``.plist`` format,
|
|
which stores basic data types (numbers, strings, lists,
|
|
and dictionaries) and serializes them into an XML-based format.
|
|
(It's a lot like the XML-RPC serialization of data types.)
|
|
|
|
Despite being primarily used on MacOS 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)
|
|
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
Build and C API Changes
|
|
=======================
|
|
|
|
Changes to Python's build process and to the C API include:
|
|
|
|
* Python 2.6 can be built with Microsoft Visual Studio 2008.
|
|
See the :file:`PCbuild9` directory for the build files.
|
|
(Implemented by Christian Heimes.)
|
|
|
|
* Python now can only be compiled with C89 compilers (after 19
|
|
years!). This means that the Python source tree can now drop its
|
|
own implementations of :cfunc:`memmove` and :cfunc:`strerror`, which
|
|
are in the C89 standard library.
|
|
|
|
* 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.)
|
|
|
|
.. Patch 1551895
|
|
|
|
* 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 a dictionary
|
|
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
|
|
|
|
* 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
|
|
|
|
* 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.)
|
|
|
|
.. Patch 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 :cmacro:`Py<typename>_MAXFREELIST` is
|
|
always defined.
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
Port-Specific Changes: Windows
|
|
-----------------------------------
|
|
|
|
* 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.)
|
|
|
|
* 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.)
|
|
|
|
* The new default compiler on Windows is Visual Studio 2008 (VS 9.0). The
|
|
build directories for Visual Studio 2003 (VS7.1) and 2005 (VS8.0)
|
|
were moved into the PC/ directory. The new 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.)
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
.. _section-other:
|
|
|
|
Other Changes and Fixes
|
|
=======================
|
|
|
|
As usual, there were a bunch of other improvements and bugfixes
|
|
scattered throughout the source tree. A search through the change
|
|
logs finds there were XXX patches applied and YYY bugs fixed between
|
|
Python 2.5 and 2.6. Both figures are likely to be underestimates.
|
|
|
|
Some of the more notable changes are:
|
|
|
|
* It's now possible to prevent Python from writing any :file:`.pyc`
|
|
or :file:`.pyo` files by either supplying the :option:`-B` switch
|
|
or setting the :envvar:`PYTHONDONTWRITEBYTECODE` environment variable
|
|
to any non-empty string when running the Python interpreter. These
|
|
are also used to set the :data:`sys.dont_write_bytecode` attribute;
|
|
Python code can change this variable to control whether bytecode
|
|
files are subsequently written.
|
|
(Contributed by Neal Norwitz and Georg Brandl.)
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
Porting to Python 2.6
|
|
=====================
|
|
|
|
This section lists previously described changes and other bugfixes
|
|
that may require changes to your code:
|
|
|
|
* 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 that of ``list.__init__()``.
|
|
|
|
* 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`.
|
|
|
|
* 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.
|
|
|
|
.. ======================================================================
|
|
|
|
|
|
.. _acks:
|
|
|
|
Acknowledgements
|
|
================
|
|
|
|
The author would like to thank the following people for offering suggestions,
|
|
corrections and assistance with various drafts of this article: .
|
|
|