Duck typing

try:
    iterator = iter(the_element)
except TypeError:
    # not iterable
else:
    # iterable

# for obj in iterator:
#     pass

类型检查

使用抽象基类。它们至少需要Python 2.6，并且只适用于新样式的类。

from collections.abc import Iterable   # import directly from collections for Python < 3.3

if isinstance(the_element, Iterable):
    # iterable
else:
    # not iterable

然而，iter()更可靠一些，如文档所述:

检查isinstance(obj, Iterable)检测类 注册为Iterable或具有__iter__()方法，但是 它不会检测使用__getitem__()迭代的类 方法。唯一可靠的方法来确定一个对象是否 Is iterable调用iter(obj)。

如果object是可迭代的，下面代码中的isiterable函数将返回True。如果不是iterable则返回False

def isiterable(object_):
    return hasattr(type(object_), "__iter__")

例子

fruits = ("apple", "banana", "peach")
isiterable(fruits) # returns True

num = 345
isiterable(num) # returns False

isiterable(str) # returns False because str type is type class and it's not iterable.

hello = "hello dude !"
isiterable(hello) # returns True because as you know string objects are iterable

在我的代码中，我用来检查非可迭代对象:

hasattr (myobject, __trunc__’)

这非常快，也可以用来检查可迭代对象(使用not)。

我不是100%确定这个解决方案是否适用于所有对象，也许其他可以提供一些更多的背景。__trunc__方法与数值类型相关(所有可以舍入为整数的对象都需要它)。但是我没有发现任何包含__trunc__和__iter__或__getitem__的对象。

你可以试试这个:

def iterable(a):
    try:
        (x for x in a)
        return True
    except TypeError:
        return False

如果我们可以创建一个迭代它的生成器(但从不使用生成器，以免占用空间)，那么它就是可迭代的。听起来像是"废话"一类的事。为什么首先需要确定一个变量是否可迭代?

你可以检查__len__属性，而不是检查__iter__属性，它是由每个python内置可迭代对象实现的，包括字符串。

>>> hasattr(1, "__len__")
False
>>> hasattr(1.3, "__len__")
False
>>> hasattr("a", "__len__")
True
>>> hasattr([1,2,3], "__len__")
True
>>> hasattr({1,2}, "__len__")
True
>>> hasattr({"a":1}, "__len__")
True
>>> hasattr(("a", 1), "__len__")
True

由于显而易见的原因，不可迭代对象不会实现这一点。但是，它不会捕获没有实现它的用户定义迭代对象，也不会捕获生成器表达式，而iter可以处理生成器表达式。但是，这可以在一行中完成，并且为生成器添加一个简单的或表达式检查将解决这个问题。(注意，写入type(my_generator_expression) == generator会抛出NameError。请参考这个答案。)

你可以从类型中使用GeneratorType: >>>导入类型 > > >类型。GeneratorType <类“发电机”> >>> gen = (i for i in range(10)) >>> isinstance(gen, types.GeneratorType) 真正的 ——utdemir接受的回答

(这对于检查是否可以在对象上调用len非常有用。)

考虑到Python的duck类型，最简单的方法是捕捉错误(Python完全知道它期望从一个对象变成迭代器):

class A(object):
    def __getitem__(self, item):
        return something

class B(object):
    def __iter__(self):
        # Return a compliant iterator. Just an example
        return iter([])

class C(object):
    def __iter__(self):
        # Return crap
        return 1

class D(object): pass

def iterable(obj):
    try:
        iter(obj)
        return True
    except:
        return False

assert iterable(A())
assert iterable(B())
assert iterable(C())
assert not iterable(D())

注:

如果异常类型相同，则区分对象是否不可迭代或已经实现了有bug的__iter__是无关紧要的:无论如何，您将无法迭代对象。 我想我理解你的担忧:如果我也可以依赖鸭类型来引发AttributeError，如果__call__没有为我的对象定义，那么callable如何作为检查存在，但这不是可迭代检查的情况? 我不知道答案，但你可以实现我(和其他用户)给出的函数，或者只是在你的代码中捕获异常(你在那部分的实现将像我写的函数一样——只要确保你将迭代器的创建与其余代码隔离开来，这样你就可以捕获异常并将其与另一个TypeError区分开来。