有没有类似isiterable的方法？到目前为止，我发现的唯一解决方案是致电

hasattr(myObj, '__iter__')

但是我不确定这有多愚蠢。

#1楼

根据Python 2词汇表，可迭代项是

您可以使用__iter__()或__getitem__()方法定义的所有序列类型（例如list ， str和tuple ）以及一些非序列类型（例如dict和file以及任何类的对象__getitem__() 。 Iterables可用于for循环以及需要序列的许多其他地方（zip（），map（）等）。将可迭代对象作为参数传递给内置函数iter（）时，它将返回该对象的迭代器。

当然，考虑到Python的通用编码风格是基于“请求宽容比允许容易”这一事实，因此，人们普遍期望使用

try:for i in object_in_question:do_something
except TypeError:do_something_for_non_iterable

但是，如果需要显式检查它，则可以通过hasattr(object_in_question, "__iter__") or hasattr(object_in_question, "__getitem__")来测试是否可迭代。您需要检查两者，因为str没有__iter__方法（至少在Python 2中没有），并且generator对象没有__getitem__方法。

#2楼

我经常在脚本中发现方便的方法来定义iterable函数。（现在结合了Alfe建议的简化）：

import collectionsdef iterable(obj):return isinstance(obj, collections.Iterable):

因此，您可以以可读性强的形式测试任何对象是否可迭代

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

就像使用callable函数一样

编辑：如果您已安装numpy，则可以执行以下操作：从numpy import iterable ，这就像

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

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

#3楼

检查__iter__可以在序列类型上使用，但是在Python 2中的字符串上会失败。我也想知道正确的答案，在此之前，这是一种可能性（也适用于字符串）：
```
 try: some_object_iterator = iter(some_object) except TypeError as te: print some_object, 'is not iterable' 
```
内置的iter检查__iter__方法，如果是字符串，则检查__getitem__方法。
另一种通用的pythonic方法是假定一个可迭代的对象，如果它不适用于给定的对象，则将优雅地失败。 Python词汇表：
通过检查对象的方法或属性签名而不是通过与某种类型对象的显式关系来确定对象类型的Python编程风格（“如果它看起来像鸭子，并且像鸭子一样嘎嘎叫，那一定是鸭子。”）通过强调接口经过精心设计的代码（而不是特定类型）通过允许多态替换来提高其灵活性。鸭式输入避免使用type（）或isinstance（）进行测试。 取而代之的是，它通常采用EAFP（比授权更容易获得宽恕）风格的编程。

...
```
 try: _ = (e for e in my_object) except TypeError: print my_object, 'is not iterable' 
```
collections模块提供了一些抽象基类，这些基类允许询问类或实例是否提供特定功能，例如：
```
 from collections.abc import Iterable if isinstance(e, Iterable): # e is iterable 
```
但是，这不会检查可通过__getitem__进行迭代的类。

#4楼

这还不够： __iter__返回的对象必须实现迭代协议（即next方法）。请参阅文档中的相关部分。

在Python中，一个好的做法是“尝试一下”而不是“检查”。

#5楼

您可以尝试以下方法：

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

如果我们可以使生成器在其上进行迭代（但不要使用生成器以免占用空间），那么它是可迭代的。好像是“ duh”之类的东西。为什么首先需要确定变量是否可迭代？

#6楼

try:#treat object as iterable
except TypeError, e:#object is not actually iterable

不要运行检查以查看您的鸭子是否真的是鸭子，以查看它是否可迭代，请像对待鸭子一样对待它，否则请抱怨。

#7楼

鸭打字

try:iterator = iter(theElement)
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.3if isinstance(theElement, Iterable):# iterable
else:# not iterable

但是， iter()更加可靠，如文档所述：

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

#8楼

我在这里找到了一个不错的解决方案：

isiterable = lambda obj: isinstance(obj, basestring) \or getattr(obj, '__iter__', False)

#9楼

在Python <= 2.5中，您不能也不应-可迭代是一个“非正式”接口。

但是从Python 2.6和3.0开始，您可以利用新的ABC（抽象基类）基础结构以及一些内置的ABC（可在collections模块中使用）：

from collections import Iterableclass MyObject(object):passmo = 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_excdef check_and_raise(x):if not isinstance(x, Iterable):raise TypeError, "%s is not iterable" % xelse:for i in x:print idef just_iter(x):for i in x:print iclass NotIterable(object):passif __name__ == "__main__":try:check_and_raise(5)except:print_exc()printtry:just_iter(5)except:print_exc()printtry:Iterable.register(NotIterable)ni = NotIterable()check_and_raise(ni)except:print_exc()print

