def is_iterable(x):
    try:
        0 in x
    except TypeError:
        return False
    else:
        return True

这将对所有可迭代对象说“是”，但对Python 2中的字符串说“不”。(例如，当递归函数可以接受字符串或字符串容器时，这就是我想要的。在这种情况下，请求原谅可能会导致模糊代码，最好先征求允许。)

import numpy

class Yes:
    def __iter__(self):
        yield 1;
        yield 2;
        yield 3;

class No:
    pass

class Nope:
    def __iter__(self):
        return 'nonsense'

assert is_iterable(Yes())
assert is_iterable(range(3))
assert is_iterable((1,2,3))   # tuple
assert is_iterable([1,2,3])   # list
assert is_iterable({1,2,3})   # set
assert is_iterable({1:'one', 2:'two', 3:'three'})   # dictionary
assert is_iterable(numpy.array([1,2,3]))
assert is_iterable(bytearray("not really a string", 'utf-8'))

assert not is_iterable(No())
assert not is_iterable(Nope())
assert not is_iterable("string")
assert not is_iterable(42)
assert not is_iterable(True)
assert not is_iterable(None)

这里有许多其他策略会对字符串说“是”。如果你想的话就用吧。

import collections
import numpy

assert isinstance("string", collections.Iterable)
assert isinstance("string", collections.Sequence)
assert numpy.iterable("string")
assert iter("string")
assert hasattr("string", '__getitem__')

注意:is_iterable()会对bytes和bytearray类型的字符串说yes。

Python 3中的bytes对象是可迭代的True == is_iterable(b"string") == is_iterable("string".encode('utf-8')) Python 2和3中的bytearray对象是可迭代的True == is_iterable(bytearray(b"abc"))

O.P. hasattr(x， '__iter__')方法将对Python 3中的字符串说“是”，而在Python 2中对字符串说“否”(无论“或b”或u”)。感谢@LuisMasuelli注意到它也会让你在一个bug __iter__。

你可以检查__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非常有用。)

到目前为止，我找到的最佳解决方案是:

Hasattr（obj， '__contains__'）

它主要检查对象是否实现了in操作符。

优点(其他解决方案都不具备这三个优点):

它是一个表达式(工作为lambda，而不是try…变体除外) 它(应该)由所有可迭代对象实现，包括字符串(而不是__iter__) 适用于任何Python >= 2.5

注:

Python的“请求原谅，而不是允许”的哲学在例如，在一个列表中，你有可迭代对象和不可迭代对象，你需要根据它的类型区别对待每个元素(在try上处理可迭代对象，在except上处理不可迭代对象可以工作，但它看起来很丑，会误导人)时，就不会很好地工作了。 对于这个问题的解决方案，试图实际遍历对象(例如[x for x in obj])来检查它是否为可迭代对象，可能会导致对大型可迭代对象的显著性能损失(特别是如果你只需要可迭代对象的前几个元素，例如)，应该避免

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

hasattr (myobject, __trunc__’)

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

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

我最近一直在研究这个问题。基于此，我的结论是，现在这是最好的方法:

from collections.abc import Iterable   # drop `.abc` with Python 2.7 or lower

def iterable(obj):
    return isinstance(obj, Iterable)

上面的建议已经在前面，但普遍的共识是使用iter()会更好:

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

为了这个目的，我们在代码中也使用了iter()，但我最近开始越来越讨厌只有__getitem__被认为是可迭代的对象。在一个不可迭代对象中使用__getitem__是有正当理由的，因此上面的代码不能很好地工作。作为一个真实的例子，我们可以使用Faker。上面的代码报告它是可迭代的，但实际上试图迭代它会导致AttributeError(用Faker 4.0.2测试):

>>> from faker import Faker
>>> fake = Faker()
>>> iter(fake)    # No exception, must be iterable
<iterator object at 0x7f1c71db58d0>
>>> list(fake)    # Ooops
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/.../site-packages/faker/proxy.py", line 59, in __getitem__
    return self._factory_map[locale.replace('-', '_')]
AttributeError: 'int' object has no attribute 'replace'

如果我们使用insinstance()，我们不会意外地认为Faker实例(或任何其他只有__getitem__的对象)是可迭代的:

>>> from collections.abc import Iterable
>>> from faker import Faker
>>> isinstance(Faker(), Iterable)
False

之前的回答评论说，使用iter()更安全，因为在Python中实现迭代的旧方法是基于__getitem__的，isinstance()方法不会检测到这一点。对于旧的Python版本，这可能是真的，但根据我非常详尽的测试，isinstance()现在工作得很好。isinstance()不起作用而iter()起作用的唯一情况是在使用Python 2时使用UserDict。如果这是相关的，可以使用isinstance(item， (Iterable, UserDict))来覆盖。

在Python <= 2.5中，你不能也不应该——iterable是一个“非正式的”接口。

但是从Python 2.6和3.0开始，你可以利用新的ABC(抽象基类)基础设施以及一些内置的ABC，这些ABC在collections模块中可用:

from collections import Iterable

class MyObject(object):
    pass

mo = MyObject()
print isinstance(mo, Iterable)
Iterable.register(MyObject)
print isinstance(mo, Iterable)

print isinstance("abc", Iterable)

现在，这是否可取，或者是否有效，只是一个惯例的问题。正如你所看到的，你可以将一个不可迭代的对象注册为Iterable——它将在运行时引发一个异常。因此，isinstance获得了一个“新的”含义——它只是检查“声明的”类型兼容性，这在Python中是一个很好的方法。

另一方面，如果你的对象不能满足你所需要的接口，你会怎么做?举个例子:

from collections import Iterable
from traceback import print_exc

def check_and_raise(x):
    if not isinstance(x, Iterable):
        raise TypeError, "%s is not iterable" % x
    else:
        for i in x:
            print i

def just_iter(x):
    for i in x:
        print i


class NotIterable(object):
    pass

if __name__ == "__main__":
    try:
        check_and_raise(5)
    except:
        print_exc()
        print

    try:
        just_iter(5)
    except:
        print_exc()
        print

    try:
        Iterable.register(NotIterable)
        ni = NotIterable()
        check_and_raise(ni)
    except:
        print_exc()
        print

如果对象不满足您的期望，则抛出TypeError，但如果已经注册了正确的ABC，则检查将毫无用处。相反，如果__iter__方法可用，Python将自动识别该类的object为Iterable。

如果你只是期望一个可迭代对象，遍历它，然后忘记它。另一方面，如果您需要根据输入类型执行不同的操作，那么您可能会发现ABC基础结构非常有用。