Difference between callable-iterator and listiterator and iterator?

Question

There are multiple iterator classes depending on what you're iterating over:

>>> import re
>>> re.finditer("\d+", "1 ha 2 bah").__class__
<type 'callable-iterator'>
>>> iter([1, 2]).__class__
<type 'listiterator'>
>>> iter("hurm").__class__
<type 'iterator'>

Two questions:

1. Is there any meaningful distinction between them?
2. Why is the first one called a callable-iterator? You definitely cannot call it.

Answer 1

BrenBarn answers #1 quite delightfully, but I believe I have unlocked the mysteries of #2. To wit, a callable-iterator is that which is returned for using iter with its second form:

>>> help(iter)
iter(...)
    iter(collection) -> iterator
    iter(callable, sentinel) -> iterator

    Get an iterator from an object.  In the first form, the argument must
    supply its own iterator, or be a sequence.
    In the second form, the callable is called until it returns the sentinel.

To wit:

>>> def globals_are_bad_mmkay():
        global foo
        foo += 1
        return foo

>>> foo = 0
>>> it = iter(globals_are_bad_mmkay, 10)
>>> it
<callable-iterator object at 0x021609B0>
>>> list(it)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Answer 2

Being an iterator means implementing the iterator protocol, not being a member of a particular class -- an iterator is as an iterator does. You can write your own custom classes that are iterators, and they won't be any of those classes you list.

From the point of view of "being an iterator", there is no difference between them. They are all iterators, and that just means you can iterate over them. There are might of course be other differences between them -- they might have additional methods or behavior defined -- but as iterators qua iterators they are the same.

You can view an iterator as some kind of doodad that "knows how" to iterate over a particular data structure. Different kinds of data structures might have their own custom classes for iterating over them; these iterators may do different things under the hood, but all share the same public interface (the iterator protocol).