如果对象不满足您的期望，则只引发TypeError，但是如果已注册了正确的ABC，则您的检查无用。相反，如果__iter__方法可用，Python会自动将该类的对象识别为Iterable。

因此，如果您只是期望一个可迭代的对象，请对其进行迭代并忘记它。另一方面，如果您需要根据输入类型执行不同的操作，则可能会发现ABC基础结构非常有用。

#10楼

尊重Python的鸭子类型，最简单的方法是捕获错误（Python完全知道从对象变成迭代器的期望）：

class A(object):def __getitem__(self, item):return somethingclass B(object):def __iter__(self):# Return a compliant iterator. Just an examplereturn iter([])class C(object):def __iter__(self):# Return crapreturn 1class D(object): passdef iterable(obj):try:iter(obj)return Trueexcept:return Falseassert iterable(A())
assert iterable(B())
assert iterable(C())
assert not iterable(D())

注意事项 ：

如果异常类型相同，则对象是不可迭代的，还是实现了错误的__iter__ ，这无关紧要：无论如何，您将无法迭代该对象。
我想我理解您的担心：如果未为我的对象定义__call__那么是否还可以依赖于鸭子类型引发AttributeError的检查， callable如何存在，但可迭代检查不是这种情况？

我不知道答案，但是您可以实现我（和其他用户）提供的功能，也可以仅捕获代码中的异常（您在该部分中的实现将类似于我编写的功能-只要确保隔离从其余代码创建迭代器，以便您可以捕获异常并将其与另一个TypeError区分开。

#11楼

def is_iterable(x):try:0 in xexcept TypeError:return Falseelse:return True

这将对所有可迭代对象的方式都说“是”，但是对Python 2中的字符串会说“否” 。（例如，当递归函数可以使用字符串或字符串容器时，这就是我想要的。在这种情况下，请求宽恕可能会导致混淆代码，最好先请求权限。）

import numpyclass Yes:def __iter__(self):yield 1;yield 2;yield 3;class No:passclass 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 numpyassert isinstance("string", collections.Iterable)
assert isinstance("string", collections.Sequence)
assert numpy.iterable("string")
assert iter("string")
assert hasattr("string", '__getitem__')

注意：is_iterable（）将对类型为bytes和bytearray字符串说是。

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

OP hasattr(x, '__iter__')方法将在Python 3中对字符串说是，而在Python 2中则否（无论是''还是b''或u'' ）。感谢@LuisMasuelli的注意，它也会使您失望__iter__ 。

#12楼

我想进一步了解iter ， __iter__和__getitem__的相互作用以及幕后发生的事情。有了这些知识，您将能够理解为什么您能做到最好的是

try:iter(maybe_iterable)print('iteration will probably work')
except TypeError:print('not iterable')

我将首先列出事实，然后快速提醒您在python中使用for循环时会发生什么，然后再进行讨论以说明事实。

事实

如果至少满足以下条件之一，则可以通过调用iter(o)从任何对象o获取迭代器：

a） o具有返回迭代器对象的__iter__方法。迭代器是具有__iter__和__next__ （Python 2： next ）方法的任何对象。

b） o有一个__getitem__方法。
仅检查Iterable或Sequence的实例，或者仅检查__iter__属性是不够的。
如果对象o仅实现__getitem__ ，而不实现__iter__ ，则iter(o)将构造一个迭代器，该迭代器尝试从整数索引（从索引0开始）从o获取项目。该迭代器将捕获到以下任何IndexError （但无其他错误）：引发，然后引发StopIteration本身。
从最一般的意义上讲，除了尝试它之外，没有其他方法可以检查iter返回的迭代器是否健全。
如果对象o实现__iter__ ，则iter函数将确保__iter__返回的对象是迭代器。如果对象仅实现__getitem__则没有健全性检查。
__iter__获胜。如果对象o实现__iter__和__getitem__ __iter__ ， iter(o)将调用__iter__ 。
如果要使自己的对象可迭代，请始终从抽象基类 Iterable或其子类之一继承。您将必须实现__iter__方法，否则将像Sequence那样提供它。

`for`循环

为了继续学习，您需要了解在Python中使用for循环时会发生什么。如果您已经知道，请随时跳到下一部分。

当您将for item in o用于某些可迭代对象o ，Python会调用iter(o)并期望将迭代器对象作为返回值。迭代器是实现__next__ （或Python 2中的next ）方法和__iter__方法的任何对象。

