Есть ли такой метод isiterable? Единственное решение, которое я нашел, это позвонить

hasattr(myObj, '__iter__')

Но я не уверен, насколько это глупо.

Я изучал эту проблему совсем недавно. Исходя из этого, я пришел к выводу, что в настоящее время это лучший подход:

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(), было UserDictпри использовании Python 2. Если это уместно, можно использовать это isinstance(item, (Iterable, UserDict))для покрытия.

1. Проверка __iter__работает на типах последовательностей, но не работает, например, в строках в Python 2 . Я также хотел бы знать правильный ответ, до тех пор, здесь есть одна возможность (которая также будет работать со строками):

   from __future__ import print_function
   
   try:
       some_object_iterator = iter(some_object)
   except TypeError as te:
       print(some_object, 'is not iterable')

   В iterвстроенные проверки для __iter__метода или в случае строк в __getitem__методе.

2. Другой общий питонический подход - предполагать итеративность, а затем изящно проваливаться, если она не работает с данным объектом. Глоссарий Python:

   Стиль программирования Pythonic, который определяет тип объекта путем проверки его метода или сигнатуры атрибута, а не путем явного отношения к какому-либо объекту типа («Если он выглядит как утка и крякает как утка , он должен быть уткой» .) Подчеркивая интерфейсы В отличие от конкретных типов, хорошо разработанный код повышает его гибкость, позволяя полиморфное замещение. Утиная типография избегает тестов с использованием type () или isinstance (). Вместо этого он обычно использует стиль программирования EAFP (Проще просить прощения, чем разрешения).

   ...

   try:
      _ = (e for e in my_object)
   except TypeError:
      print my_object, 'is not iterable'

3. collectionsМодуль обеспечивает некоторые абстрактные базовые классы, которые позволяют задавать классы или экземпляры , если они обеспечивают определенную функциональность, например:

   from collections.abc import Iterable
   
   if isinstance(e, Iterable):
       # e is iterable

   Однако, это не проверяет классы, через которые можно пройти итерацию __getitem__.

Утка печатать

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

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

Тем не менее, iter()это немного более надежно, как описано в документации :

Проверка isinstance(obj, Iterable)обнаруживает классы, которые зарегистрированы как Iterable или которые имеют __iter__()метод, но не обнаруживает классы, которые повторяются с __getitem__() методом. Единственный надежный способ определить, является ли объект итеративным, - это вызвать iter(obj).

Я хотел бы, чтобы пролить немного больше света на взаимодействие iter, __iter__а __getitem__и то , что происходит за кулисами. Вооружившись этими знаниями, вы сможете понять, почему лучшее, что вы можете сделать, это

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

Сначала я перечислю факты, а затем сделаю быстрое напоминание о том, что происходит, когда вы используете forцикл в python, после чего следует обсуждение, чтобы проиллюстрировать факты.

факты

1. Вы можете получить итератор из любого объекта o, вызвав его, iter(o)если выполняется хотя бы одно из следующих условий:
   
   а) oимеет __iter__метод, который возвращает объект итератора. Итератор - это любой объект с методом __iter__и __next__(Python 2 next:).
   
   б) oимеет __getitem__метод.

2. Проверка на наличие экземпляра Iterableили Sequence, или проверка на атрибут __iter__недостаточно.

3. Если объект oреализует только __getitem__, но не реализует __iter__, он iter(o)создаст итератор, который пытается извлечь элементы oпо целочисленному индексу, начиная с индекса 0. Итератор будет перехватывать любые IndexError(но не другие ошибки), которые возникают, а затем возникают StopIterationсами.

4. В самом общем смысле, нет никакого способа проверить, является ли итератор, возвращаемый пользователем iter, нормальным, кроме как попробовать его.

5. Если объект oреализуется __iter__, iterфункция гарантирует, что возвращаемый объект __iter__является итератором. Нет проверки работоспособности, если объект только реализует __getitem__.

6. __iter__выигрывает. Если объект oреализует оба __iter__и __getitem__, iter(o)вызовет __iter__.

7. Если вы хотите сделать свои собственные объекты повторяемыми, всегда реализуйте __iter__метод.

for петли

Чтобы следовать, вам нужно понять, что происходит, когда вы нанимаете for цикл в Python. Не стесняйтесь переходить к следующему разделу, если вы уже знаете.

Когда вы используете for item in oкакой-либо повторяемый объект o, Python вызывает iter(o)и ожидает объект итератора в качестве возвращаемого значения. Итератор - это любой объект, который реализует __next__(или nextв Python 2) метод и__iter__ метод.

По соглашению __iter__метод итератора должен возвращать сам объект (то есть return self). Затем Python вызывает nextитератор до тех пор, пока он не StopIterationбудет поднят. Все это происходит неявно, но следующая демонстрация делает это видимым:

import random

