remove traces of .next

This commit is contained in:
Benjamin Peterson 2008-07-03 20:28:26 +00:00
parent 69164c77ef
commit e7c78b26c6
3 changed files with 29 additions and 28 deletions

View File

@ -168,7 +168,7 @@ Glossary
:keyword:`yield` elements back to the caller. The function execution is
stopped at the :keyword:`yield` keyword (returning the result) and is
resumed there when the next element is requested by calling the
:meth:`next` method of the returned iterator.
:meth:`__next__` method of the returned iterator.
.. index:: single: generator expression
@ -266,11 +266,12 @@ Glossary
iterator
An object representing a stream of data. Repeated calls to the iterator's
:meth:`next` method return successive items in the stream. When no more
data is available a :exc:`StopIteration` exception is raised instead. At
this point, the iterator object is exhausted and any further calls to its
:meth:`next` method just raise :exc:`StopIteration` again. Iterators are
required to have an :meth:`__iter__` method that returns the iterator
:meth:`__next__` (or passing it to the builtin function) :func:`next`
method return successive items in the stream. When no more data is
available a :exc:`StopIteration` exception is raised instead. At this
point, the iterator object is exhausted and any further calls to its
:meth:`__next__` method just raise :exc:`StopIteration` again. Iterators
are required to have an :meth:`__iter__` method that returns the iterator
object itself so every iterator is also iterable and may be used in most
places where other iterables are accepted. One notable exception is code
that attempts multiple iteration passes. A container object (such as a

View File

@ -184,11 +184,11 @@ foundation for writing functional-style programs: iterators.
An iterator is an object representing a stream of data; this object returns the
data one element at a time. A Python iterator must support a method called
``next()`` that takes no arguments and always returns the next element of the
stream. If there are no more elements in the stream, ``next()`` must raise the
``StopIteration`` exception. Iterators don't have to be finite, though; it's
perfectly reasonable to write an iterator that produces an infinite stream of
data.
``__next__()`` that takes no arguments and always returns the next element of
the stream. If there are no more elements in the stream, ``__next__()`` must
raise the ``StopIteration`` exception. Iterators don't have to be finite,
though; it's perfectly reasonable to write an iterator that produces an infinite
stream of data.
The built-in :func:`iter` function takes an arbitrary object and tries to return
an iterator that will return the object's contents or elements, raising
@ -203,13 +203,13 @@ You can experiment with the iteration interface manually:
>>> it = iter(L)
>>> it
<...iterator object at ...>
>>> it.next()
>>> it.__next__()
1
>>> it.next()
>>> next(it)
2
>>> it.next()
>>> next(it)
3
>>> it.next()
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
StopIteration
@ -467,20 +467,20 @@ the ``yield`` expression, the generator outputs the value of ``i``, similar to a
``return`` statement. The big difference between ``yield`` and a ``return``
statement is that on reaching a ``yield`` the generator's state of execution is
suspended and local variables are preserved. On the next call to the
generator's ``.next()`` method, the function will resume executing.
generator's ``.__next__()`` method, the function will resume executing.
Here's a sample usage of the ``generate_ints()`` generator:
>>> gen = generate_ints(3)
>>> gen
<generator object at ...>
>>> gen.next()
>>> next(gen)
0
>>> gen.next()
>>> next(gen)
1
>>> gen.next()
>>> next(gen)
2
>>> gen.next()
>>> next(gen)
Traceback (most recent call last):
File "stdin", line 1, in ?
File "stdin", line 2, in generate_ints
@ -500,7 +500,7 @@ the bottom of the function.
You could achieve the effect of generators manually by writing your own class
and storing all the local variables of the generator as instance variables. For
example, returning a list of integers could be done by setting ``self.count`` to
0, and having the ``next()`` method increment ``self.count`` and return it.
0, and having the ``__next__()`` method increment ``self.count`` and return it.
However, for a moderately complicated generator, writing a corresponding class
can be much messier.
@ -555,7 +555,7 @@ but have to use parentheses when there's an operation, as in ``val = (yield i)
Values are sent into a generator by calling its ``send(value)`` method. This
method resumes the generator's code and the ``yield`` expression returns the
specified value. If the regular ``next()`` method is called, the ``yield``
specified value. If the regular ``__next__()`` method is called, the ``yield``
returns ``None``.
Here's a simple counter that increments by 1 and allows changing the value of
@ -576,15 +576,15 @@ the internal counter.
And here's an example of changing the counter:
>>> it = counter(10)
>>> it.next()
>>> next(it)
0
>>> it.next()
>>> next(it)
1
>>> it.send(8)
8
>>> it.next()
>>> next(it)
9
>>> it.next()
>>> next(it)
Traceback (most recent call last):
File ``t.py'', line 15, in ?
it.next()

View File

@ -375,8 +375,8 @@ generator function:
Starts the execution of a generator function or resumes it at the last
executed :keyword:`yield` expression. When a generator function is resumed
with a :meth:`next` method, the current :keyword:`yield` expression always
evaluates to :const:`None`. The execution then continues to the next
with a :meth:`__next__` method, the current :keyword:`yield` expression
always evaluates to :const:`None`. The execution then continues to the next
:keyword:`yield` expression, where the generator is suspended again, and the
value of the :token:`expression_list` is returned to :meth:`next`'s caller.
If the generator exits without yielding another value, a :exc:`StopIteration`