按照约定，迭代器的__iter__方法应返回对象本身（即return self ）。然后，Python在迭代器上调用next ，直到引发StopIteration 。所有这些操作都是隐式发生的，但是下面的演示使其可见：

import randomclass DemoIterable(object):def __iter__(self):print('__iter__ called')return DemoIterator()class DemoIterator(object):def __iter__(self):return selfdef __next__(self):print('__next__ called')r = random.randint(1, 10)if r == 5:print('raising StopIteration')raise StopIterationreturn r

在DemoIterable迭代：

>>> di = DemoIterable()
>>> for x in di:
...     print(x)
...
__iter__ called
__next__ called
9
__next__ called
8
__next__ called
10
__next__ called
3
__next__ called
10
__next__ called
raising StopIteration

讨论与插图

在第1点和第2点：获取迭代器和不可靠的检查

考虑以下类别：

class BasicIterable(object):def __getitem__(self, item):if item == 3:raise IndexErrorreturn item

用BasicIterable实例调用iter会返回一个没有问题的迭代器，因为BasicIterable实现了__getitem__ 。

>>> b = BasicIterable()
>>> iter(b)
<iterator object at 0x7f1ab216e320>

但是，必须注意b不具有__iter__属性，并且不被视为Iterable或Sequence的实例：

>>> from collections import Iterable, Sequence
>>> hasattr(b, '__iter__')
False
>>> isinstance(b, Iterable)
False
>>> isinstance(b, Sequence)
False

这就是为什么Luciano Ramalho的Fluent Python建议调用iter并处理潜在的TypeError作为检查对象是否可迭代的最准确方法。直接从书中引用：

从Python 3.4开始，检查对象x是否可迭代的最准确方法是调用iter(x)并处理一个TypeError异常（如果不是）。这比使用isinstance(x, abc.Iterable)更准确，因为iter(x)还考虑了旧的__getitem__方法，而Iterable ABC则不考虑。

关于第3点：遍历仅提供__getitem__而不提供__iter__

对BasicIterable实例的迭代按预期方式工作：Python构造了一个迭代器，该迭代器尝试从索引开始（从零开始）获取项目，直到引发IndexError 。演示对象的__getitem__方法简单地返回item将其作为供给该参数__getitem__(self, item)通过返回的迭代器iter 。

>>> b = BasicIterable()
>>> it = iter(b)
>>> next(it)
0
>>> next(it)
1
>>> next(it)
2
>>> next(it)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
StopIteration

请注意，当迭代器无法返回下一个项目时，它将引发StopIteration ，并且为item == 3引发的IndexError是在内部处理的。这就是为什么使用for循环遍历BasicIterable可以按预期工作的原因：

>>> for x in b:
...     print(x)
...
0
1
2

这是另一个例子，目的是了解iter返回的迭代器如何尝试按索引访问项目的概念。 WrappedDict不继承自dict ，这意味着实例将没有__iter__方法。

class WrappedDict(object): # note: no inheritance from dict!def __init__(self, dic):self._dict = dicdef __getitem__(self, item):try:return self._dict[item] # delegate to dict.__getitem__except KeyError:raise IndexError

请注意，对__getitem__调用被委派给dict.__getitem__对于该对象，方括号表示法只是一种简写形式。

>>> w = WrappedDict({-1: 'not printed',
...                   0: 'hi', 1: 'StackOverflow', 2: '!',
...                   4: 'not printed',
...                   'x': 'not printed'})
>>> for x in w:
...     print(x)
...
hi
StackOverflow
!

关于第4点和第5点： iter在调用__iter__时检查迭代器 ：

当为对象o调用iter(o) ， iter将确保__iter__的返回值（如果存在）是一个迭代器。这意味着返回的对象必须实现__next__ （或Python 2中的next ）和__iter__ 。 iter无法对仅提供__getitem__对象执行任何健全性检查，因为它无法检查整数索引是否可以访问对象的项。

class FailIterIterable(object):def __iter__(self):return object() # not an iteratorclass FailGetitemIterable(object):def __getitem__(self, item):raise Exception

请注意，从构建一个迭代FailIterIterable情况下立即失败，而构建一个迭代器从FailGetItemIterable成功，但会扔在第一次调用一个异常__next__ 。

