Merged revisions 61209-61214,61217-61222,61224-61226,61233-61237 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r61209 | georg.brandl | 2008-03-03 21:37:55 +0100 (Mon, 03 Mar 2008) | 2 lines
There are now sixteen isfoo functions.
........
r61210 | georg.brandl | 2008-03-03 21:39:00 +0100 (Mon, 03 Mar 2008) | 2 lines
15 -> 16, the 2nd
........
r61211 | georg.brandl | 2008-03-03 22:22:47 +0100 (Mon, 03 Mar 2008) | 2 lines
Actually import itertools.
........
r61212 | georg.brandl | 2008-03-03 22:31:50 +0100 (Mon, 03 Mar 2008) | 2 lines
Expand a bit on genexp scopes.
........
r61213 | raymond.hettinger | 2008-03-03 23:04:55 +0100 (Mon, 03 Mar 2008) | 1 line
Remove dependency on itertools -- a simple genexp suffices.
........
r61214 | raymond.hettinger | 2008-03-03 23:19:58 +0100 (Mon, 03 Mar 2008) | 1 line
Issue 2226: Callable checked for the wrong abstract method.
........
r61217 | andrew.kuchling | 2008-03-04 01:40:32 +0100 (Tue, 04 Mar 2008) | 1 line
Typo fix
........
r61218 | andrew.kuchling | 2008-03-04 02:30:10 +0100 (Tue, 04 Mar 2008) | 1 line
Grammar fix; markup fix
........
r61219 | andrew.kuchling | 2008-03-04 02:47:38 +0100 (Tue, 04 Mar 2008) | 1 line
Fix sentence fragment
........
r61220 | andrew.kuchling | 2008-03-04 02:48:26 +0100 (Tue, 04 Mar 2008) | 1 line
Typo fix
........
r61221 | andrew.kuchling | 2008-03-04 02:49:37 +0100 (Tue, 04 Mar 2008) | 1 line
Add versionadded tags
........
r61222 | andrew.kuchling | 2008-03-04 02:50:32 +0100 (Tue, 04 Mar 2008) | 1 line
Thesis night results: add various items
........
r61224 | raymond.hettinger | 2008-03-04 05:17:08 +0100 (Tue, 04 Mar 2008) | 1 line
Beef-up docs and tests for itertools. Fix-up end-case for product().
........
r61225 | georg.brandl | 2008-03-04 08:25:54 +0100 (Tue, 04 Mar 2008) | 2 lines
Fix some patch attributions.
........
r61226 | georg.brandl | 2008-03-04 08:33:30 +0100 (Tue, 04 Mar 2008) | 2 lines
#2230: document that PyArg_* leaves addresses alone on error.
........
r61233 | neal.norwitz | 2008-03-04 17:22:46 +0100 (Tue, 04 Mar 2008) | 3 lines
Close the file before trying to remove the directory so it works on Windows.
As reported by Trent Nelson on python-dev.
........
r61234 | thomas.heller | 2008-03-04 21:09:11 +0100 (Tue, 04 Mar 2008) | 9 lines
Merged changes from libffi3-branch.
The bundled libffi copy is now in sync with the recently released
libffi3.0.4 version, apart from some small changes to
Modules/_ctypes/libffi/configure.ac.
I gave up on using libffi3 files on os x.
Instead, static configuration with files from pyobjc is used.
........
r61235 | thomas.heller | 2008-03-04 21:21:42 +0100 (Tue, 04 Mar 2008) | 1 line
Try to fix the build for PY_LINUX.
........
r61236 | fred.drake | 2008-03-04 22:14:04 +0100 (Tue, 04 Mar 2008) | 2 lines
fix typo
........
r61237 | raymond.hettinger | 2008-03-04 23:29:44 +0100 (Tue, 04 Mar 2008) | 1 line
Fix refleak in chain().
........
diff --git a/Doc/c-api/arg.rst b/Doc/c-api/arg.rst
index 5f82904..faf97ed 100644
--- a/Doc/c-api/arg.rst
+++ b/Doc/c-api/arg.rst
@@ -212,7 +212,7 @@
:ctype:`void\*` argument that was passed to the :cfunc:`PyArg_Parse\*` function.
The returned *status* should be ``1`` for a successful conversion and ``0`` if
the conversion has failed. When the conversion fails, the *converter* function
- should raise an exception.
+ should raise an exception and leave the content of *address* unmodified.
``S`` (string) [PyStringObject \*]
Like ``O`` but requires that the Python object is a string object. Raises
@@ -284,9 +284,13 @@
units above, where these parameters are used as input values; they should match
what is specified for the corresponding format unit in that case.
-For the conversion to succeed, the *arg* object must match the format and the
-format must be exhausted. On success, the :cfunc:`PyArg_Parse\*` functions
-return true, otherwise they return false and raise an appropriate exception.
+For the conversion to succeed, the *arg* object must match the format
+and the format must be exhausted. On success, the
+:cfunc:`PyArg_Parse\*` functions return true, otherwise they return
+false and raise an appropriate exception. When the
+:cfunc:`PyArg_Parse\*` functions fail due to conversion failure in one
+of the format units, the variables at the addresses corresponding to that
+and the following format units are left untouched.
.. cfunction:: int PyArg_ParseTuple(PyObject *args, const char *format, ...)
diff --git a/Doc/library/inspect.rst b/Doc/library/inspect.rst
index c2bc15c..d622e1d 100644
--- a/Doc/library/inspect.rst
+++ b/Doc/library/inspect.rst
@@ -26,7 +26,7 @@
-----------------
The :func:`getmembers` function retrieves the members of an object such as a
-class or module. The fifteen functions whose names begin with "is" are mainly
+class or module. The sixteen functions whose names begin with "is" are mainly
provided as convenient choices for the second argument to :func:`getmembers`.
They also help you determine when you can expect to find the following special
attributes:
@@ -267,8 +267,6 @@
Return true if the object is an abstract base class.
- .. versionadded:: 2.6
-
.. function:: ismethoddescriptor(object)
diff --git a/Doc/library/itertools.rst b/Doc/library/itertools.rst
index 9da51aa..0d74c59 100644
--- a/Doc/library/itertools.rst
+++ b/Doc/library/itertools.rst
@@ -87,6 +87,7 @@
.. versionadded:: 2.6
+
.. function:: combinations(iterable, r)
Return successive *r* length combinations of elements in the *iterable*.
@@ -121,6 +122,17 @@
indices[j] = indices[j-1] + 1
yield tuple(pool[i] for i in indices)
+ The code for :func:`combinations` can be also expressed as a subsequence
+ of :func:`permutations` after filtering entries where the elements are not
+ in sorted order (according to their position in the input pool)::
+
+ def combinations(iterable, r):
+ pool = tuple(iterable)
+ n = len(pool)
+ for indices in permutations(range(n), r):
+ if sorted(indices) == list(indices):
+ yield tuple(pool[i] for i in indices)
+
.. versionadded:: 2.6
.. function:: count([n])
@@ -378,6 +390,18 @@
else:
return
+ The code for :func:`permutations` can be also expressed as a subsequence of
+ :func:`product`, filtered to exclude entries with repeated elements (those
+ from the same position in the input pool)::
+
+ def permutations(iterable, r=None):
+ pool = tuple(iterable)
+ n = len(pool)
+ r = n if r is None else r
+ for indices in product(range(n), repeat=r):
+ if len(set(indices)) == r:
+ yield tuple(pool[i] for i in indices)
+
.. versionadded:: 2.6
.. function:: product(*iterables[, repeat])
@@ -388,26 +412,25 @@
``product(A, B)`` returns the same as ``((x,y) for x in A for y in B)``.
The leftmost iterators are in the outermost for-loop, so the output tuples
- cycle in a manner similar to an odometer (with the rightmost element
- changing on every iteration). This results in a lexicographic ordering
- so that if the inputs iterables are sorted, the product tuples are emitted
+ cycle like an odometer (with the rightmost element changing on every
+ iteration). This results in a lexicographic ordering so that if the
+ inputs iterables are sorted, the product tuples are emitted
in sorted order.
To compute the product of an iterable with itself, specify the number of
repetitions with the optional *repeat* keyword argument. For example,
``product(A, repeat=4)`` means the same as ``product(A, A, A, A)``.
- Equivalent to the following except that the actual implementation does not
- build-up intermediate results in memory::
+ This function is equivalent to the following code, except that the
+ actual implementation does not build up intermediate results in memory::
def product(*args, **kwds):
pools = map(tuple, args) * kwds.get('repeat', 1)
- if pools:
- result = [[]]
- for pool in pools:
- result = [x+[y] for x in result for y in pool]
- for prod in result:
- yield tuple(prod)
+ result = [[]]
+ for pool in pools:
+ result = [x+[y] for x in result for y in pool]
+ for prod in result:
+ yield tuple(prod)
.. function:: repeat(object[, times])
diff --git a/Doc/library/signal.rst b/Doc/library/signal.rst
index cf6f8f8..2e5cae5 100644
--- a/Doc/library/signal.rst
+++ b/Doc/library/signal.rst
@@ -128,12 +128,12 @@
.. function:: siginterrupt(signalnum, flag)
Change system call restart behaviour: if *flag* is :const:`False`, system calls
- will be restarted when interrupted by signal *signalnum*, else system calls will
+ will be restarted when interrupted by signal *signalnum*, otherwise system calls will
be interrupted. Returns nothing. Availability: Unix, Mac (see the man page
:manpage:`siginterrupt(3)` for further information).
Note that installing a signal handler with :func:`signal` will reset the restart
- behaviour to interruptible by implicitly calling siginterrupt with a true *flag*
+ behaviour to interruptible by implicitly calling :cfunc:`siginterrupt` with a true *flag*
value for the given signal.
.. versionadded:: 2.6
diff --git a/Doc/reference/expressions.rst b/Doc/reference/expressions.rst
index e8efa9f..ac3c90f 100644
--- a/Doc/reference/expressions.rst
+++ b/Doc/reference/expressions.rst
@@ -232,6 +232,20 @@
constructed from the elements resulting from the comprehension.
+Variables used in the generator expression are evaluated lazily in a separate
+scope when the :meth:`next` method is called for the generator object (in the
+same fashion as for normal generators). However, the :keyword:`in` expression
+of the leftmost :keyword:`for` clause is immediately evaluated in the current
+scope so that an error produced by it can be seen before any other possible
+error in the code that handles the generator expression. Subsequent
+:keyword:`for` and :keyword:`if` clauses cannot be evaluated immediately since
+they may depend on the previous :keyword:`for` loop. For example:
+``(x*y for x in range(10) for y in bar(x))``.
+
+The parentheses can be omitted on calls with only one argument. See section
+:ref:`calls` for the detail.
+
+
.. _dict:
Dictionary displays
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index a0ec071..bba46c9 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -450,6 +450,15 @@
.. ======================================================================
+.. _pep-3101:
+
+PEP 3101: Advanced String Formatting
+=====================================================
+
+XXX write this
+
+.. ======================================================================
+
.. _pep-3110:
PEP 3110: Exception-Handling Changes
@@ -544,6 +553,32 @@
.. ======================================================================
+.. _pep-3127:
+
+PEP 3127: Integer Literal Support and Syntax
+=====================================================
+
+XXX write this
+
+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, and
+
+
+New bin() built-in returns the binary form of a number.
+
+.. ======================================================================
+
+.. _pep-3129:
+
+PEP 3129: Class Decorators
+=====================================================
+
+XXX write this.
+
+.. ======================================================================
+
.. _pep-3141:
PEP 3141: A Type Hierarchy for Numbers
@@ -579,7 +614,9 @@
: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.
+: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 ``>>``,
@@ -587,9 +624,9 @@
and can be used as array indexes and slice boundaries.
In Python 3.0, the PEP slightly redefines the existing built-ins
-:func:`math.floor`, :func:`math.ceil`, :func:`round`, and adds a new
-one, :func:`trunc`, that's been backported to Python 2.6.
-:func:`trunc` rounds toward zero, returning the closest
+: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::
@@ -603,7 +640,7 @@
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; rational numbers can exactly represent
+represented as a fraction, and can exactly represent
numbers such as two-thirds that floating-point numbers can only
approximate.
@@ -692,7 +729,7 @@
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
+ :func:`complex` constructor will now preserve the sign
of the zero.
.. Patch 1507
@@ -789,6 +826,15 @@
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.)
+
+* 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.
@@ -956,15 +1002,69 @@
can also be accessed as attributes.
(Contributed by Raymond Hettinger.)
-* 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::
+ 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)]
- (Contributed by Raymond Hettinger.)
+ ``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(iter, r)`` returns combinations 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')]
+
+ ``itertools.chain(*iterables)` is an existing function in
+ :mod:`itertools` that gained a new constructor.
+ ``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:`macfs` module has been removed. This in turn required the
:func:`macostools.touched` function to be removed because it depended on the
@@ -975,7 +1075,7 @@
* :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 a *end* parameter containing the index at which to stop
+ also gained an *end* parameter containing the index at which to stop
the forward search.
(Contributed by John Lenton.)
@@ -984,6 +1084,29 @@
triggers a warning message when Python is running in 3.0-warning
mode.
+* 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
@@ -1036,6 +1159,11 @@
.. 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
@@ -1099,6 +1227,10 @@
.. % 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
@@ -1201,6 +1333,18 @@
.. 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
@@ -1236,6 +1380,8 @@
whitespace.
>>>
+ (Contributed by Dwayne Bailey.)
+
.. Patch #1581073
* The :mod:`timeit` module now accepts callables as well as strings
@@ -1415,6 +1561,12 @@
.. 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.
.. ======================================================================