| **************************** |
| What's New in Python 2.6 |
| **************************** |
| |
| .. % XXX mention switch to reST for documentation |
| .. % XXX mention switch to Roundup for bug tracking |
| |
| :Author: A.M. Kuchling |
| :Release: |release| |
| :Date: |today| |
| |
| .. % $Id: whatsnew26.tex 55963 2007-06-13 18:07:49Z guido.van.rossum $ |
| .. % 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 log |
| .. % 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 |
| ================ |
| |
| .. % XXX add general comment about Python 3.0 features in 2.6 |
| |
| 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. |
| |
| .. 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. |
| |
| 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-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-3119: |
| |
| PEP 3119: Abstract Base Classes |
| ===================================================== |
| |
| XXX |
| |
| .. 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). |
| |
| 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 |
| |
| * 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 |
| |
| * 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 :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 |
| |
| * 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 |
| ------------- |
| |
| * 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.) |
| |
| 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) |
| |
| (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. |
| :: |
| |
| # Boldface text starting at y=0,x=21 |
| # and affecting the rest of the line. |
| stdscr.chgat(0,21, curses.A_BOLD) |
| |
| (Contributed by Fabian Kreutz.) |
| |
| * 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") |
| |
| (Implemented by Facundo Batista and Mark Dickinson.) |
| |
| * 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.) |
| |
| * 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] |
| |
| (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.) |
| |
| * A new function in the :mod:`itertools` module: ``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)] |
| |
| (Contributed by Raymond Hettinger.) |
| |
| * 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 |
| |
| * 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 |
| |
| * 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.) |
| |
| * The :mod:`rgbimg` module has been removed. |
| |
| * The :mod:`sets` module has been deprecated; it's better to |
| use the built-in :class:`set` and :class:`frozenset` types. |
| |
| * 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 |
| |
| * 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 |
| |
| * 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. |
| >>> |
| |
| .. % 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.) |
| |
| .. % ====================================================================== |
| .. % 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. |
| |
| .. % ====================================================================== |
| |
| |
| 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.) |
| |
| * 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 |
| |
| |
| .. % ====================================================================== |
| |
| |
| Port-Specific Changes |
| --------------------- |
| |
| Platform-specific changes go here. |
| |
| .. % ====================================================================== |
| |
| |
| .. _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: |
| |
| * Details will go here. |
| |
| .. % ====================================================================== |
| |
| |
| Porting to Python 2.6 |
| ===================== |
| |
| This section lists previously described changes that may require changes to your |
| code: |
| |
| * 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.) |
| |
| .. % http://bugs.python.org/issue1706815 |
| |
| .. % ====================================================================== |
| |
| |
| .. _acks: |
| |
| Acknowledgements |
| ================ |
| |
| The author would like to thank the following people for offering suggestions, |
| corrections and assistance with various drafts of this article: . |
| |