>>> fii = FailIterIterable()
>>> iter(fii)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: iter() returned non-iterator of type 'object'
>>>
>>> fgi = FailGetitemIterable()
>>> it = iter(fgi)
>>> next(it)
Traceback (most recent call last):File "<stdin>", line 1, in <module>File "/path/iterdemo.py", line 42, in __getitem__raise Exception
Exception

在第6点： __iter__获胜

这很简单。如果对象实现__iter__和__getitem__ ，则iter将调用__iter__ 。考虑以下课程

class IterWinsDemo(object):def __iter__(self):return iter(['__iter__', 'wins'])def __getitem__(self, item):return ['__getitem__', 'wins'][item]

以及遍历实例时的输出：

>>> iwd = IterWinsDemo()
>>> for x in iwd:
...     print(x)
...
__iter__
wins

关于第7点：您的可迭代类应实现__iter__

您可能会问自己，当__getitem__足够时，为什么大多数内置序列（如list实现了__iter__方法。

class WrappedList(object): # note: no inheritance from list!def __init__(self, lst):self._list = lstdef __getitem__(self, item):return self._list[item]

毕竟，在上面的类的实例上进行迭代，该实例将对__getitem__调用委派给list.__getitem__ （使用方括号表示法），将可以正常工作：

>>> wl = WrappedList(['A', 'B', 'C'])
>>> for x in wl:
...     print(x)
...
A
B
C

您的自定义可迭代项应实现__iter__的原因如下：

如果实现__iter__ ，则实例将被视为可迭代的，而isinstance(o, collections.abc.Iterable)将返回True 。
如果__iter__返回的对象不是迭代器，则iter将立即失败并引发TypeError 。
出于向后兼容的原因，存在__getitem__的特殊处理。再次引用Fluent Python：

这就是任何Python序列都是可迭代的原因：它们都实现了__getitem__ 。实际上，标准序列也实现了__iter__ ，您也应该这样做，因为对__getitem__的特殊处理是出于向后兼容的原因而存在的，并且在将来可能会消失（尽管在我撰写本文时并未弃用）。

#13楼

大熊猫具有如下内置功能：

from pandas.util.testing import isiterable

#14楼

到目前为止，我发现的最佳解决方案是：

hasattr(obj, '__contains__')

它基本上检查对象是否实现in运算符。

优点（其他解决方案都没有这三个优点）：

它是一个表达式（作为lambda ，而不是try ... except变体）
（应该）由所有可迭代对象（包括字符串 （与__iter__相对））实现
适用于任何Python> = 2.5

笔记：

例如，在列表中同时具有可迭代和不可迭代，并且您需要根据其类型对每个元素进行不同的处理（在try和non-上处理可迭代）时，Python的“请求宽恕，而不是允许”的哲学无法很好地工作。上的iterables 会起作用，但看起来很难看并且具有误导性）
尝试实际迭代对象（例如[x for obj中的x的x]）以检查其是否可迭代的此问题的解决方案，可能会导致大型可迭代对象受到明显的性能损失（特别是如果您只需要可迭代对象的前几个元素，则为示例），应避免

#15楼

如果对象是可迭代的，则以下代码中的isiterable函数将返回True 。如果不是可迭代的，则返回False

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

例

fruits = ("apple", "banana", "peach")
isiterable(fruits) # returns Truenum = 345
isiterable(num) # returns Falseisiterable(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

#16楼

除了常规尝试和除外，你可以运行帮助。

temp= [1,2,3,4]
help(temp)

help将提供可以在该对象上运行的所有方法（它可以是任何对象，并且可能不是示例中的列表），在这种情况下是临时的。

注意：这将是您手动执行的操作。

#17楼

从Python 3.5开始，您可以使用标准库中的类型输入模块来处理与类型相关的事情：

from typing import Iterable...if isinstance(my_item, Iterable):print(True)

#18楼

除了检查__iter__属性，您还可以检查__len__属性，该属性由每个内置的可迭代的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可以处理的生成器表达式。但是，这可以一行完成，为生成器添加简单检查or表达式检查可以解决此问题。（请注意，编写type(my_generator_expression) == generator会抛出NameError 。请参考此答案。）

您可以从以下类型使用GeneratorType：
 >>> import types >>> types.GeneratorType <class 'generator'> >>> gen = (i for i in range(10)) >>> isinstance(gen, types.GeneratorType) True 
--- utdemir接受的答案

（这对于检查是否可以在对象上调用len很有用。）

#19楼

关于python为什么有callable(obj) -> bool但没有iterable(obj) -> bool ...
当然，即使更慢，执行hasattr(obj,'__call__')也更容易。