class DemoIterable(object):
    def __iter__(self):
        print('__iter__ called')
        return DemoIterator()

class DemoIterator(object):
    def __iter__(self):
        return self

    def __next__(self):
        print('__next__ called')
        r = random.randint(1, 10)
        if r == 5:
            print('raising StopIteration')
            raise StopIteration
        return 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 IndexError
        return item

Вызов iterс экземпляром BasicIterableвернет итератор без проблем, потому что 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

Вот почему Fluent Python от Luciano Ramalho рекомендует вызывать iterи обрабатывать потенциал TypeErrorкак наиболее точный способ проверить, является ли объект итеративным. Цитирую прямо из книги:

Начиная с Python 3.4, наиболее точный способ проверить, является ли объект xитеративным, - это вызвать iter(x)и обработать TypeErrorисключение, если это не так. Это более точно, чем использование isinstance(x, abc.Iterable), потому что iter(x)также учитывает устаревший __getitem__метод, а IterableABC - нет.

По пункту 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когда он не может вернуть следующий элемент, и что значение, для IndexErrorкоторого вызывается item == 3, обрабатывается внутренне. Вот почему зацикливание больше BasicIterableс forконтуром работ , как и ожидалось:

>>> 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 = dic

    def __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__ :

Когда iter(o)вызывается для объекта o, iterубедитесь, что возвращаемое значение __iter__, если метод присутствует, является итератором. Это означает, что возвращаемый объект должен реализовать __next__(или nextв Python 2) и __iter__. iterне может выполнять какие-либо проверки работоспособности для объектов, которые только предоставляют __getitem__, потому что он не может проверить, доступны ли элементы объекта по целочисленному индексу.

class FailIterIterable(object):
    def __iter__(self):
        return object() # not an iterator

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

Вы можете спросить себя, почему большинство встроенных последовательностей, например, listреализуют __iter__метод, когда __getitem__этого будет достаточно.

class WrappedList(object): # note: no inheritance from list!
    def __init__(self, lst):
        self._list = lst

    def __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__:

1. Если вы реализуете __iter__, экземпляры будут считаться многоразовыми и isinstance(o, collections.abc.Iterable)будут возвращаться True.
2. Если объект, возвращаемый __iter__не является итератором, iterнемедленно завершится ошибкой и вызовет a TypeError.
3. Специальная обработка __getitem__существует по причинам обратной совместимости. Цитирую снова из Fluent Python:

Вот почему любая последовательность Python является итеративной: все они реализуются __getitem__. На самом деле, стандартные последовательности также реализуются __iter__, и ваша также должна, потому что специальная обработка __getitem__существует по причинам обратной совместимости и может отсутствовать в будущем (хотя это не рекомендуется, поскольку я пишу это).

Этого недостаточно: возвращаемый объект __iter__должен реализовывать протокол итерации (т. Е. nextМетод). Смотрите соответствующий раздел в документации .

В Python хорошей практикой является «попробовать и посмотреть» вместо «проверки».

В Python <= 2.5 вы не можете и не должны - итерируемый был «неформальным» интерфейсом.

Но начиная с Python 2.6 и 3.0 вы можете использовать новую инфраструктуру ABC (абстрактный базовый класс) вместе с некоторыми встроенными ABC, которые доступны в модуле коллекций:

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 автоматически распознает объект этого класса как Iterable.

Так что, если вы просто ожидаете итерации, итерируйте и забудьте об этом. С другой стороны, если вам нужно делать разные вещи в зависимости от типа ввода, вы можете найти инфраструктуру ABC довольно полезной.

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

Не запускайте проверки, чтобы увидеть , действительно ли ваша утка является уткой, чтобы увидеть, является ли она итеративной или нет, относитесь к ней так, как будто она есть, и жалуйтесь, если это не так.

Начиная с Python 3.5 вы можете использовать модуль ввода из стандартной библиотеки для вещей, связанных с типами:

from typing import Iterable

...

if isinstance(my_item, Iterable):
    print(True)

Лучшее решение, которое я нашел до сих пор:

hasattr(obj, '__contains__')

который в основном проверяет, реализует ли объект inоператор.

Преимущества (ни одно из других решений не имеет всех трех):

• это выражение (работает как лямбда , в отличие от try ... кроме варианта)
• он (должен быть) реализован всеми итерациями, включая строки (в отличие от __iter__)
• работает на любом Python> = 2.5

Ноты:

• философия Python «просить прощения, а не разрешения» не работает, когда, например, в списке есть как итерируемые, так и неитерируемые, и вам нужно обрабатывать каждый элемент по-разному в соответствии с его типом (обработка итеративных элементов при попытке и не Итериблс, за исключением того, что это сработало бы , но это выглядело бы неприглядно и вводило в заблуждение)
• Решения этой проблемы, которые пытаются фактически выполнить итерацию по объекту (например, [x для x в obj]), чтобы проверить, является ли он итеративным, могут привести к значительным потерям производительности для больших итерируемых элементов (особенно, если вам просто нужны первые несколько элементов итерируемого, для пример) и его следует избегать

