traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

More edits

This commit is contained in:
Andrew M. Kuchling 2008-08-31 02:24:08 +00:00
parent eaa29bb238
commit 4d028570c7
1 changed files with 57 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
Doc/whatsnew/2.6.rst
View File

@ -94,7 +94,7 @@ 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
code will need some conversion in order to run on
Python 3.0. However, not all the changes in 3.0 necessarily break
compatibility. In cases where new features won't cause existing code
to break, they've been backported to 2.6 and are described in this
@ -1359,9 +1359,9 @@ This is equivalent to::
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.
Python 3.0 adds several abstract base classes for numeric types
inspired by Scheme's numeric tower. These classes were backported to
2.6 as the :mod:`numbers` module.
The most general ABC is :class:`Number`. It defines no operations at
all, and only exists to allow checking if an object is a number by
@ -1409,8 +1409,8 @@ one, :func:`math.trunc`, that's been backported to Python 2.6.
The :mod:`fractions` Module
--------------------------------------------------
To fill out the hierarchy of numeric types, a rational-number class is
provided by the :mod:`fractions` module. Rational numbers store their
To fill out the hierarchy of numeric types, the :mod:`fractions`
module provides a rational-number class. Rational numbers store their
values as a numerator and denominator forming a fraction, and can
exactly represent numbers such as ``2/3`` that floating-point numbers
can only approximate.
@ -1428,8 +1428,8 @@ that will be the numerator and denominator of the resulting fraction. ::
>>> 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
For converting floating-point numbers to rationals,
the float type now has an :meth:`as_integer_ratio()` method that returns
the numerator and denominator for a fraction that evaluates to the same
floating-point value::
@ -1454,11 +1454,11 @@ Yasskin.
Other Language Changes
======================
Here are all of the changes that Python 2.6 makes to the core Python language.
Some smaller changes made to the core Python language are:
* The :func:`hasattr` function was catching and ignoring all errors,
under the assumption that they meant a :meth:`__getattr__` method
was failing somewhere and the return value of :func:`hasattr` would
was failing somehow and the return value of :func:`hasattr` would
therefore be ``False``. This logic shouldn't be applied to
:exc:`KeyboardInterrupt` and :exc:`SystemExit`, however; Python 2.6
will no longer discard such exceptions when :func:`hasattr`
@ -1479,7 +1479,7 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
(Contributed by Alexander Belopolsky; :issue:`1686487`.)
It's also now legal to provide keyword arguments after a ``*args`` argument
It's also become legal to provide keyword arguments after a ``*args`` argument
to a function call.
>>> def f(*args, **kw):
@ -1491,31 +1491,34 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
Previously this would have been a syntax error.
(Contributed by Amaury Forgeot d'Arc; :issue:`3473`.)
* A new built-in, ``next(*iterator*, [*default*])`` returns the next item
* A new built-in, ``next(iterator, [default])`` returns the next item
from the specified iterator. If the *default* argument is supplied,
it will be returned if *iterator* has been exhausted; otherwise,
the :exc:`StopIteration` exception will be raised. (:issue:`2719`)
the :exc:`StopIteration` exception will be raised. (Backported
in :issue:`2719`.)
* Tuples now have :meth:`index` and :meth:`count` methods matching the
list type's :meth:`index` and :meth:`count` methods::
>>> t = (0,1,2,3,4)
>>> t = (0,1,2,3,4,0,1,2)
>>> t.index(3)
3
>>> t.count(0)
2
(Contributed by Raymond Hettinger)
* The built-in types now have improved support for extended slicing syntax,
where various combinations of ``(start, stop, step)`` are supplied.
accepting various combinations of ``(start, stop, step)``.
Previously, the support was partial and certain corner cases wouldn't work.
(Implemented by Thomas Wouters.)
.. Revision 57619
* Properties now have three attributes, :attr:`getter`,
:attr:`setter` and :attr:`deleter`, that are useful shortcuts for
adding or modifying a getter, setter or deleter function to an
existing property. You would use them like this::
* Properties now have three attributes, :attr:`getter`, :attr:`setter`
and :attr:`deleter`, that are decorators providing useful shortcuts
for adding a getter, setter or deleter function to an existing
property. You would use them like this::
class C(object):
@property
@ -1555,12 +1558,7 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
(Contributed by Raymond Hettinger.)
* A numerical nicety: when creating a complex number from two floats
on systems that support signed zeros (-0 and +0), the
:func:`complex` constructor will now preserve the sign
of the zero. (Fixed by Mark T. Dickinson; :issue:`1507`)
* More floating-point features were also added. The :func:`float` function
* Many floating-point features were added. The :func:`float` function
will now turn the string ``nan`` into an
IEEE 754 Not A Number value, and ``+inf`` and ``-inf`` into
positive or negative infinity. This works on any platform with
@ -1571,7 +1569,7 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
infinite or Not A Number. (:issue:`1640`)
Conversion functions were added to convert floating-point numbers
into hexadecimal strings. (:issue:`3008`) These functions lets you
into hexadecimal strings (:issue:`3008`). These functions
convert floats to and from a string representation without
introducing rounding errors from the conversion between decimal and
binary. Floats have a :meth:`hex` method that returns a string
@ -1587,11 +1585,7 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
>>> b.hex()
'0x1.5555555555555p-2'
* The :mod:`math` module has a number of new functions, and the existing
functions have been improved to give more consistent behaviour
across platforms, especially with respect to handling of
floating-point exceptions and IEEE 754 special values.
The new functions are:
* Several new functions were added to the :mod:`math` module:
* :func:`~math.isinf` and :func:`~math.isnan` determine whether a given float
is a (positive or negative) infinity or a NaN (Not a Number), respectively.
@ -1605,32 +1599,40 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
(Contributed by Raymond Hettinger; :issue:`2138`.)
* :func:`~math.fsum` adds up the stream of numbers from an iterable,
and is careful to avoid loss of precision by calculating partial sums.
and is careful to avoid loss of precision through using partial sums.
(Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson;
:issue:`2819`.)
* The inverse hyperbolic functions :func:`~math.acosh`, :func:`~math.asinh`
and :func:`~math.atanh`.
* :func:`~math.acosh`, :func:`~math.asinh`
and :func:`~math.atanh` compute the inverse hyperbolic functions.
* The function :func:`~math.log1p`, returning the natural logarithm of *1+x*
* The function :func:`~math.log1p` returns the natural logarithm of *1+x*
(base *e*).
There's also a new :func:`trunc` built-in function as a result of the
There's also a new :func:`trunc` built-in function from the
backport of `PEP 3141's type hierarchy for numbers <#pep-3141>`__.
The existing math functions have been modified to follow the
recommendations of the C99 standard with respect to special values
whenever possible. For example, ``sqrt(-1.)`` should now give a
:exc:`ValueError` across (nearly) all platforms, while
``sqrt(float('NaN'))`` should return a NaN on all IEEE 754
* The :mod:`math` module has been improved to give more consistent
behaviour across platforms, especially with respect to handling of
floating-point exceptions and IEEE 754 special values.
Whenever possible, the module follows the recommendations of the C99
standard about 754's special values. For example, ``sqrt(-1.)``
should now give a :exc:`ValueError` across almost all platforms,
while ``sqrt(float('NaN'))`` should return a NaN on all IEEE 754
platforms. Where Annex 'F' of the C99 standard recommends signaling
'divide-by-zero' or 'invalid', Python will raise :exc:`ValueError`.
Where Annex 'F' of the C99 standard recommends signaling 'overflow',
Python will raise :exc:`OverflowError`. (See :issue:`711019`,
Python will raise :exc:`OverflowError`. (See :issue:`711019` and
:issue:`1640`.)
(Contributed by Christian Heimes and Mark Dickinson.)
* Another numerical nicety: when creating a complex number from two floats
on systems that support signed zeros (-0 and +0), the
:func:`complex` constructor will now preserve the sign
of the zero. (Fixed by Mark T. Dickinson; :issue:`1507`.)
* 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
@ -1651,7 +1653,7 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
:issue:`1444529`.)
* The :func:`complex` constructor now accepts strings containing
parenthesized complex numbers, letting ``complex(repr(cmplx))``
parenthesized complex numbers, meaning that ``complex(repr(cplx))``
will now round-trip values. For example, ``complex('(3+4j)')``
now returns the value (3+4j). (:issue:`1491866`)
@ -1672,11 +1674,11 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
* 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.
The old names are still supported in Python 2.6, but are gone in 3.0.
* An obscure change: when you use the the :func:`locals` function inside a
:keyword:`class` statement, the resulting dictionary no longer returns free
variables. (Free variables, in this case, are variables referred to in the
variables. (Free variables, in this case, are variables referenced in the
:keyword:`class` statement that aren't attributes of the class.)
.. ======================================================================
@ -1691,7 +1693,7 @@ Optimizations
(Contributed by Neal Norwitz and Brett Cannon; :issue:`1631171`.)
* Type objects now have a cache of methods that can reduce
the amount of work required to find the correct method implementation
the work required to find the correct method implementation
for a particular class; once cached, the interpreter doesn't need to
traverse base classes to figure out the right method to call.
The cache is cleared if a base class or the class itself is modified,
@ -1711,19 +1713,18 @@ Optimizations
but it's impossible for the Python interpreter to determine that.
See :issue:`1878` for some discussion.)
* Function calls that use keyword arguments
are significantly faster thanks to a patch that does a quick pointer
comparison, usually saving the time of a full string comparison.
(Contributed by Raymond Hettinger, after an initial implementation by
Antoine Pitrou; :issue:`1819`.)
* Function calls that use keyword arguments are significantly faster
by doing a quick pointer comparison, usually saving the time of a
full string comparison. (Contributed by Raymond Hettinger, after an
initial implementation by Antoine Pitrou; :issue:`1819`.)
* All of the functions in the :mod:`struct` module have been rewritten in
C, thanks to work at the Need For Speed sprint.
(Contributed by Raymond Hettinger.)
* 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.)
* Some of the standard built-in types now set a bit in their type
objects. This speeds up checking whether an object is a subclass of
one of these types. (Contributed by Neal Norwitz.)
* Unicode strings now use faster code for detecting
whitespace and line breaks; this speeds up the :meth:`split` method
@ -2202,7 +2203,7 @@ details.
* 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
functions. :func:`fchmod` and :func:`fchown` change the mode
and ownership of an opened file, and :func:`lchmod` changes the mode
of a symlink.
@ -2487,7 +2488,7 @@ details.
tar = tarfile.open("output.tar", "w", format=tarfile.PAX_FORMAT)
The new ``errors`` parameter lets you specify an error handling
The new ``errors`` parameter specifies 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