hasnext() for Python iterators?

Question

Do Python iterators have a hasnext method?

Answer 1

The alternative to catching StopIteration is to use next(iterator, default_value).

For example:

>>> a = iter('hi')
>>> print(next(a, None))
h
>>> print(next(a, None))
i
>>> print(next(a, None))
None

This way you can check for None to see if you've reached the end of the iterator if you don't want to do it the exception way.

If your iterable can contain None values you'll have to define a sentinel value and check for it instead:

>>> sentinel = object()
>>> a = iter([None, 1, 2])
>>> elem = next(a, sentinel)
>>> if elem is sentinel:
...     print('end')
... 
>>>

Answer 2

No, there is no such method. The end of iteration is indicated by an exception. See the documentation.

Answer 3

No, but you can implement your own iterable wrapper class that does:

from collections.abc import Iterator

class hn_wrapper(Iterator):
    def __init__(self, it):
        self.it = iter(it)
        self._hasnext = None
    def __iter__(self): 
        return self
    def __next__(self):
        if self._hasnext:
            result = self._thenext
        else:
            result = next(self.it)
        self._hasnext = None
        return result
    def hasnext(self):
        if self._hasnext is None:
            try: 
                self._thenext = next(self.it)
            except StopIteration: 
                self._hasnext = False
            else:
                self._hasnext = True
        return self._hasnext

Then you can use it like this:

x = hn_wrapper('ciao')
while x.hasnext():
    print(next(x))

and it will emit

c
i
a
o

Answer 4

In addition to all the mentions of StopIteration, the Python for loop does what you want:

>>> it = iter('hello')
>>> for i in it:
...     print(i)
...
h
e
l
l
o

Answer 5

Try the __length_hint__() method from any iterator object:

iter(...).__length_hint__() > 0

Answer 6

You can tee the iterator using, itertools.tee, and check for StopIteration on the teed iterator.

Answer 7

hasNext somewhat translates to the StopIteration exception, e.g.:

>>> it = iter("hello")
>>> it.next()
'h'
>>> it.next()
'e'
>>> it.next()
'l'
>>> it.next()
'l'
>>> it.next()
'o'
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

• StopIteration docs: http://docs.python.org/library/exceptions.html#exceptions.StopIteration
• Some article about iterators and generator in python: http://www.ibm.com/developerworks/library/l-pycon.html

Answer 8

No. The most similar concept is most likely a StopIteration exception.

Answer 9

I believe python just has next() and according to the doc, it throws an exception is there are no more elements.

http://docs.python.org/library/stdtypes.html#iterator-types

Answer 10

The use case that lead me to search for this is the following

def setfrom(self,f):
    """Set from iterable f"""
    fi = iter(f)
    for i in range(self.n):
        try:
            x = next(fi)
        except StopIteration:
            fi = iter(f)
            x = next(fi)
        self.a[i] = x 

where hasnext() is available, one could do

def setfrom(self,f):
    """Set from iterable f"""
    fi = iter(f)
    for i in range(self.n):
        if not hasnext(fi):
            fi = iter(f) # restart
        self.a[i] = next(fi)

which to me is cleaner. Obviously you can work around issues by defining utility classes, but what then happens is you have a proliferation of twenty-odd different almost-equivalent workarounds each with their quirks, and if you wish to reuse code that uses different workarounds, you have to either have multiple near-equivalent in your single application, or go around picking through and rewriting code to use the same approach. The 'do it once and do it well' maxim fails badly.

Furthermore, the iterator itself needs to have an internal 'hasnext' check to run to see if it needs to raise an exception. This internal check is then hidden so that it needs to be tested by trying to get an item, catching the exception and running the handler if thrown. This is unnecessary hiding IMO.

Answer 11

Maybe it's just me, but while I like https://stackoverflow.com/users/95810/alex-martelli 's answer, I find this a bit easier to read:

from collections.abc import Iterator  # since python 3.3 Iterator is here

class MyIterator(Iterator):  # need to subclass Iterator rather than object
  def __init__(self, it):
    self._iter = iter(it)
    self._sentinel = object()
    self._next = next(self._iter, self._sentinel)
    
  def __iter__(self): 
    return self
  
  def __next__(self):        # __next__ vs next in python 2
    if not self.has_next():
      next(self._iter)  # raises StopIteration

    val = self._next
    self._next = next(self._iter, self._sentinel)
    return val
  
  def has_next(self):
    return self._next is not self._sentinel

