考虑到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区分开来。

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

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__。

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

Hasattr（obj， '__contains__'）

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

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

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

注:

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

在我的脚本中，我经常发现定义一个可迭代函数很方便。 (现在合并了Alfe建议的简化):

import collections

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

因此，您可以测试任何对象是否具有非常可读的可迭代形式

if iterable(obj):
    # act on iterable
else:
    # not iterable

就像你对可调用函数所做的那样

编辑:如果你安装了numpy，你可以简单地做: 简单地说是什么

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

如果没有numpy，可以简单地实现这段代码或上面的代码。