Вы можете попробовать это:

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

Если мы можем создать генератор, который выполняет итерации по нему (но никогда не использовать генератор, чтобы он не занимал место), он будет повторяемым. Похоже, что-то вроде "дух". Почему вы должны определить, является ли переменная итеративной?

Я нашел хорошее решение здесь :

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

Согласно Глоссарию Python 2 , итерации

все типы последовательностей (такие как list,, strи tuple) и некоторые непоследовательные типы, такие как dictи, fileи объекты любых классов, которые вы определяете с помощью метода __iter__()или __getitem__(). Итерации могут использоваться в цикле 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__"). Вы должны проверить оба, потому что у strs нет __iter__метода (по крайней мере, не в Python 2, в Python 3 они есть) и потому что у generatorобъектов нет __getitem__метода.

В моих сценариях я часто нахожу удобным определение iterableфункции. (Теперь включает в себя предложенное Alfe упрощение):

import collections

def 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 False
    return True

Если у вас нет numpy, вы можете просто реализовать этот код или тот, что приведен выше.

панд имеет такую ​​встроенную функцию:

from pandas.util.testing import isiterable

Мне всегда было трудно понять, почему Python имеет, callable(obj) -> boolно нет iterable(obj) -> bool...
конечно, это легче сделать, hasattr(obj,'__call__')даже если он медленнее.

Поскольку почти каждый ответ рекомендует использовать try/ except TypeError, где тестирование исключений обычно считается плохой практикой для любого языка, вот реализация, iterable(obj) -> boolкоторую я полюбил и часто использую:

Ради Python 2 я буду использовать лямбду только для дополнительного повышения производительности ...
(в Python 3 не имеет значения, что вы используете для определения функции, defскорость примерно такая же, как и у lambda)

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

Обратите внимание, что эта функция выполняется быстрее для объектов с, __iter__поскольку она не проверяется __getitem__.

Большинство итерируемых объектов должны полагаться на то, __iter__куда возвращаются объекты специального случая __getitem__, хотя любой из них необходим для того, чтобы объект был итеративным.
(и поскольку это стандарт, это также влияет на объекты C)

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

Это скажет да всем видам итерируемых объектов, но это скажет нет строкам в Python 2 . (Это то, что я хочу, например, когда рекурсивная функция может взять строку или контейнер строк. В этой ситуации, просьба о прощении может привести к obfuscode, и лучше сначала спросить разрешение.)

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 () скажет yes строкам типа bytesи bytearray.

• bytesобъекты в Python 3 являются итеративными. True == is_iterable(b"string") == is_iterable("string".encode('utf-8'))В Python 2 такого типа нет.
• bytearray объекты в Python 2 и 3 являются повторяемыми True == is_iterable(bytearray(b"abc"))

OP hasattr(x, '__iter__')подход не будет говорить да строки в Python 3 и не в Python 2 (независимо от того , является ли ''или b''или u''). Спасибо @LuisMasuelli за то, что заметили, что это также подведет вас к багги __iter__.

Самый простой способ, с учетом утилитарной типизации Python , - поймать ошибку (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())

Примечания :

1. Не имеет значения различие между тем, является ли объект итеративным, или __iter__была ли реализована ошибка, если тип исключения одинаков: в любом случае вы не сможете выполнить итерацию объекта.

2. Я думаю, что понимаю вашу озабоченность: как callableсуществует проверка, если я мог бы также полагаться на типизацию утки, чтобы поднять AttributeErrorif __call__, не определенную для моего объекта, но это не относится к повторяющейся проверке?

   Я не знаю ответа, но вы можете либо реализовать функцию, которую я (и другие пользователи) дали, или просто перехватить исключение в вашем коде (ваша реализация в этой части будет похожа на функцию, которую я написал - просто убедитесь, что вы изолируете создание итератора из остального кода, чтобы вы могли зафиксировать исключение и отличить его от другого TypeError.

Функция isiterableв следующем коде возвращает, Trueесли объект является итеративным. если это не повторяется, возвращает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

Вместо проверки __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

--- принял ответ утдемир

(Это делает его полезным для проверки возможности вызова lenобъекта.)

Не совсем «правильно», но может служить быстрой проверкой большинства распространенных типов, таких как строки, кортежи, числа с плавающей точкой и т. Д.

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

Вроде поздно на вечеринку, но я задал себе этот вопрос и увидел это, а затем подумал об ответе. Я не знаю, если кто-то уже опубликовал это. Но по сути, я заметил, что все повторяемые типы имеют __getitem __ () . Вот как вы можете проверить, является ли объект итеративным, даже не пытаясь. (Пун предназначен)

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