Answer 12

No, there is no such method. The end of iteration is indicated by a StopIteration (more on that here).

---

This follows the python principle EAFP (easier to ask for forgiveness than permission). A has_next method would follow the principle of LBYL (look before you leap) and contradicts this core python principle.

This interesting article explains the two concepts in more detail.

Answer 13

It is also possible to implement a helper generator that wraps any iterator and answers question if it has next value:

Try it online!

def has_next(it):
    first = True
    for e in it:
        if not first:
            yield True, prev
        else:
            first = False
        prev = e
    if not first:
        yield False, prev

for has_next_, e in has_next(range(4)):
    print(has_next_, e)

Which outputs:

True 0
True 1
True 2
False 3

The main and probably only drawback of this method is that it reads ahead one more element, for most of tasks it is totally alright, but for some tasks it may be disallowed, especially if user of has_next() is not aware of this read-ahead logic and may missuse it.

Code above works for infinite iterators too.

Actually for all cases that I ever programmed such kind of has_next() was totally enough and didn't cause any problems and in fact was very helpful. You just have to be aware of its read-ahead logic.

Answer 14

The way has solved it based on handling the "StopIteration" execption is pretty straightforward in order to read all iterations :

    end_cursor = False
    while not end_cursor:
        try:
            print(cursor.next())
        except StopIteration:
            print('end loop')
            end_cursor = True
        except:
            print('other exceptions to manage')
            end_cursor = True

Answer 15

I think there are valid use cases for when you may want some sort of has_next functionality, in which case you should decorate an iterator with a has_next defined.

Combining concepts from the answers to this question here is my implementation of that which feels like a nice concise solution to me (python 3.9):

_EMPTY_BUF = object()


class BufferedIterator(Iterator[_T]):
    def __init__(self, real_it: Iterator[_T]):
        self._real_it = real_it
        self._buf = next(self._real_it, _EMPTY_BUF)

    def has_next(self):
        return self._buf is not _EMPTY_BUF

    def __next__(self) -> _T_co:
        v = self._buf
        self._buf = next(self._real_it, _EMPTY_BUF)
        if v is _EMPTY_BUF:
            raise StopIteration()
        return v

The main difference is that has_next is just a boolean expression, and also handles iterators with None values.

Added this to a gist here with tests and example usage.

Answer 16

There is no has_next in Python, but you can achieve has_next functionality for iterators like this:

class BSTIterator:

    def __init__(self, root: Optional[TreeNode]):
        def inorder_dfs(root):
            if root is None:
                return
            yield from inorder_dfs(root.left)
            yield root.val
            yield from inorder_dfs(root.right)
        self.inorder_generator = inorder_dfs(root)
        self.has_next = None

    def next(self) -> int:
        if self.has_next is not None:
            temp = self.has_next
            self.has_next = None
            return temp
        return next(self.inorder_generator)

    def hasNext(self) -> bool:
        if self.has_next is not None:
            return True
        try:
            self.has_next = next(self.inorder_generator)
            return True
        except StopIteration:
            return False

Answer 17

The way I solved my problem is to keep the count of the number of objects iterated over, so far. I wanted to iterate over a set using calls to an instance method. Since I knew the length of the set, and the number of items counted so far, I effectively had an hasNext method.

A simple version of my code:

class Iterator:
    # s is a string, say
    def __init__(self, s):
        self.s = set(list(s))
        self.done = False
        self.iter = iter(s)
        self.charCount = 0

    def next(self):
        if self.done:
            return None
        self.char = next(self.iter)
        self.charCount += 1
        self.done = (self.charCount < len(self.s))
        return self.char

    def hasMore(self):
        return not self.done

Of course, the example is a toy one, but you get the idea. This won't work in cases where there is no way to get the length of the iterable, like a generator etc.

Answer 18

very interesting question, but this "hasnext" design had been put into leetcode: https://leetcode.com/problems/iterator-for-combination/

here is my implementation:

class CombinationIterator:

def __init__(self, characters: str, combinationLength: int):
    from itertools import combinations
    from collections import deque
    self.iter = combinations(characters, combinationLength)
    self.res = deque()


def next(self) -> str:
    if len(self.res) == 0:
        return ''.join(next(self.iter))
    else:
        return ''.join(self.res.pop())


def hasNext(self) -> bool:
    try:
        self.res.insert(0, next(self.iter))
        return True
    except:
        return len(self.res) > 0