Cfrgtkky

In Python 2.6 or better, the designed-in idiom for such behavioral checks is a "membership check" with the abstract base class in the collections module of the standard library:

>>> import collections

>>> isinstance('ciao', collections.Iterable)

True

>>> isinstance(23, collections.Iterable)

False

>>> isinstance(xrange(23), collections.Iterable)

True

Indeed, this kind of checks is the prime design reason for the new abstract base classes (a second important one is to provide "mixin functionality" in some cases, which is why they're ABCs rather than just interfaces -- but that doesn't apply to collections.Iterable, it exists strictly to allow such checks with isinstance or issubclass). ABCs allow classes that don't actually inherit from them to be "registered" as subclasses anyway, so that such classes can be "subclasses" of the ABC for such checks; and, they can internally perform all needed checks for special methods (__iter__ in this case), so you don't have to.

If you're stuck with older releases of Python, "it's better to ask forgiveness than permission":

def isiterable(x):

  try: iter(x)

  except TypeError: return False

  else: return True

but that's not as fast and concise as the new approach.

Note that for this special case you'll often want to special-case strings (which are iterable but most application contexts want to treat as "scalars" anyway). Whatever approach you're using to check iterableness, if you need such special casing just prepend a check for isinstance(x, basestring) -- for example:

def reallyiterable(x):

  return not isinstance(x, basestring) and isinstance(x, collections.Iterable)

Edit: as pointed out in a comment, the question focuses on whether an object is an iter***ator*** rather than whether it's iter***able*** (all iterators are iterable, but not vice versa -- not all iterables are iterators). isinstance(x, collections.Iterator) is the perfectly analogous way to check for that condition specifically.

An object is iterable if it implements the iterator protocol.

You could check the presence of __iter__() method with:

hasattr(object,'__iter__')

in Python 2.x this approach misses str objects and other built-in sequence types like unicode, xrange, buffer. It works in Python 3.

Another way is to test it with iter method :

try:

   iter(object)

except TypeError:

   #not iterable

To be an iterator an object must pass three tests:

• 
  obj has an __iter__ method


• 
  obj has a next method (or __next__ in Python 3)


• 
  obj.__iter__() returns obj
  

So, a roll-your-own test would look like:

def is_iterator(obj):

    if (

            hasattr(obj, '__iter__') and

            hasattr(obj, 'next') and      # or __next__ in Python 3

            callable(obj.__iter__) and

            obj.__iter__() is obj

        ):

        return True

    else:

        return False

answer from python sourcecode doc comments:

{python install path}/Versions/3.5/lib/python3.5/types.py

# 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.

As the question is about Iterator not Iterable and considering usage of iterator, a simplest and pythonic way of doing this

iterable = [1,2]

iterator = iter(iterable)





def isIterator(obj):

    try:

        next(obj, None)

        return True

    except TypeError:

        return False



>>> isIterator(iterable)

False

>>> isIterator(iterator)

True

Yes. Checking on next() should be enough

There is a better method than other answers have suggested.

In Python we have two kinds of things: Iterable and Iterator. An object is Iterable if it can give you Iterator. It does so when you use iter() on it. An object is Iterator if you can use next() to sequentially browse through its elements. For example, map() returns Iterator and list is Iterable.

Here are more details.

Below code illustrates how to check for these types:

from collections.abc import Iterable, Iterator



r = [1, 2, 3]

e = map(lambda x:x, r)



print(isinstance(r, Iterator)) # False, because can't apply next

print(isinstance(e, Iterator)) # True

print(isinstance(r, Iterable)) # True, because can apply iter()

print(isinstance(e, Iterable)) # True, note iter() returns self