iterator, or raises \exception{StopIteration} when the iterator is
exhausted. Its presence normally signals that the instances of this
type are iterators (although classic instances always have this
- function, even if they don't define a \method{next()} method).
+ function, even if they don't define a \method{__next__()} method).
Iterator types should also define the \member{tp_iter} function, and
that function should return the iterator instance itself (not a new
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
+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.
+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 ``next()`` function is normally used to call the iterator's
+``__next__()`` method.
The built-in ``iter()`` function takes an arbitrary object and tries
to return an iterator that will return the object's contents or
>>> it = iter(L)
>>> print it
<iterator object at 0x8116870>
- >>> it.next()
+ >>> next(it)
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
Note that you can only go forward in an iterator; there's no way to
get the previous element, reset the iterator, or make a copy of it.
Iterator objects can optionally provide these additional capabilities,
-but the iterator protocol only specifies the ``next()`` method.
+but the iterator protocol only specifies the ``__next__()`` method.
Functions may therefore consume all of the iterator's output, and if
you need to do something different with the same stream, you'll have
to create a new iterator.
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,
+preserved. On the next call ``next(generator)``,
the function will resume executing.
Here's a sample usage of the ``generate_ints()`` generator::
>>> gen = generate_ints(3)
>>> gen
<generator object at 0x8117f90>
- >>> 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
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.
+``__next__()`` method increment ``self.count`` and return it.
However, for a moderately complicated generator, writing a
corresponding class can be much messier.
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
+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
And here's an example of changing the counter:
>>> it = counter(10)
- >>> print it.next()
+ >>> print next(it)
0
- >>> print it.next()
+ >>> print next(it)
1
>>> print it.send(8)
8
- >>> print it.next()
+ >>> print next(it)
9
- >>> print it.next()
+ >>> print next(it)
Traceback (most recent call last):
File ``t.py'', line 15, in ?
- print it.next()
+ print next(it)
StopIteration
Because ``yield`` will often be returning ``None``, you
while pending:
task = pending.popleft()
try:
- yield task.next()
+ yield next(task)
except StopIteration:
continue
pending.append(task)
The function \function{int()} which always returns zero is just a special
case of constant functions. A faster and more flexible way to create
-constant functions is to use \function{itertools.repeat()} which can supply
+constant functions is to use a lambda function which can supply
any constant value (not just zero):
\begin{verbatim}
>>> def constant_factory(value):
-... return itertools.repeat(value).next
+... return lambda: value
>>> d = defaultdict(constant_factory('<missing>'))
>>> d.update(name='John', action='ran')
>>> '%(name)s %(action)s to %(object)s' % d
def __iter__(self):
return self
- def next(self):
- return self.reader.next().encode("utf-8")
+ def __next__(self):
+ return next(self.reader).encode("utf-8")
class UnicodeReader:
"""
f = UTF8Recoder(f, encoding)
self.reader = csv.reader(f, dialect=dialect, **kwds)
- def next(self):
- row = self.reader.next()
+ def __next__(self):
+ row = next(self.reader)
return [unicode(s, "utf-8") for s in row]
def __iter__(self):
\end{opcodedesc}
\begin{opcodedesc}{FOR_ITER}{delta}
-\code{TOS} is an iterator. Call its \method{next()} method. If this
-yields a new value, push it on the stack (leaving the iterator below
-it). If the iterator indicates it is exhausted \code{TOS} is
-popped, and the byte code counter is incremented by \var{delta}.
+ \code{TOS} is an iterator. Call its \method{__next__()} method. If this
+ yields a new value, push it on the stack (leaving the iterator below it). If
+ the iterator indicates it is exhausted \code{TOS} is popped, and the byte code
+ counter is incremented by \var{delta}.
\end{opcodedesc}
%\begin{opcodedesc}{FOR_LOOP}{delta}
\end{excdesc}
\begin{excdesc}{StopIteration}
- Raised by an iterator's \method{next()} method to signal that there
- are no further values.
+ Raised by builtin \function{next()} and an iterator's \method{__next__()}
+ method to signal that there are no further values.
This is derived from \exception{Exception} rather than
\exception{StandardError}, since this is not considered an error in
its normal application.
\end{funcdesc}
\begin{funcdesc}{enumerate}{iterable}
- Return an enumerate object. \var{iterable} must be a sequence, an
- iterator, or some other object which supports iteration. The
- \method{next()} method of the iterator returned by
- \function{enumerate()} returns a tuple containing a count (from
- zero) and the corresponding value obtained from iterating over
- \var{iterable}. \function{enumerate()} is useful for obtaining an
- indexed series: \code{(0, seq[0])}, \code{(1, seq[1])}, \code{(2,
- seq[2])}, \ldots.
+ Return an enumerate object. \var{iterable} must be a sequence, an iterator, or
+ some other object which supports iteration. The \method{__next__()} method of
+ the iterator returned by \function{enumerate()} returns a tuple containing a
+ count (from zero) and the corresponding value obtained from iterating over
+ \var{iterable}. \function{enumerate()} is useful for obtaining an indexed
+ series: \code{(0, seq[0])}, \code{(1, seq[1])}, \code{(2, seq[2])}, \ldots.
\versionadded{2.3}
\end{funcdesc}
support either of those protocols, \exception{TypeError} is raised.
If the second argument, \var{sentinel}, is given, then \var{o} must
be a callable object. The iterator created in this case will call
- \var{o} with no arguments for each call to its \method{next()}
+ \var{o} with no arguments for each call to its \method{__next__()}
method; if the value returned is equal to \var{sentinel},
\exception{StopIteration} will be raised, otherwise the value will
be returned.
\versionchanged[Added support for the optional \var{key} argument]{2.5}
\end{funcdesc}
+\begin{funcdesc}{next}{iterator\optional{, default}}
+ Retrieve the next item from the \var{iterable} by calling its
+ \method{__next__()} method. If \var{default} is given, it is returned if the
+ iterator is exhausted, otherwise \exception{StopIteration} is raised.
+\end{funcdesc}
+
\begin{funcdesc}{object}{}
Return a new featureless object. \class{object} is a base
for all new style classes. It has the methods that are common
self.tgtkey = self.currkey = self.currvalue = xrange(0)
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
while self.currkey == self.tgtkey:
- self.currvalue = self.it.next() # Exit on StopIteration
+ self.currvalue = next(self.it) # Exit on StopIteration
self.currkey = self.keyfunc(self.currvalue)
self.tgtkey = self.currkey
return (self.currkey, self._grouper(self.tgtkey))
def _grouper(self, tgtkey):
while self.currkey == tgtkey:
yield self.currvalue
- self.currvalue = self.it.next() # Exit on StopIteration
+ self.currvalue = next(self.it) # Exit on StopIteration
self.currkey = self.keyfunc(self.currvalue)
\end{verbatim}
\versionadded{2.4}
def imap(function, *iterables):
iterables = map(iter, iterables)
while True:
- args = [i.next() for i in iterables]
+ args = [next(i) for i in iterables]
if function is None:
yield tuple(args)
else:
def islice(iterable, *args):
s = slice(*args)
it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
- nexti = it.next()
+ nexti = next(it)
for i, element in enumerate(iterable):
if i == nexti:
yield element
- nexti = it.next()
+ nexti = next(it)
\end{verbatim}
If \var{start} is \code{None}, then iteration starts at zero.
def izip(*iterables):
iterables = map(iter, iterables)
while iterables:
- result = [it.next() for it in iterables]
+ result = [next(it) for it in iterables]
yield tuple(result)
\end{verbatim}
from each iterator in-turn, but the process ends when one of the iterators
terminates. This leaves the last fetched values in limbo (they cannot be
returned in a final, incomplete tuple and they are cannot be pushed back
- into the iterator for retrieval with \code{it.next()}). In general,
+ into the iterator for retrieval with \code{next(it)}). In general,
\function{izip()} should only be used with unequal length inputs when you
don't care about trailing, unmatched values from the longer iterables.
\end{funcdesc}
def starmap(function, iterable):
iterable = iter(iterable)
while True:
- yield function(*iterable.next())
+ yield function(*next(iterable))
\end{verbatim}
\end{funcdesc}
item = data.pop(i)
yield item
it = iter(iterable)
- return (gen(it.next), gen(it.next))
+ return (gen(it.__next__), gen(it.__next__))
\end{verbatim}
Note, once \function{tee()} has made a split, the original \var{iterable}
def pairwise(iterable):
"s -> (s0,s1), (s1,s2), (s2, s3), ..."
a, b = tee(iterable)
- try:
- b.next()
- except StopIteration:
- pass
+ next(b, None)
return izip(a, b)
def grouper(n, iterable, padvalue=None):
specialized forms. The specific types are not important beyond their
implementation of the iterator protocol.
-The intention of the protocol is that once an iterator's
-\method{next()} method raises \exception{StopIteration}, it will
-continue to do so on subsequent calls. Implementations that
-do not obey this property are deemed broken. (This constraint
-was added in Python 2.3; in Python 2.2, various iterators are
-broken according to this rule.)
+The intention of the protocol is that once an iterator's \method{__next__()}
+method raises \exception{StopIteration}, it will continue to do so on subsequent
+calls. Implementations that do not obey this property are deemed broken. (This
+constraint was added in Python 2.3; in Python 2.2, various iterators are broken
+according to this rule.)
-Python's generators provide a convenient way to implement the
-iterator protocol. If a container object's \method{__iter__()}
-method is implemented as a generator, it will automatically
-return an iterator object (technically, a generator object)
-supplying the \method{__iter__()} and \method{next()} methods.
+Python's generators provide a convenient way to implement the iterator protocol.
+If a container object's \method{__iter__()} method is implemented as a
+generator, it will automatically return an iterator object (technically, a
+generator object) supplying the \method{__iter__()} and \method{__next__()}
+methods.
\section{Sequence Types ---
with a real file, this method should \emph{not} be implemented.}
\end{methoddesc}
-\begin{methoddesc}[file]{next}{}
+\begin{methoddesc}[file]{__next__}{}
A file object is its own iterator, for example \code{iter(\var{f})} returns
\var{f} (unless \var{f} is closed). When a file is used as an
iterator, typically in a \keyword{for} loop (for example,
-\code{for line in f: print line}), the \method{next()} method is
+\code{for line in f: print line}), the \method{__next__()} method is
called repeatedly. This method returns the next input line, or raises
\exception{StopIteration} when \EOF{} is hit. In order to make a
\keyword{for} loop the most efficient way of looping over the lines of
-a file (a very common operation), the \method{next()} method uses a
+a file (a very common operation), the \method{__next__()} method uses a
hidden read-ahead buffer. As a consequence of using a read-ahead
-buffer, combining \method{next()} with other file methods (like
+buffer, combining \method{__next__()} with other file methods (like
\method{readline()}) does not work right. However, using
\method{seek()} to reposition the file to an absolute position will
flush the read-ahead buffer.
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.count > ord('z'):
raise StopIteration
self.count += 1
section~\ref{yield}, ``The \keyword{yield} statement'') is called a
\dfn{generator function}. Such a function, when called, always
returns an iterator object which can be used to execute the body of
-the function: calling the iterator's \method{next()} method will
+the function: calling the iterator's \method{__next__()} method will
cause the function to execute until it provides a value using the
\keyword{yield} statement. When the function executes a
\keyword{return} statement or falls off the end, a
innermost block for each iteration.
Variables used in the generator expression are evaluated lazily
-when the \method{next()} method is called for generator object
+when the \method{__next__()} method is called for generator object
(in the same fashion as normal generators). However, the leftmost
\keyword{for} clause is immediately evaluated so that error produced
by it can be seen before any other possible error in the code that
sufficient to cause that definition to create a generator function
instead of a normal function.
-When a generator function is called, it returns an iterator known as a
-generator iterator, or more commonly, a generator. The body of the
-generator function is executed by calling the generator's
-\method{next()} method repeatedly until it raises an exception.
-
-When a \keyword{yield} statement is executed, the state of the
-generator is frozen and the value of \grammartoken{expression_list} is
-returned to \method{next()}'s caller. By ``frozen'' we mean that all
-local state is retained, including the current bindings of local
-variables, the instruction pointer, and the internal evaluation stack:
-enough information is saved so that the next time \method{next()} is
-invoked, the function can proceed exactly as if the \keyword{yield}
-statement were just another external call.
+When a generator function is called, it returns an iterator known as a generator
+iterator, or more commonly, a generator. The body of the generator function is
+executed by calling the generator's \method{__next__()} method repeatedly until
+it raises an exception.
+
+When a \keyword{yield} statement is executed, the state of the generator is
+frozen and the value of \grammartoken{expression_list} is returned to
+\method{__next__()}'s caller. By ``frozen'' we mean that all local state is
+retained, including the current bindings of local variables, the instruction
+pointer, and the internal evaluation stack: enough information is saved so that
+the next time \method{__next__()} is invoked, the function can proceed exactly
+as if the \keyword{yield} statement were just another external call.
As of Python version 2.5, the \keyword{yield} statement is now
allowed in the \keyword{try} clause of a \keyword{try} ...\
\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
-\method{next()} method of the returned iterator.
+\method{__next__()} method of the returned iterator.
\index{generator expression}
\item[generator expression]
\index{iterator}
\item[iterator]
An object representing a stream of data. Repeated calls to the
-iterator's \method{next()} method return successive items in the
+iterator's \method{__next__()} method return successive items in the
stream. When no more data is available a \exception{StopIteration}
exception is raised instead. At this point, the iterator object is
-exhausted and any further calls to its \method{next()} method just
+exhausted and any further calls to its \method{__next__()} method just
raise \exception{StopIteration} again. Iterators are required to have
an \method{__iter__()} method that returns the iterator object
itself so every iterator is also iterable and may be used in most
pervades and unifies Python. Behind the scenes, the \keyword{for}
statement calls \function{iter()} on the container object. The
function returns an iterator object that defines the method
-\method{next()} which accesses elements in the container one at a
-time. When there are no more elements, \method{next()} raises a
+\method{__next__()} which accesses elements in the container one at a
+time. When there are no more elements, \method{__next__()} raises a
\exception{StopIteration} exception which tells the \keyword{for} loop
-to terminate. This example shows how it all works:
+to terminate. You can call the \method{__next__()} method using the
+\function{next()} builtin; this example shows how it all works:
\begin{verbatim}
>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
->>> it.next()
+>>> next(it)
'a'
->>> it.next()
+>>> next(it)
'b'
->>> it.next()
+>>> next(it)
'c'
->>> it.next()
+>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
- it.next()
+ next(it)
StopIteration
\end{verbatim}
Having seen the mechanics behind the iterator protocol, it is easy to add
iterator behavior to your classes. Define a \method{__iter__()} method
-which returns an object with a \method{next()} method. If the class defines
-\method{next()}, then \method{__iter__()} can just return \code{self}:
+which returns an object with a \method{__next__()} method. If the class defines
+\method{__next__()}, then \method{__iter__()} can just return \code{self}:
\begin{verbatim}
class Reverse:
self.index = len(data)
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.index == 0:
raise StopIteration
self.index = self.index - 1
Generators are a simple and powerful tool for creating iterators. They are
written like regular functions but use the \keyword{yield} statement whenever
-they want to return data. Each time \method{next()} is called, the
+they want to return data. Each time \function{next()} is called on it, the
generator resumes where it left-off (it remembers all the data values and
which statement was last executed). An example shows that generators can
be trivially easy to create:
Anything that can be done with generators can also be done with class based
iterators as described in the previous section. What makes generators so
-compact is that the \method{__iter__()} and \method{next()} methods are
+compact is that the \method{__iter__()} and \method{__next__()} methods are
created automatically.
Another key feature is that the local variables and execution state
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
"""A file object is its own iterator, for example iter(f) returns f
(unless f is closed). When a file is used as an iterator, typically
- in a for loop (for example, for line in f: print line), the next()
+ in a for loop (for example, for line in f: print line), the __next__()
method is called repeatedly. This method returns the next input line,
or raises StopIteration when EOF is hit.
"""
return value
def popitem(self):
try:
- k, v = self.iteritems().next()
+ k, v = next(self.iteritems())
except StopIteration:
raise KeyError, 'container is empty'
del self[k]
self.reset()
self.stream.seek(offset, whence)
- def next(self):
+ def __next__(self):
""" Return the next decoded line from the input stream."""
line = self.readline()
return self.reader.readlines(sizehint)
- def next(self):
+ def __next__(self):
""" Return the next decoded line from the input stream."""
- return self.reader.next()
+ return next(self.reader)
def __iter__(self):
return self
data, bytesencoded = self.encode(data, self.errors)
return data.splitlines(1)
- def next(self):
+ def __next__(self):
""" Return the next decoded line from the input stream."""
- data = self.reader.next()
+ data = next(self.reader)
data, bytesencoded = self.encode(data, self.errors)
return data
def __enter__(self):
try:
- return self.gen.next()
+ return next(self.gen)
except StopIteration:
raise RuntimeError("generator didn't yield")
def __exit__(self, type, value, traceback):
if type is None:
try:
- self.gen.next()
+ next(self.gen)
except StopIteration:
return
else:
def __iter__(self):
return self
- def next(self):
- row = self.reader.next()
+ def __next__(self):
+ row = next(self.reader)
if self.fieldnames is None:
self.fieldnames = row
- row = self.reader.next()
+ row = next(self.reader)
# unlike the basic reader, we prefer not to return blanks,
# because we will typically wind up with a dict full of None
# values
while row == []:
- row = self.reader.next()
+ row = next(self.reader)
d = dict(zip(self.fieldnames, row))
lf = len(self.fieldnames)
lr = len(row)
rdr = reader(StringIO(sample), self.sniff(sample))
- header = rdr.next() # assume first row is header
+ header = next(rdr) # assume first row is header
columns = len(header)
columnTypes = {}
# so we can do some very readable comparisons.
while len(lines) < 4:
try:
- lines.append(diff_lines_iterator.next())
+ lines.append(next(diff_lines_iterator))
except StopIteration:
lines.append('X')
s = ''.join([line[0] for line in lines])
while True:
# Collecting lines of text until we have a from/to pair
while (len(fromlines)==0 or len(tolines)==0):
- from_line, to_line, found_diff =line_iterator.next()
+ from_line, to_line, found_diff = next(line_iterator)
if from_line is not None:
fromlines.append((from_line,found_diff))
if to_line is not None:
line_pair_iterator = _line_pair_iterator()
if context is None:
while True:
- yield line_pair_iterator.next()
+ yield next(line_pair_iterator)
# Handle case where user wants context differencing. We must do some
# storage of lines until we know for sure that they are to be yielded.
else:
index, contextLines = 0, [None]*(context)
found_diff = False
while(found_diff is False):
- from_line, to_line, found_diff = line_pair_iterator.next()
+ from_line, to_line, found_diff = next(line_pair_iterator)
i = index % context
contextLines[i] = (from_line, to_line, found_diff)
index += 1
# Now yield the context lines after the change
lines_to_write = context-1
while(lines_to_write):
- from_line, to_line, found_diff = line_pair_iterator.next()
+ from_line, to_line, found_diff = next(line_pair_iterator)
# If another change within the context, extend the context
if found_diff:
lines_to_write = context-1
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
line = self.readline()
if line == '':
raise StopIteration
self._factory = _factory
self._input = BufferedSubFile()
self._msgstack = []
- self._parse = self._parsegen().next
+ self._parse = self._parsegen().__next__
self._cur = None
self._last = None
self._headersonly = False
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
try:
line = self._buffer[self._bufindex]
except IndexError:
if i != self._lineno:
raise RuntimeError, "accessing lines out of order"
try:
- return self.next()
+ return self.__next__()
except StopIteration:
raise IndexError, "end of input reached"
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
line = self.readline()
if line:
return line
h_append = h.append
for itnum, it in enumerate(map(iter, iterables)):
try:
- next = it.next
+ next = it.__next__
h_append([next(), itnum, next])
except _StopIteration:
pass
self._funcmap = {}
self._reader = _hotshot.logreader(logfn)
- self._nextitem = self._reader.next
+ self._nextitem = self._reader.__next__
self._info = self._reader.info
if 'current-directory' in self._info:
self.cwd = self._info['current-directory']
# same bound method can be used as the __getitem__() method -- this
# avoids using an additional method call which kills the performance.
- def next(self, index=0):
+ def __next__(self, index=0):
while 1:
# This call may raise StopIteration:
what, tdelta, fileno, lineno = self._nextitem()
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
line = self.readline()
if not line:
raise StopIteration
"""Extract the block of code at the top of the given list of lines."""
blockfinder = BlockFinder()
try:
- tokenize.tokenize(iter(lines).next, blockfinder.tokeneater)
+ tokenize.tokenize(iter(lines).__next__, blockfinder.tokeneater)
except (EndOfBlock, IndentationError):
pass
return lines[:blockfinder.last]
"""
return self
- def next(self) -> str:
+ def __next__(self) -> str:
"""Same as readline() except raises StopIteration on immediate EOF."""
line = self.readline()
if not line:
self._pending = res[n:]
return self._simplify(res[:n])
- def next(self) -> str:
+ def __next__(self) -> str:
self._telling = False
line = self.readline()
if not line:
self._onetime_keys = iter(self.keys())
while True:
try:
- return self[self._onetime_keys.next()]
+ return self[next(self._onetime_keys)]
except StopIteration:
return None
except KeyError:
tmp = []
for i in r:
try:
- x = items.next()
+ x = next(items)
tmp.append(x)
except StopIteration:
items = None
tmp = []
for i in r:
try:
- tmp.append(items.next())
+ tmp.append(next(items))
except StopIteration:
items = None
break
subheader = False
for cc, nc, tt, ct, callers in self.stats.values():
if callers:
- value = iter(callers.values()).next()
+ value = next(iter(callers.values()))
subheader = isinstance(value, tuple)
break
if subheader:
# close previous nested classes and defs
while stack and stack[-1][1] >= thisindent:
del stack[-1]
- tokentype, meth_name, start, end, line = g.next()
+ tokentype, meth_name, start, end, line = next(g)
if tokentype != NAME:
continue # Syntax error
if stack:
# close previous nested classes and defs
while stack and stack[-1][1] >= thisindent:
del stack[-1]
- tokentype, class_name, start, end, line = g.next()
+ tokentype, class_name, start, end, line = next(g)
if tokentype != NAME:
continue # Syntax error
# parse what follows the class name
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
inherit = None
if token == '(':
names = [] # List of superclasses
level = 1
super = [] # Tokens making up current superclass
while True:
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
if token in (')', ',') and level == 1:
n = "".join(super)
if n in dict:
name2 = None
names.append((name, name2))
while token != "," and "\n" not in token:
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
if token != ",":
break
return names
# name is the dotted name, or None if there was no dotted name,
# and token is the next input token.
parts = []
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
if tokentype != NAME and token != '*':
return (None, token)
parts.append(token)
while True:
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
if token != '.':
break
- tokentype, token, start, end, line = g.next()
+ tokentype, token, start, end, line = next(g)
if tokentype != NAME:
break
parts.append(token)
return (key, Unpickler(f).load())
def next(self):
- (key, value) = self.dict.next()
+ (key, value) = next(self.dict)
f = StringIO(value)
return (key, Unpickler(f).load())
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
token = self.get_token()
if token == self.eof:
raise StopIteration
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
line = self.readline()
if not line:
raise StopIteration
def __init__(self):
self.value = 5
- def next(self):
+ def __next__(self):
if self.value == 10:
raise StopIteration
else:
"""Return iterator object.
"""
return self
- def next(self):
+ def __next__(self):
"""Return the next item using TarFile's next() method.
When all members have been read, set TarFile as _loaded.
"""
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
m = self.mutex
c = self.characters
choose = self.rng.choice
dir = _os.path.normcase(_os.path.abspath(dir))
# Try only a few names per directory.
for seq in xrange(100):
- name = namer.next()
+ name = next(namer)
filename = _os.path.join(dir, name)
try:
fd = _os.open(filename, flags, 0600)
names = _get_candidate_names()
for seq in xrange(TMP_MAX):
- name = names.next()
+ name = next(names)
file = _os.path.join(dir, pre + name + suf)
try:
fd = _os.open(file, flags, 0600)
names = _get_candidate_names()
for seq in xrange(TMP_MAX):
- name = names.next()
+ name = next(names)
file = _os.path.join(dir, prefix + name + suffix)
try:
_os.mkdir(file, 0700)
names = _get_candidate_names()
for seq in xrange(TMP_MAX):
- name = names.next()
+ name = next(names)
file = _os.path.join(dir, prefix + name + suffix)
if not _exists(file):
return file
a = self.type2test(range(20))
r = reversed(a)
self.assertEqual(list(r), self.type2test(range(19, -1, -1)))
- self.assertRaises(StopIteration, r.next)
+ self.assertRaises(StopIteration, next, r)
self.assertEqual(list(reversed(self.type2test())),
self.type2test())
if not d: self.fail("Full mapping must compare to True")
# keys(), items(), iterkeys() ...
def check_iterandlist(iter, lst, ref):
- self.assert_(hasattr(iter, 'next'))
+ self.assert_(hasattr(iter, '__next__'))
self.assert_(hasattr(iter, '__iter__'))
x = list(iter)
self.assert_(set(x)==set(lst)==set(ref))
check_iterandlist(iter(d.items()), list(d.items()),
self.reference.items())
#get
- key, value = iter(d.items()).next()
- knownkey, knownvalue = iter(self.other.items()).next()
+ key, value = next(iter(d.items()))
+ knownkey, knownvalue = next(iter(self.other.items()))
self.assertEqual(d.get(key, knownvalue), value)
self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
self.failIf(knownkey in d)
self.assertEqual(dict(p), self.reference)
d = self._full_mapping(self.reference)
#setdefault
- key, value = iter(d.items()).next()
- knownkey, knownvalue = iter(self.other.items()).next()
+ key, value = next(iter(d.items()))
+ knownkey, knownvalue = next(iter(self.other.items()))
self.assertEqual(d.setdefault(key, knownvalue), value)
self.assertEqual(d[key], value)
self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
self.i = 1
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i:
self.i = 0
return 'a'
self.i = ord('a')
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i <= ord('z'):
rtn = chr(self.i)
self.i += 1
class badseq(object):
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise Exc()
self.assertRaises(Exc, d.update, badseq())
class BadSeq(object):
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise Exc()
self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
return v
class IterNoNext:
- 'Iterator missing next()'
+ 'Iterator missing __next__()'
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
3 // 0
class IterFuncStop:
pass
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise StopIteration
from itertools import chain, imap
class T(self.type2test):
def __getitem__(self, key):
return str(key) + '!!!'
- self.assertEqual(iter(T((1,2))).next(), 1)
+ self.assertEqual(next(iter(T((1,2)))), 1)
def test_repeat(self):
for m in xrange(4):
eq(iter(self._fp), self._fp)
# Does this object support the iteration protocol?
unless(hasattr(self._fp, '__iter__'))
- unless(hasattr(self._fp, 'next'))
+ unless(hasattr(self._fp, '__next__'))
i = 0
for line in self._fp:
eq(line, self._line + '\n')
i += 1
eq(i, 5)
self._fp.close()
- self.assertRaises(ValueError, self._fp.next)
+ self.assertRaises(ValueError, next, self._fp)
class TestStringIO(TestGenericStringIO):
MODULE = StringIO
di = iter(self.d)
while 1:
try:
- key = di.next()
+ key = next(di)
self.d[key] = 'modified '+key
except StopIteration:
break
fi = iter(self.f)
while 1:
try:
- key = fi.next()
+ key = next(fi)
self.f[key] = 'modified '+key
except StopIteration:
break
di = iter(self.d.items())
while 1:
try:
- k, v = di.next()
+ k, v = next(di)
self.d[k] = 'modified '+v
except StopIteration:
break
fi = iter(self.f.items())
while 1:
try:
- k, v = fi.next()
+ k, v = next(fi)
self.f[k] = 'modified '+v
except StopIteration:
break
if hasattr(self.f, 'iteritems'):
if debug: print("D")
i = iter(self.f.items())
- k,v = i.next()
+ k,v = next(i)
if debug: print("E")
self.f[k] = "please don't deadlock"
if debug: print("F")
while 1:
try:
- k,v = i.next()
+ k,v = next(i)
except StopIteration:
break
if debug: print("F2")
while i:
try:
if debug: print("H")
- k = i.next()
+ k = next(i)
if debug: print("I")
self.f[k] = "deadlocks-r-us"
if debug: print("J")
i = iter(self.f.iteritems())
nc2 = len(self.f._cursor_refs)
# use the iterator (should run to the first yield, creating the cursor)
- k, v = i.next()
+ k, v = next(i)
nc3 = len(self.f._cursor_refs)
# destroy the iterator; this should cause the weakref callback
# to remove the cursor object from self.f._cursor_refs
lists.append(unicode("12"))
for l in lists:
i = iter(l)
- self.assertEqual(i.next(), '1')
- self.assertEqual(i.next(), '2')
- self.assertRaises(StopIteration, i.next)
+ self.assertEqual(next(i), '1')
+ self.assertEqual(next(i), '2')
+ self.assertRaises(StopIteration, next, i)
def test_isinstance(self):
class C:
self.assertEqual(min(data, key=f),
sorted(data, key=f)[0])
+ def test_next(self):
+ it = iter(range(2))
+ self.assertEqual(next(it), 0)
+ self.assertEqual(next(it), 1)
+ self.assertRaises(StopIteration, next, it)
+ self.assertRaises(StopIteration, next, it)
+ self.assertEquals(next(it, 42), 42)
+
+ class Iter(object):
+ def __iter__(self):
+ return self
+ def __next__(self):
+ raise StopIteration
+
+ it = iter(Iter())
+ self.assertEquals(next(it, 42), 42)
+ self.assertRaises(StopIteration, next, it)
+
+ def gen():
+ yield 1
+ return
+
+ it = gen()
+ self.assertEquals(next(it), 1)
+ self.assertRaises(StopIteration, next, it)
+ self.assertEquals(next(it, 42), 42)
+
def test_oct(self):
self.assertEqual(oct(100), '0144')
self.assertEqual(oct(100), '0144')
def test_read_linenum(self):
r = csv.reader(['line,1', 'line,2', 'line,3'])
self.assertEqual(r.line_num, 0)
- r.next()
+ next(r)
self.assertEqual(r.line_num, 1)
- r.next()
+ next(r)
self.assertEqual(r.line_num, 2)
- r.next()
+ next(r)
self.assertEqual(r.line_num, 3)
- self.assertRaises(StopIteration, r.next)
+ self.assertRaises(StopIteration, next, r)
self.assertEqual(r.line_num, 3)
class TestDialectRegistry(unittest.TestCase):
try:
fileobj.write("abc def\nc1ccccc1 benzene\n")
fileobj.seek(0)
- rdr = csv.reader(fileobj, dialect=space())
- self.assertEqual(rdr.next(), ["abc", "def"])
- self.assertEqual(rdr.next(), ["c1ccccc1", "benzene"])
+ reader = csv.reader(fileobj, dialect=space())
+ self.assertEqual(next(reader), ["abc", "def"])
+ self.assertEqual(next(reader), ["c1ccccc1", "benzene"])
finally:
fileobj.close()
os.unlink(name)
fileobj.seek(0)
reader = csv.DictReader(fileobj,
fieldnames=["f1", "f2", "f3"])
- self.assertEqual(reader.next(), {"f1": '1', "f2": '2', "f3": 'abc'})
+ self.assertEqual(next(reader), {"f1": '1', "f2": '2', "f3": 'abc'})
finally:
fileobj.close()
os.unlink(name)
fileobj.write("f1,f2,f3\r\n1,2,abc\r\n")
fileobj.seek(0)
reader = csv.DictReader(fileobj)
- self.assertEqual(reader.next(), {"f1": '1', "f2": '2', "f3": 'abc'})
+ self.assertEqual(next(reader), {"f1": '1', "f2": '2', "f3": 'abc'})
finally:
fileobj.close()
os.unlink(name)
fileobj.seek(0)
reader = csv.DictReader(fileobj,
fieldnames=["f1", "f2"])
- self.assertEqual(reader.next(), {"f1": '1', "f2": '2',
+ self.assertEqual(next(reader), {"f1": '1', "f2": '2',
None: ["abc", "4", "5", "6"]})
finally:
fileobj.close()
fileobj.seek(0)
reader = csv.DictReader(fileobj,
fieldnames=["f1", "f2"], restkey="_rest")
- self.assertEqual(reader.next(), {"f1": '1', "f2": '2',
+ self.assertEqual(next(reader), {"f1": '1', "f2": '2',
"_rest": ["abc", "4", "5", "6"]})
finally:
fileobj.close()
fileobj.write("f1,f2\r\n1,2,abc,4,5,6\r\n")
fileobj.seek(0)
reader = csv.DictReader(fileobj, restkey="_rest")
- self.assertEqual(reader.next(), {"f1": '1', "f2": '2',
+ self.assertEqual(next(reader), {"f1": '1', "f2": '2',
"_rest": ["abc", "4", "5", "6"]})
finally:
fileobj.close()
reader = csv.DictReader(fileobj,
fieldnames="1 2 3 4 5 6".split(),
restval="DEFAULT")
- self.assertEqual(reader.next(), {"1": '1', "2": '2', "3": 'abc',
+ self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
- self.assertEqual(reader.next(), {"1": '1', "2": '2', "3": 'abc',
+ self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
"4": 'DEFAULT', "5": 'DEFAULT',
"6": 'DEFAULT'})
finally:
reader = csv.DictReader(sample,
fieldnames="i1 float i2 s1 s2".split())
- self.assertEqual(reader.next(), {"i1": '2147483648',
+ self.assertEqual(next(reader), {"i1": '2147483648',
"float": '43.0e12',
"i2": '17',
"s1": 'abc',
reader = csv.DictReader(["1,2,abc,4,5,6\r\n","\r\n",
"1,2,abc,4,5,6\r\n"],
fieldnames="1 2 3 4 5 6".split())
- self.assertEqual(reader.next(), {"1": '1', "2": '2', "3": 'abc',
+ self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
- self.assertEqual(reader.next(), {"1": '1', "2": '2', "3": 'abc',
+ self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
def test_read_semi_sep(self):
reader = csv.DictReader(["1;2;abc;4;5;6\r\n"],
fieldnames="1 2 3 4 5 6".split(),
delimiter=';')
- self.assertEqual(reader.next(), {"1": '1', "2": '2', "3": 'abc',
+ self.assertEqual(next(reader), {"1": '1', "2": '2', "3": 'abc',
"4": '4', "5": '5', "6": '6'})
class TestArrayWrites(unittest.TestCase):
d = deque('abcdefg')
it = iter(d)
d.pop()
- self.assertRaises(RuntimeError, it.next)
+ self.assertRaises(RuntimeError, next, it)
def test_runtime_error_on_empty_deque(self):
d = deque()
it = iter(d)
d.append(10)
- self.assertRaises(RuntimeError, it.next)
+ self.assertRaises(RuntimeError, next, it)
class Deque(deque):
pass
... while pending:
... task = pending.popleft()
... try:
-... yield task.next()
+... yield next(task)
... except StopIteration:
... continue
... pending.append(task)
self.i = 1
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i:
self.i = 0
return 'a'
self.i = ord('a')
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i <= ord('z'):
rtn = chr(self.i)
self.i += 1
class badseq(object):
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise Exc()
self.assertRaises(Exc, {}.update, badseq())
class BadSeq(object):
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise Exc()
self.assertRaises(Exc, dict.fromkeys, BadSeq())
def test_comparing_empty_lists(self):
# Check fix for bug #979794
group_gen = difflib.SequenceMatcher(None, [], []).get_grouped_opcodes()
- self.assertRaises(StopIteration, group_gen.next)
+ self.assertRaises(StopIteration, next, group_gen)
diff_gen = difflib.unified_diff([], [])
- self.assertRaises(StopIteration, diff_gen.next)
+ self.assertRaises(StopIteration, next, diff_gen)
patch914575_from1 = """
1. Beautiful is beTTer than ugly.
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
3 // 0
class N:
- 'Iterator missing next()'
+ 'Iterator missing __next__()'
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
def test_getitemseqn(self):
self.assertEqual(list(self.enum(G(self.seq))), self.res)
e = self.enum(G(''))
- self.assertRaises(StopIteration, e.next)
+ self.assertRaises(StopIteration, next, e)
def test_iteratorseqn(self):
self.assertEqual(list(self.enum(I(self.seq))), self.res)
e = self.enum(I(''))
- self.assertRaises(StopIteration, e.next)
+ self.assertRaises(StopIteration, next, e)
def test_iteratorgenerator(self):
self.assertEqual(list(self.enum(Ig(self.seq))), self.res)
e = self.enum(Ig(''))
- self.assertRaises(StopIteration, e.next)
+ self.assertRaises(StopIteration, next, e)
def test_noniterable(self):
self.assertRaises(TypeError, self.enum, X(self.seq))
self.c = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.c == 4:
raise StopIteration
c = self.c
self.assert_(f.closed)
def testMethods(self):
- methods = ['fileno', 'flush', 'isatty', 'next', 'read', 'readinto',
+ methods = ['fileno', 'flush', 'isatty', '__next__', 'read', 'readinto',
'readline', 'readlines', 'seek', 'tell', 'truncate',
'write', '__iter__']
if sys.platform.startswith('atheos'):
# Test for appropriate errors mixing read* and iteration
for methodname, args in methods:
f = open(TESTFN, 'rb')
- if f.next() != filler:
+ if next(f) != filler:
self.fail, "Broken testfile"
meth = getattr(f, methodname)
try:
# between 4 and 16384 (inclusive).
f = open(TESTFN, 'rb')
for i in range(nchunks):
- f.next()
+ next(f)
testline = testlines.pop(0)
try:
line = f.readline()
t2 = writeTmp(2, ["C\nD"])
fi = FileInput(files=(t1, t2))
verify(fi.fileno() == -1)
- line = fi.next()
+ line = next(fi)
verify(fi.fileno() != -1)
fi.nextfile()
verify(fi.fileno() == -1)
1
2
>>> g = f()
- >>> g.next()
+ >>> next(g)
1
- >>> g.next()
+ >>> next(g)
2
"Falling off the end" stops the generator:
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in g
... yield 2 # never reached
...
>>> g = f()
- >>> g.next()
+ >>> next(g)
1
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in f
StopIteration
- >>> g.next() # once stopped, can't be resumed
+ >>> next(g) # once stopped, can't be resumed
Traceback (most recent call last):
File "<stdin>", line 1, in ?
StopIteration
... yield 2 # never reached
...
>>> g = f()
- >>> g.next()
+ >>> next(g)
1
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
StopIteration
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
StopIteration
>>> def creator():
... r = yrange(5)
- ... print("creator", r.next())
+ ... print("creator", next(r))
... return r
...
>>> def caller():
running:
>>> def g():
- ... i = me.next()
+ ... i = next(me)
... yield i
>>> me = g()
- >>> me.next()
+ >>> next(me)
Traceback (most recent call last):
...
File "<string>", line 2, in g
... yield f() # the zero division exception propagates
... yield 42 # and we'll never get here
>>> k = g()
- >>> k.next()
+ >>> next(k)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in g
File "<stdin>", line 2, in f
ZeroDivisionError: integer division or modulo by zero
- >>> k.next() # and the generator cannot be resumed
+ >>> next(k) # and the generator cannot be resumed
Traceback (most recent call last):
File "<stdin>", line 1, in ?
StopIteration
>>> type(i)
<type 'generator'>
>>> [s for s in dir(i) if not s.startswith('_')]
-['close', 'gi_frame', 'gi_running', 'next', 'send', 'throw']
->>> print(i.next.__doc__)
-x.next() -> the next value, or raise StopIteration
+['close', 'gi_frame', 'gi_running', 'send', 'throw']
+>>> print(i.__next__.__doc__)
+x.__next__() <==> next(x)
>>> iter(i) is i
True
>>> import types
>>> me = g()
>>> me.gi_running
0
->>> me.next()
+>>> next(me)
1
>>> me.gi_running
0
... yield x
...
... def find(self):
-... return self.generator.next()
+... return next(self.generator)
...
... def union(self, parent):
... if self.parent:
Build up to a recursive Sieve of Eratosthenes generator.
>>> def firstn(g, n):
-... return [g.next() for i in range(n)]
+... return [next(g) for i in range(n)]
>>> def intsfrom(i):
... while 1:
[1, 2, 4, 5, 7, 8]
>>> def sieve(ints):
-... prime = ints.next()
+... prime = next(ints)
... yield prime
... not_divisible_by_prime = exclude_multiples(prime, ints)
... for p in sieve(not_divisible_by_prime):
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
>>> def merge(g, h):
-... ng = g.next()
-... nh = h.next()
+... ng = next(g)
+... nh = next(h)
... while 1:
... if ng < nh:
... yield ng
-... ng = g.next()
+... ng = next(g)
... elif ng > nh:
... yield nh
-... nh = h.next()
+... nh = next(h)
... else:
... yield ng
-... ng = g.next()
-... nh = h.next()
+... ng = next(g)
+... nh = next(h)
The following works, but is doing a whale of a lot of redundant work --
it's not clear how to get the internal uses of m235 to share a single
>>> class LazyList:
... def __init__(self, g):
... self.sofar = []
-... self.fetch = g.next
+... self.fetch = g.__next__
...
... def __getitem__(self, i):
... sofar, fetch = self.sofar, self.fetch
...
... def sum(g, h):
... while 1:
-... yield g.next() + h.next()
+... yield next(g) + next(h)
...
... def tail(g):
-... g.next() # throw first away
+... next(g) # throw first away
... for x in g:
... yield x
...
...
... def _isum(g, h):
... while 1:
-... yield g.next() + h.next()
+... yield next(g) + next(h)
...
... def _fib():
... yield 1
... yield 2
-... fibTail.next() # throw first away
+... next(fibTail) # throw first away
... for res in _isum(fibHead, fibTail):
... yield res
...
... yield i
...
>>> g = f()
->>> print(g.next())
+>>> print(next(g))
0
->>> print(g.next())
+>>> print(next(g))
1
->>> print(g.next())
+>>> print(next(g))
2
->>> print(g.next())
+>>> print(next(g))
Traceback (most recent call last):
StopIteration
"""
# Descend.
try:
while i < n:
- it = iters[i] = gs[i]().next
+ it = iters[i] = gs[i]().__next__
values[i] = it()
i += 1
except _StopIteration:
... print((yield 1))
... yield 2
>>> g = f()
->>> g.next()
+>>> next(g)
1
>>> g.send(42)
42
... seq.append(count)
>>> seq = []
>>> c = coroutine(seq)
->>> c.next()
+>>> next(c)
>>> print(seq)
[]
>>> c.send(10)
... print("caught ValueError (%s)" % (v))
>>> import sys
>>> g = f()
->>> g.next()
+>>> next(g)
>>> g.throw(ValueError) # type only
caught ValueError ()
... print("exiting")
>>> g = f()
->>> g.next()
+>>> next(g)
>>> g.close()
exiting
>>> g.close() # should be no-op now
>>> def f(): yield # an even simpler generator
>>> f().close() # close before opening
>>> g = f()
->>> g.next()
+>>> next(g)
>>> g.close() # close normally
And finalization:
... print("exiting")
>>> g = f()
->>> g.next()
+>>> next(g)
>>> del g
exiting
... except GeneratorExit:
... yield "foo!"
>>> g = f()
->>> g.next()
+>>> next(g)
>>> g.close()
Traceback (most recent call last):
...
>>> import sys, StringIO
>>> old, sys.stderr = sys.stderr, StringIO.StringIO()
>>> g = f()
->>> g.next()
+>>> next(g)
>>> del g
>>> sys.stderr.getvalue().startswith(
... "Exception RuntimeError: 'generator ignored GeneratorExit' in "
... except GeneratorExit:
... raise TypeError("fie!")
>>> g = f()
->>> g.next()
+>>> next(g)
>>> g.close()
Traceback (most recent call last):
...
... class gen:
... def __iter__(self):
... return self
-... def next(self):
+... def __next__(self):
... return self.item
... g = gen()
... head, tail = itertools.tee(g)
Make sure to also test the involvement of the tee-internal teedataobject,
which stores returned items.
->>> item = it.next()
+>>> item = next(it)
Test direct calls to next()
>>> g = (i*i for i in range(3))
- >>> g.next()
+ >>> next(g)
0
- >>> g.next()
+ >>> next(g)
1
- >>> g.next()
+ >>> next(g)
4
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<pyshell#21>", line 1, in -toplevel-
- g.next()
+ next(g)
StopIteration
Does it stay stopped?
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<pyshell#21>", line 1, in -toplevel-
- g.next()
+ next(g)
StopIteration
>>> list(g)
[]
>>> def creator():
... r = yrange(5)
- ... print("creator", r.next())
+ ... print("creator", next(r))
... return r
>>> def caller():
... r = creator()
Verify that a gen exp cannot be resumed while it is actively running:
- >>> g = (me.next() for i in xrange(10))
+ >>> g = (next(me) for i in xrange(10))
>>> me = g
- >>> me.next()
+ >>> next(me)
Traceback (most recent call last):
File "<pyshell#30>", line 1, in -toplevel-
- me.next()
+ next(me)
File "<pyshell#28>", line 1, in <generator expression>
- g = (me.next() for i in xrange(10))
+ g = (next(me) for i in xrange(10))
ValueError: generator already executing
Verify exception propagation
>>> g = (10 // i for i in (5, 0, 2))
- >>> g.next()
+ >>> next(g)
2
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<pyshell#37>", line 1, in -toplevel-
- g.next()
+ next(g)
File "<pyshell#35>", line 1, in <generator expression>
g = (10 // i for i in (5, 0, 2))
ZeroDivisionError: integer division or modulo by zero
- >>> g.next()
+ >>> next(g)
Traceback (most recent call last):
File "<pyshell#38>", line 1, in -toplevel-
- g.next()
+ next(g)
StopIteration
Make sure that None is a valid return value
Check that generator attributes are present
>>> g = (i*i for i in range(3))
- >>> expected = set(['gi_frame', 'gi_running', 'next'])
+ >>> expected = set(['gi_frame', 'gi_running'])
>>> set(attr for attr in dir(g) if not attr.startswith('__')) >= expected
True
- >>> print(g.next.__doc__)
- x.next() -> the next value, or raise StopIteration
+ >>> print(g.__next__.__doc__)
+ x.__next__() <==> next(x)
>>> import types
>>> isinstance(g, types.GeneratorType)
True
>>> me = g
>>> me.gi_running
0
- >>> me.next()
+ >>> next(me)
1
>>> me.gi_running
0
def testGenexps(self):
# generator expression tests
g = ([x for x in range(10)] for x in range(1))
- self.assertEqual(g.next(), [x for x in range(10)])
+ self.assertEqual(next(g), [x for x in range(10)])
try:
- g.next()
+ next(g)
self.fail('should produce StopIteration exception')
except StopIteration:
pass
a = 1
try:
g = (a for d in a)
- g.next()
+ next(g)
self.fail('should produce TypeError')
except TypeError:
pass
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
return v
class N:
- 'Iterator missing next()'
+ 'Iterator missing __next__()'
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
3 // 0
class S:
pass
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise StopIteration
from itertools import chain, imap
def __init__(self, n):
self.n = n
self.i = 0
- def next(self):
+ def __next__(self):
res = self.i
if res >= self.n:
raise StopIteration
res = []
while 1:
try:
- val = it.next()
+ val = next(it)
except StopIteration:
break
res.append(val)
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
i = self.i
self.i = i + 1
if i < len(self.vals):
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
i = self.i
self.i = i+1
return i
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
i = self.i
self.i = i+1
if i == 2:
return unicode("fooled you!")
- return self.it.next()
+ return next(self.it)
f = open(TESTFN, "w")
try:
self.finish = finish
self.i = self.start
- def next(self):
+ def __next__(self):
if self.i >= self.finish:
raise StopIteration
result = str(self.i) + '\n'
A complication is that an iterable and iterator can be the same object. To
maintain the invariant, an iterator needs to dynamically update its length.
For instance, an iterable such as xrange(10) always reports its length as ten,
-but it=iter(xrange(10)) starts at ten, and then goes to nine after it.next().
+but it=iter(xrange(10)) starts at ten, and then goes to nine after next(it).
Having this capability means that map() can ignore the distinction between
map(func, iterable) and map(func, iter(iterable)).
it = self.it
for i in reversed(xrange(1, n+1)):
self.assertEqual(len(it), i)
- it.next()
+ next(it)
self.assertEqual(len(it), 0)
- self.assertRaises(StopIteration, it.next)
+ self.assertRaises(StopIteration, next, it)
self.assertEqual(len(it), 0)
class TestTemporarilyImmutable(TestInvariantWithoutMutations):
it = self.it
self.assertEqual(len(it), n)
- it.next()
+ next(it)
self.assertEqual(len(it), n-1)
self.mutate()
- self.assertRaises(RuntimeError, it.next)
+ self.assertRaises(RuntimeError, next, it)
self.assertEqual(len(it), 0)
## ------- Concrete Type Tests -------
def test_mutation(self):
d = range(n)
it = iter(d)
- it.next()
- it.next()
+ next(it)
+ next(it)
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-1) # grow with append
def test_mutation(self):
d = range(n)
it = reversed(d)
- it.next()
- it.next()
+ next(it)
+ next(it)
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-2) # ignore append
def test_mutation(self):
d = UserList(range(n))
it = iter(d)
- it.next()
- it.next()
+ next(it)
+ next(it)
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-1) # grow with append
def test_mutation(self):
d = UserList(range(n))
it = reversed(d)
- it.next()
- it.next()
+ next(it)
+ next(it)
self.assertEqual(len(it), n-2)
d.append(n)
self.assertEqual(len(it), n-2) # ignore append
'Class emulating an empty iterable.'
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise StopIteration
def take(n, seq):
self.assertRaises(OverflowError, list, islice(count(sys.maxint-5), 10))
c = count(3)
self.assertEqual(repr(c), 'count(3)')
- c.next()
+ next(c)
self.assertEqual(repr(c), 'count(4)')
c = count(-9)
self.assertEqual(repr(c), 'count(-9)')
- c.next()
- self.assertEqual(c.next(), -8)
+ next(c)
+ self.assertEqual(next(c), -8)
def test_cycle(self):
self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
r = sorted([(len(list(g)) , k) for k, g in groupby(sorted(s))], reverse=True)[:3]
self.assertEqual(r, [(5, 'a'), (2, 'r'), (2, 'b')])
- # iter.next failure
+ # iter.__next__ failure
class ExpectedError(Exception):
pass
def delayed_raise(n=0):
def gulp(iterable, keyp=None, func=list):
return [func(g) for k, g in groupby(iterable, keyp)]
- # iter.next failure on outer object
+ # iter.__next__ failure on outer object
self.assertRaises(ExpectedError, gulp, delayed_raise(0))
- # iter.next failure on inner object
+ # iter.__next__ failure on inner object
self.assertRaises(ExpectedError, gulp, delayed_raise(1))
# __cmp__ failure
self.assertRaises(TypeError, ifilter, lambda x:x)
self.assertRaises(TypeError, ifilter, lambda x:x, range(6), 7)
self.assertRaises(TypeError, ifilter, isEven, 3)
- self.assertRaises(TypeError, ifilter(range(6), range(6)).next)
+ self.assertRaises(TypeError, next, ifilter(range(6), range(6)))
def test_ifilterfalse(self):
self.assertEqual(list(ifilterfalse(isEven, range(6))), [1,3,5])
self.assertRaises(TypeError, ifilterfalse, lambda x:x)
self.assertRaises(TypeError, ifilterfalse, lambda x:x, range(6), 7)
self.assertRaises(TypeError, ifilterfalse, isEven, 3)
- self.assertRaises(TypeError, ifilterfalse(range(6), range(6)).next)
+ self.assertRaises(TypeError, next, ifilterfalse(range(6), range(6)))
def test_izip(self):
# XXX This is rather silly now that builtin zip() calls izip()...
self.assertEqual(list(imap(operator.pow, [])), [])
self.assertRaises(TypeError, imap)
self.assertRaises(TypeError, imap, operator.neg)
- self.assertRaises(TypeError, imap(10, range(5)).next)
- self.assertRaises(ValueError, imap(errfunc, [4], [5]).next)
- self.assertRaises(TypeError, imap(onearg, [4], [5]).next)
+ self.assertRaises(TypeError, next, imap(10, range(5)))
+ self.assertRaises(ValueError, next, imap(errfunc, [4], [5]))
+ self.assertRaises(TypeError, next, imap(onearg, [4], [5]))
def test_starmap(self):
self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
self.assertRaises(TypeError, list, starmap(operator.pow, [[4,5]]))
self.assertRaises(TypeError, starmap)
self.assertRaises(TypeError, starmap, operator.pow, [(4,5)], 'extra')
- self.assertRaises(TypeError, starmap(10, [(4,5)]).next)
- self.assertRaises(ValueError, starmap(errfunc, [(4,5)]).next)
- self.assertRaises(TypeError, starmap(onearg, [(4,5)]).next)
+ self.assertRaises(TypeError, next, starmap(10, [(4,5)]))
+ self.assertRaises(ValueError, next, starmap(errfunc, [(4,5)]))
+ self.assertRaises(TypeError, next, starmap(onearg, [(4,5)]))
def test_islice(self):
for args in [ # islice(args) should agree with range(args)
self.assertRaises(TypeError, takewhile)
self.assertRaises(TypeError, takewhile, operator.pow)
self.assertRaises(TypeError, takewhile, operator.pow, [(4,5)], 'extra')
- self.assertRaises(TypeError, takewhile(10, [(4,5)]).next)
- self.assertRaises(ValueError, takewhile(errfunc, [(4,5)]).next)
+ self.assertRaises(TypeError, next, takewhile(10, [(4,5)]))
+ self.assertRaises(ValueError, next, takewhile(errfunc, [(4,5)]))
t = takewhile(bool, [1, 1, 1, 0, 0, 0])
self.assertEqual(list(t), [1, 1, 1])
- self.assertRaises(StopIteration, t.next)
+ self.assertRaises(StopIteration, next, t)
def test_dropwhile(self):
data = [1, 3, 5, 20, 2, 4, 6, 8]
self.assertRaises(TypeError, dropwhile)
self.assertRaises(TypeError, dropwhile, operator.pow)
self.assertRaises(TypeError, dropwhile, operator.pow, [(4,5)], 'extra')
- self.assertRaises(TypeError, dropwhile(10, [(4,5)]).next)
- self.assertRaises(ValueError, dropwhile(errfunc, [(4,5)]).next)
+ self.assertRaises(TypeError, next, dropwhile(10, [(4,5)]))
+ self.assertRaises(ValueError, next, dropwhile(errfunc, [(4,5)]))
def test_tee(self):
n = 200
a, b = tee(irange(n)) # test dealloc of leading iterator
for i in xrange(100):
- self.assertEqual(a.next(), i)
+ self.assertEqual(next(a), i)
del a
self.assertEqual(list(b), range(n))
a, b = tee(irange(n)) # test dealloc of trailing iterator
for i in xrange(100):
- self.assertEqual(a.next(), i)
+ self.assertEqual(next(a), i)
del b
self.assertEqual(list(a), range(100, n))
lists = ([], [])
its = tee(irange(n))
for i in order:
- value = its[i].next()
+ value = next(its[i])
lists[i].append(value)
self.assertEqual(lists[0], range(n))
self.assertEqual(lists[1], range(n))
# test long-lagged and multi-way split
a, b, c = tee(xrange(2000), 3)
for i in xrange(100):
- self.assertEqual(a.next(), i)
+ self.assertEqual(next(a), i)
self.assertEqual(list(b), range(2000))
- self.assertEqual([c.next(), c.next()], range(2))
+ self.assertEqual([next(c), next(c)], range(2))
self.assertEqual(list(a), range(100,2000))
self.assertEqual(list(c), range(2,2000))
self.assertRaises(ReferenceError, getattr, p, '__class__')
def test_StopIteration(self):
- self.assertRaises(StopIteration, izip().next)
+ self.assertRaises(StopIteration, next, izip())
for f in (chain, cycle, izip, groupby):
- self.assertRaises(StopIteration, f([]).next)
- self.assertRaises(StopIteration, f(StopNow()).next)
+ self.assertRaises(StopIteration, next, f([]))
+ self.assertRaises(StopIteration, next, f(StopNow()))
- self.assertRaises(StopIteration, islice([], None).next)
- self.assertRaises(StopIteration, islice(StopNow(), None).next)
+ self.assertRaises(StopIteration, next, islice([], None))
+ self.assertRaises(StopIteration, next, islice(StopNow(), None))
p, q = tee([])
- self.assertRaises(StopIteration, p.next)
- self.assertRaises(StopIteration, q.next)
+ self.assertRaises(StopIteration, next, p)
+ self.assertRaises(StopIteration, next, q)
p, q = tee(StopNow())
- self.assertRaises(StopIteration, p.next)
- self.assertRaises(StopIteration, q.next)
+ self.assertRaises(StopIteration, next, p)
+ self.assertRaises(StopIteration, next, q)
- self.assertRaises(StopIteration, repeat(None, 0).next)
+ self.assertRaises(StopIteration, next, repeat(None, 0))
for f in (ifilter, ifilterfalse, imap, takewhile, dropwhile, starmap):
- self.assertRaises(StopIteration, f(lambda x:x, []).next)
- self.assertRaises(StopIteration, f(lambda x:x, StopNow()).next)
+ self.assertRaises(StopIteration, next, f(lambda x:x, []))
+ self.assertRaises(StopIteration, next, f(lambda x:x, StopNow()))
class TestGC(unittest.TestCase):
def makecycle(self, iterator, container):
container.append(iterator)
- iterator.next()
+ next(iterator)
del container, iterator
def test_chain(self):
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
return v
class N:
- 'Iterator missing next()'
+ 'Iterator missing __next__()'
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
3 // 0
class S:
pass
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise StopIteration
def L(seqn):
def g(value, first=[1]):
if first:
del first[:]
- f(z.next())
+ f(next(z))
return value
items = list(tuple2)
items[1:1] = list(tuple1)
gen = imap(g, items)
z = izip(*[gen]*len(tuple1))
- z.next()
+ next(z)
def f(t):
global T
... "s -> (s0,s1), (s1,s2), (s2, s3), ..."
... a, b = tee(iterable)
... try:
-... b.next()
+... next(b)
... except StopIteration:
... pass
... return izip(a, b)
# Iterate by line
proxy.seek(0)
iterator = iter(proxy)
- self.assert_(iterator.next() == 'foo' + os.linesep)
- self.assert_(iterator.next() == 'bar' + os.linesep)
- self.assert_(iterator.next() == 'fred' + os.linesep)
- self.assert_(iterator.next() == 'bob')
- self.assertRaises(StopIteration, lambda: iterator.next())
+ self.assert_(next(iterator) == 'foo' + os.linesep)
+ self.assert_(next(iterator) == 'bar' + os.linesep)
+ self.assert_(next(iterator) == 'fred' + os.linesep)
+ self.assert_(next(iterator) == 'bob')
+ self.assertRaises(StopIteration, next, iterator)
def _test_seek_and_tell(self, proxy):
# Seek and use tell to check position
def test_bug_581080(self):
iter = re.finditer(r"\s", "a b")
- self.assertEqual(iter.next().span(), (1,2))
- self.assertRaises(StopIteration, iter.next)
+ self.assertEqual(next(iter).span(), (1,2))
+ self.assertRaises(StopIteration, next, iter)
scanner = re.compile(r"\s").scanner("a b")
self.assertEqual(scanner.search().span(), (1, 2))
def test_bug_817234(self):
iter = re.finditer(r".*", "asdf")
- self.assertEqual(iter.next().span(), (0, 4))
- self.assertEqual(iter.next().span(), (4, 4))
- self.assertRaises(StopIteration, iter.next)
+ self.assertEqual(next(iter).span(), (0, 4))
+ self.assertEqual(next(iter).span(), (4, 4))
+ self.assertRaises(StopIteration, next, iter)
def run_re_tests():
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
- def next(self):
+ def __next__(self):
if self.i >= len(self.seqn): raise StopIteration
v = self.seqn[self.i]
self.i += 1
return v
class N:
- 'Iterator missing next()'
+ 'Iterator missing __next__()'
def __init__(self, seqn):
self.seqn = seqn
self.i = 0
self.i = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
3 // 0
class S:
pass
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
raise StopIteration
from itertools import chain, imap
def test_iterators(self):
# Make sure str objects have an __iter__ method
it = "abc".__iter__()
- self.assertEqual(it.next(), "a")
- self.assertEqual(it.next(), "b")
- self.assertEqual(it.next(), "c")
- self.assertRaises(StopIteration, it.next)
+ self.assertEqual(next(it), "a")
+ self.assertEqual(next(it), "b")
+ self.assertEqual(next(it), "c")
+ self.assertRaises(StopIteration, next, it)
def test_conversion(self):
# Make sure __str__() behaves properly
def test_get_six_char_str(self):
# _RandomNameSequence returns a six-character string
- s = self.r.next()
+ s = next(self.r)
self.nameCheck(s, '', '', '')
def test_many(self):
dict = {}
r = self.r
for i in xrange(TEST_FILES):
- s = r.next()
+ s = next(r)
self.nameCheck(s, '', '', '')
self.failIf(s in dict)
dict[s] = 1
t1 = [tok[:2] for tok in fulltok]
newtext = untokenize(t1)
- readline = iter(newtext.splitlines(1)).next
+ readline = iter(newtext.splitlines(1)).__next__
t2 = [tok[:2] for tok in generate_tokens(readline)]
if t1 != t2:
raise TestFailed("untokenize() roundtrip failed for %r" % f)
This function exists solely to test the tokenization of the RARROW
operator.
- >>> tokenize(iter(['->']).next) #doctest: +NORMALIZE_WHITESPACE
+ >>> tokenize(iter(['->']).__next__) #doctest: +NORMALIZE_WHITESPACE
1,0-1,2:\tOP\t'->'
2,0-2,0:\tENDMARKER\t''
"""
def test_iterators(self):
# Make sure unicode objects have an __iter__ method
it = u"\u1111\u2222\u3333".__iter__()
- self.assertEqual(it.next(), u"\u1111")
- self.assertEqual(it.next(), u"\u2222")
- self.assertEqual(it.next(), u"\u3333")
- self.assertRaises(StopIteration, it.next)
+ self.assertEqual(next(it), u"\u1111")
+ self.assertEqual(next(it), u"\u2222")
+ self.assertEqual(next(it), u"\u3333")
+ self.assertRaises(StopIteration, next, it)
def test_count(self):
string_tests.CommonTest.test_count(self)
class T(self.type2test):
def __getitem__(self, key):
return str(key) + '!!!'
- self.assertEqual(iter(T((1,2))).next(), "0!!!")
+ self.assertEqual(next(iter(T((1,2)))), "0!!!")
def test_main():
test_support.run_unittest(UserListTest)
it = make_it()
if not iter(it) is it: raise AssertionError
for item in match:
- if not it.next()==item: raise AssertionError
+ if not next(it) == item: raise AssertionError
try:
- it.next()
+ next(it)
except StopIteration:
pass
else:
- raise AssertionError("Too many items from .next()",it)
+ raise AssertionError("Too many items from .__next__()", it)
# Output text will tokenize the back to the input
t1 = [tok[:2] for tok in generate_tokens(f.readline)]
newcode = untokenize(t1)
- readline = iter(newcode.splitlines(1)).next
+ readline = iter(newcode.splitlines(1)).__next__
t2 = [tok[:2] for tokin generate_tokens(readline)]
assert t1 == t2
"""
readline() method of built-in file objects. Each call to the function
should return one line of input as a string. Alternately, readline
can be a callable function terminating with StopIteration:
- readline = open(myfile).next # Example of alternate readline
+ readline = open(myfile).__next__ # Example of alternate readline
The generator produces 5-tuples with these members: the token type; the
token string; a 2-tuple (srow, scol) of ints specifying the row and
# Iterators in Python aren't a matter of type but of protocol. A large
# and changing number of builtin types implement *some* flavor of
# iterator. Don't check the type! Use hasattr to check for both
-# "__iter__" and "next" attributes instead.
+# "__iter__" and "__next__" attributes instead.
NoneType = type(None)
TypeType = type
self.fileno = lambda: None
if hasattr(self.fp, "__iter__"):
self.__iter__ = self.fp.__iter__
- if hasattr(self.fp, "next"):
- self.next = self.fp.next
+ if hasattr(self.fp, "__next__"):
+ self.__next__ = self.fp.__next__
def __repr__(self):
return '<%s at %r whose fp = %r>' % (self.__class__.__name__,
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
data = self.filelike.read(self.blksize)
if data:
return data
- That it is not a string (it should be a list of a single string; a
string will work, but perform horribly).
- - That .next() returns a string
+ - That .__next__() returns a string
- That the iterator is not iterated over until start_response has
been called (that can signal either a server or application
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
assert_(not self.closed,
"Iterator read after closed")
- v = self.iterator.next()
+ v = next(self.iterator)
if self.check_start_response is not None:
assert_(self.check_start_response,
"The application returns and we started iterating over its body, but start_response has not yet been called")
return rc
raise IndexError
- def next(self):
+ def __next__(self):
rc = self.getEvent()
if rc:
return rc
append((event, None))
parser.EndNamespaceDeclHandler = handler
- def next(self):
+ def __next__(self):
while 1:
try:
item = self._events[self._index]
return self
except NameError:
def __getitem__(self, index):
- return self.next()
+ return self.__next__()
##
# Parses an XML document from a string constant. This function can
overflow = None
while total_len < fill_len:
try:
- new_item = it.next()
+ new_item = next(it)
buffer_.append(new_item)
total_len += len(new_item) + 1
except StopIteration:
FILL - len(prefix) - len(indent))
try:
while True:
- print>>FILE, indent + prefix + stmt_iter.next()
+ print>>FILE, indent + prefix + next(stmt_iter)
except StopIteration:
print>>FILE, ''
else:
return [result] -- Exits from function (or method) and returns result (use a tuple to
return more than one value). If no result given, then returns None.
yield result -- Freezes the execution frame of a generator and returns the result
- to the iterator's .next() method. Upon the next call to next(),
+ to the iterator's .__next__() method. Upon the next call to __next__(),
resumes execution at the frozen point with all of the local variables
still intact.
SystemExit
On 'sys.exit()'
StopIteration
- Signal the end from iterator.next()
+ Signal the end from iterator.__next__()
StandardError
Base class for all built-in exceptions; derived from Exception
root class.
PyDoc_STRVAR(chain_doc,
"chain(*iterables) --> chain object\n\
\n\
-Return a chain object whose .next() method returns elements from the\n\
+Return a chain object whose .__next__() method returns elements from the\n\
first iterable until it is exhausted, then elements from the next\n\
iterable, until all of the iterables are exhausted.");
PyDoc_STRVAR(count_doc,
"count([firstval]) --> count object\n\
\n\
-Return a count object whose .next() method returns consecutive\n\
+Return a count object whose .__next__() method returns consecutive\n\
integers starting from zero or, if specified, from firstval.");
static PyTypeObject count_type = {
PyDoc_STRVAR(izip_doc,
"izip(iter1 [,iter2 [...]]) --> izip object\n\
\n\
-Return a izip object whose .next() method returns a tuple where\n\
-the i-th element comes from the i-th iterable argument. The .next()\n\
+Return a izip object whose .__next__() method returns a tuple where\n\
+the i-th element comes from the i-th iterable argument. The .__next__()\n\
method continues until the shortest iterable in the argument sequence\n\
is exhausted and then it raises StopIteration. Works like the zip()\n\
function but consumes less memory by returning an iterator instead of\n\
PyDoc_STRVAR(izip_longest_doc,
"izip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> izip_longest object\n\
\n\
-Return an izip_longest object whose .next() method returns a tuple where\n\
-the i-th element comes from the i-th iterable argument. The .next()\n\
+Return an izip_longest object whose .__next__() method returns a tuple where\n\
+the i-th element comes from the i-th iterable argument. The .__next__()\n\
method continues until the longest iterable in the argument sequence\n\
is exhausted and then it raises StopIteration. When the shorter iterables\n\
are exhausted, the fillvalue is substituted in their place. The fillvalue\n\
* StopIteration extends Exception
*/
SimpleExtendsException(PyExc_Exception, StopIteration,
- "Signal the end from iterator.next().");
+ "Signal the end from iterator.__next__().");
/*
slot_tp_iternext(PyObject *self)
{
static PyObject *next_str;
- return call_method(self, "next", &next_str, "()");
+ return call_method(self, "__next__", &next_str, "()");
}
static PyObject *
"x.__ge__(y) <==> x>=y"),
TPSLOT("__iter__", tp_iter, slot_tp_iter, wrap_unaryfunc,
"x.__iter__() <==> iter(x)"),
- TPSLOT("next", tp_iternext, slot_tp_iternext, wrap_next,
- "x.next() -> the next value, or raise StopIteration"),
+ TPSLOT("__next__", tp_iternext, slot_tp_iternext, wrap_next,
+ "x.__next__() <==> next(x)"),
TPSLOT("__get__", tp_descr_get, slot_tp_descr_get, wrap_descr_get,
"descr.__get__(obj[, type]) -> value"),
TPSLOT("__set__", tp_descr_set, slot_tp_descr_set, wrap_descr_set,
the items of the sequence (or a list of tuples if more than one sequence).");
+static PyObject *
+builtin_next(PyObject *self, PyObject *args)
+{
+ PyObject *it, *res;
+ PyObject *def = NULL;
+
+ if (!PyArg_UnpackTuple(args, "next", 1, 2, &it, &def))
+ return NULL;
+ if (!PyIter_Check(it)) {
+ PyErr_Format(PyExc_TypeError,
+ "%.200s object is not an iterator", it->ob_type->tp_name);
+ return NULL;
+ }
+
+ res = (*it->ob_type->tp_iternext)(it);
+ if (res == NULL) {
+ if (def) {
+ if (PyErr_Occurred() &&
+ !PyErr_ExceptionMatches(PyExc_StopIteration))
+ return NULL;
+ PyErr_Clear();
+ Py_INCREF(def);
+ return def;
+ } else if (PyErr_Occurred()) {
+ return NULL;
+ } else {
+ PyErr_SetNone(PyExc_StopIteration);
+ return NULL;
+ }
+ }
+ return res;
+}
+
+PyDoc_STRVAR(next_doc,
+"next(iterator[, default])\n\
+\n\
+Return the next item from the iterator. If default is given and the iterator\n\
+is exhausted, it is returned instead of raising StopIteration.");
+
+
static PyObject *
builtin_setattr(PyObject *self, PyObject *args)
{
{"map", builtin_map, METH_VARARGS, map_doc},
{"max", (PyCFunction)builtin_max, METH_VARARGS | METH_KEYWORDS, max_doc},
{"min", (PyCFunction)builtin_min, METH_VARARGS | METH_KEYWORDS, min_doc},
+ {"next", (PyCFunction)builtin_next, METH_VARARGS, next_doc},
{"oct", builtin_oct, METH_O, oct_doc},
{"open", (PyCFunction)builtin_open, METH_VARARGS | METH_KEYWORDS, open_doc},
{"ord", builtin_ord, METH_O, ord_doc},
OP = tokenize.OP
changed = self.changed
- get = tokenize.generate_tokens(self.getline).next
+ get = tokenize.generate_tokens(self.getline).__next__
type, token, (srow, scol), (erow, ecol), line = get()
# Chew up initial comments and blank lines (if any).
projects / python / commitdiff