由于几乎所有其他答案都建议使用try / except TypeError ，在所有语言中，通常将异常测试视为在任何语言中的不良做法，因此，这是iterable(obj) -> bool的实现，我越来越喜欢并经常使用：

为了python 2的缘故，我将使用lambda只是为了提高性能...
（在python 3中，定义函数的功能无关紧要， def与lambda速度大致相同）

iterable = lambda obj: hasattr(obj,'__iter__') or hasattr(obj,'__getitem__')

请注意，此函数对于使用__iter__对象执行更快，因为它不会测试__getitem__ 。

大多数可迭代对象都应依赖__iter__ ，其中特殊情况下的对象可__getitem__为__getitem__ ，但__getitem__对象可迭代则需要其中一个。
（由于这是标准的，因此也会影响C对象）

#20楼

并不是真正的“正确”，但可以用作最常见类型的快速检查，例如字符串，元组，浮点数等。

>>> '__iter__' in dir('sds')
True
>>> '__iter__' in dir(56)
False
>>> '__iter__' in dir([5,6,9,8])
True
>>> '__iter__' in dir({'jh':'ff'})
True
>>> '__iter__' in dir({'jh'})
True
>>> '__iter__' in dir(56.9865)
False

#21楼

Kinda参加聚会很晚，但我问了自己这个问题，然后看到这个，然后想到了答案。我不知道是否有人已经发布了这个。但从本质上讲，我注意到所有可迭代的类型在其dict中都具有“ getitem ”。这是您无需尝试即可检查对象是否可迭代的方式。（双关语意）

def is_attr(arg):return '__getitem__' in dir(arg)

在Python中，如何确定对象是否可迭代？相关推荐

python语言中一切皆对象_2 python 中一切皆对象
python 中一皆对象在 python 编程语言中所有的一切都是对象 , python 语言相对于 C++ 或 java 这样的语言 (静态语言), 面向对象这个思想更加的彻底. 2.1 函数和类 ...
获取Python中的所有对象属性？
本文翻译自:Get all object attributes in Python? Is there a way to get all attributes/methods/fields/etc. ...
python一切皆对象的理解_在 Python 中万物皆对象
在 Python 中一切都是对象,并且几乎一切都有属性和方法.所有的函数都有一个内置的 __doc__ 属性,它会返回在函数源代码中定义的 doc string:sys 模块是一个对象,它有一个叫作 ...
python list存储对象_《python解释器源码剖析》第4章--python中的list对象
4.0 序 python中的list对象,底层对应的则是PyListObject.如果你熟悉C++,那么会很容易和C++中的list联系起来.但实际上,这个C++中的list大相径庭,反而和STL中的 ...
python iterable对象_如何理解Python中的iterable对象
转载请注明出处:https://www.jianshu.com/u/5e6f798c903a [^*] 表示注脚,在文末可以查看对应连接,但简书不支持该语法. 首先,容器和 iterable 间没有必 ...
python函数赋值给对象_【Python核心编程笔记】一、Python中一切皆对象
Python中一切皆对象本章节首先对比静态语言以及动态语言,然后介绍 python 中最底层也是面向对象最重要的几个概念-object.type和class之间的关系,以此来引出在python如何做到 ...
python字符串代码对象_Python源码剖析 - Python中的字符串对象
1. 前言我们已经在 [Python中的整数对象] 章节中对定长对象进行了详细的讲解,接下来我们将介绍变长对象,而字符串类型,则是这类对象的典型代表. 这里必须先引入一个概念: Python 中的变 ...
Python中的null对象？
我如何在Python中引用null对象? #1楼在Python中,为了表示缺少值,可以对对象使用None值( types.NoneType.None ),对字符串使用"" (或l ...
python定义一个dog类类属性有名字毛色体重_全面了解python中的类,对象,方法,属性...
python中一切皆为对象,所谓对象:我自己就是一个对象,我玩的电脑就是对象,坐着的椅子就是对象,家里养的小狗也是一个对象...... 我们通过描述属性(特征)和行为来描述一个对象的.比如家里的小狗, ...
python nonetype_理解Python中的NoneType对象
编译:老齐在C.Java等类型的语言中,都有null,它常常被定义为与0等效.但是,在Python中并非如此.Python中用关键词None表征null对象,它并不是0,它是Python中的第一类对 ...

在Python中，如何确定对象是否可迭代？

#1楼

#2楼

#3楼

#4楼

#5楼

#6楼

#7楼

鸭打字