Wie ermittle ich in Python, ob ein Objekt iterierbar ist?

1. Prüfung für __iter__ arbeitet in Sequenz-Typen, aber es würde fehlschlagen, z.B. strings in Python 2. Ich würde gerne wissen, die richtige Antwort zu haben, bis dann, hier ist eine Möglichkeit (das würde die Arbeit auf den Saiten, zu):

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

   Den iter eingebauten Kontrollen für die __iter__ Methode oder im Fall von strings, die __getitem__ Methode.

2. Anderen Allgemeinen pythonic Ansatz davon aus, dass ein iterierbar dann ordnungsgemäß fehl, wenn Sie nicht arbeiten auf dem gegebenen Objekt. Die Python-Glossar:

   Pythonic Programmierung Stil, der bestimmt Typ eines Objekts durch Prüfung der Methode oder Attribut Signatur statt durch eine explizite Beziehung zu einigen Typ-Objekt ("Wenn es aussieht wie ein Ente und quakt wie eine Entees muss ein Ente.") Durch die Betonung Schnittstellen eher als spezifische Arten, gut entwickelte code verbessert Ihre Flexibilität, indem der polymorphe substitution. Duck-typing vermeidet tests mit type() oder isinstance(). Statt, die es in der Regel beschäftigt der EAFP (Einfacher, um Vergebung zu Bitten als Recht), Art der Programmierung.

   ...

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

3. Den Sammlungen Modul stellt eine abstrakte Basis-Klassen, die es erlauben, zu Fragen, - Klassen oder-Instanzen, wenn Sie bieten bestimmte Funktionen, zum Beispiel:

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

   Allerdings bedeutet dies nicht, überprüfen Sie für Klassen, die sind iterierbar durch __getitem__.

InformationsquelleAutor der Antwort miku

Möchte ich Schuppen ein wenig mehr Licht auf das zusammenspiel von iter__iter__ und __getitem__ und was passiert hinter den kulissen. Bewaffnet mit diesem wissen, werden Sie in der Lage zu verstehen, warum die besten, die Sie tun können, ist

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

Werde ich eine Liste der Fakten, die erste und Folgen Sie dann mit einem schnellen Erinnerung daran, was passiert, wenn Sie verwenden einen for - Schleife in python, gefolgt von einer Diskussion zur Veranschaulichung der Fakten.

Fakten

1. Können Sie sich einen iterator von einem Objekt o durch den Aufruf iter(o) wenn mindestens eine der folgenden Bedingungen gilt:

   a) o hat eine __iter__ Methode liefert ein iterator-Objekt. Ein iterator ist ein Objekt ein __iter__ und ein __next__ (Python 2: next) - Methode.

   b) o hat eine __getitem__ Methode.

2. Überprüfung auf eine Instanz von Iterable oder Sequence oder überprüfung der für die
   Attribut __iter__ ist nicht genug.

3. Wenn ein Objekt o implementiert nur __getitem__aber nicht __iter__iter(o) konstruieren
   ein iterator, der versucht zu Holen die Elemente aus o integer index, starting at index 0. Der iterator wird fangen alle IndexError (aber keine anderen Fehler), der ausgelöst wird, und dann wirft StopIteration selbst.

4. In den meisten Allgemeinen Sinn, es gibt keinen Weg, um zu überprüfen, ob der iterator zurückgegeben iter ist vernünftiger, als es auszuprobieren.

5. Wenn ein Objekt o implementiert __iter__die iter Funktion stellen Sie sicher,
   dass das Objekt zurückgegeben __iter__ ist ein iterator. Es gibt keine Plausibilitätsprüfung
   wenn ein Objekt implementiert nur __getitem__.

6. __iter__ gewinnt. Wenn ein Objekt o implementiert sowohl __iter__ und __getitem__iter(o) rufen __iter__.

7. Wenn Sie möchten, um Ihre eigenen Objekte wiederholenden, immer umsetzen die __iter__ Methode.

for Schleifen

Um zu Folgen, benötigen Sie ein Verständnis von dem, was passiert, wenn Sie verwenden einen for - Schleife in Python. Fühlen Sie sich frei, zu überspringen und direkt zum nächsten Abschnitt, wenn Sie schon wissen.

Wenn Sie for item in o für einige wiederholenden Objekt o -, Python-Aufrufe iter(o) und erwartet, dass ein iterator-Objekt als Rückgabewert. Ein iterator ist ein Objekt, das implementiert eine __next__ (oder next in Python 2) - Methode und eine __iter__ Methode.

Durch Konvention, die __iter__ Methode einen iterator zurückgeben sollte, das Objekt selbst (d.h. return self). Python ruft dann next auf den iterator bis StopIteration ausgelöst. All dies geschieht implizit, aber das folgende Beispiel macht es sichtbar:

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

Iteration über eine 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

Diskussion und Illustrationen

Auf Punkt 1 und 2: immer ein iterator und unzuverlässig überprüft

Betrachten Sie die folgende Klasse:

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

Aufrufen iter mit einer Instanz von BasicIterable zurück einen iterator ohne Probleme, weil BasicIterable implementiert __getitem__.

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

Es ist jedoch wichtig zu beachten, dass b nicht die __iter__ Attribut und nicht als eine Instanz von Iterable oder Sequence:

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

Dies ist der Grund, warum Fließend Python von Luciano Ramalho empfiehlt Berufung iter - und Umgang mit dem Potenzial TypeError als der Genaueste Weg, um zu überprüfen, ob ein Objekt ist iterierbar. Zitiert direkt aus dem Buch:

Als Python 3.4 ist die Genaueste Weg, um zu überprüfen, ob ein Objekt x ist iterierbar ist zu nennen iter(x) und Griff ein TypeError Ausnahme, wenn es nicht ist. Dies ist genauer als die Verwendung isinstance(x, abc.Iterable) , weil iter(x) auch der Auffassung, das Vermächtnis __getitem__ Methode, während die Iterable ABC nicht.

Punkt 3: Iteration über Objekte, die nur zur __getitem__aber nicht __iter__

Iteration über eine Instanz von BasicIterable funktioniert wie erwartet: Python
Konstrukte, die einen iterator, der versucht zu Holen Elemente, die durch den index, beginnend bei null, bis eine IndexError ausgelöst. Die demo-Objekt __getitem__ Methode gibt einfach die item was geliefert wurde als argument für __getitem__(self, item) durch den iterator zurückgegeben 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

Beachten Sie, dass der iterator wirft StopIteration wenn es nicht zurück, das nächste Element und die IndexError die ausgelöst wird, für item == 3 intern. Dies ist der Grund, warum looping über eine BasicIterable mit einem for - Schleife funktioniert wie erwartet:

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

Hier ist ein weiteres Beispiel, um nach Hause zu fahren, das Konzept, wie der iterator zurückgegeben iter versucht, Zugriff auf Elemente über index. WrappedDict erbt nicht von dictwas bedeutet, dass Instanzen nicht ein __iter__ Methode.

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

Beachten Sie, dass Anrufe zu __getitem__ übertragen sind dict.__getitem__ für die die eckige Klammer notation ist einfach ein Kürzel.

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

Auf Punkt 4 und 5: iter Prüfungen für ein iterator, wenn er fordert __iter__:

Wenn iter(o) genannt wird, für ein Objekt oiter wird, stellen Sie sicher, dass der Rückgabewert von __iter__wenn die Methode vorhanden ist, ist ein iterator. Dies bedeutet, dass das zurückgegebene Objekt
umsetzen muss __next__ (oder next in Python 2) und __iter__. iter nicht durchführen jegliche Vernunft überprüft, für Objekte, die nur
bieten __getitem__, da es keine Möglichkeit hat zu überprüfen, ob die Elemente des Objekts zugänglich sind integer-index.

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

class FailGetitemIterable(object):
    def __getitem__(self, item):
        raise Exception

Beachten Sie, dass die Konstruktion eines iterator von FailIterIterable Instanzen nicht sofort, bei der Konstruktion einen iterator von FailGetItemIterable erfolgreich, aber es wird eine Ausnahme ausgelöst, die auf den ersten Aufruf __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

Auf Punkt 6: __iter__ gewinnt

Dieser ist einfach. Wenn ein Objekt implementiert __iter__ und __getitem__iter rufen __iter__. Betrachten Sie die folgende Klasse

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

    def __getitem__(self, item):
        return ['__getitem__', 'wins'][item]

und die Ausgabe beim Durchlaufen einer Instanz:

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

Auf Punkt 7: Ihre iterierbar Klassen implementieren sollte __iter__

Fragen Sie sich vielleicht, warum die meisten builtin-Sequenzen wie list Umsetzung einer __iter__ Methode, wenn __getitem__ ausreichen würde.

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

    def __getitem__(self, item):
        return self._list[item]

Nachdem alle, iteration über Instanzen der Klasse vor, die Delegierten Aufrufe __getitem__ zu list.__getitem__ (Verwendung von eckigen Klammern-notation), funktioniert Prima:

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

Den Gründen Ihrer benutzerdefinierten iterables umsetzen sollte __iter__ sind wie folgt:

1. Wenn Sie implementieren __iter__ Instanzen werden als iterables und isinstance(o, collections.Iterable) zurück True.
2. Wenn das Objekt zurückgegeben __iter__ ist nicht ein iterator iter wird sofort fehl und heben einen TypeError.
3. Der Besondere Umgang mit __getitem__ vorhanden, um die Abwärtskompatibilität zu Gründen. Zitieren wieder aus Fließend Python:

Deshalb ist jede Python-Sequenz ist iterierbar: Sie alle umzusetzen __getitem__ . In der Tat,
die standard-Sequenzen auch umzusetzen __iter__, und Ihnen sollte auch, denn die
die Besondere Behandlung von __getitem__ existiert aus Gründen der Abwärtskompatibilität und kann
Weg in die Zukunft (obwohl es ist nicht veraltet, da ich dies Schreibe).

InformationsquelleAutor der Antwort timgeb

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

Nicht ausführen, überprüft, um zu sehen, wenn Ihre Ente ist wirklich eine Ente um zu sehen, ob es durchsuchbar ist oder nicht, behandeln Sie, als ob es war und sich beschweren, wenn er es nicht war.

InformationsquelleAutor der Antwort badp

In Python <= 2.5, Sie kann und darf nicht - wiederholenden war eine "informelle" - Schnittstelle.

Aber seit Python 2.6 und 3.0 nutzen Sie das neue ABC (abstract base class) - Infrastruktur zusammen mit einigen builtin-ABC, die verfügbar sind in den Sammlungen Modul:

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)

Nun, ob dies wünschenswert ist oder tatsächlich funktioniert, ist nur eine Frage der Konventionen. Wie Sie sehen können, Sie kann registrieren Sie einen nicht-wiederholenden Objekt als Iterierbar - und es wirft eine exception zur Laufzeit. Daher isinstance erwirbt eine "neue" Bedeutung - es prüft nur für "erklärt" haben, geben Sie Kompatibilität, das ist ein guter Weg zu gehen, um in Python.

Auf der anderen Seite, wenn Ihr Objekt nicht erfüllt, die der Schnittstelle, die Sie brauchen, was werden Sie tun? Nehmen Sie das folgende Beispiel:

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

Wenn das Objekt nicht zufrieden sind, was Sie erwarten, werden Sie nur werfen eine TypeError, aber wenn die richtigen ABC registriert wurde, überprüfen Sie Ihre unuseful. Im Gegenteil, wenn die __iter__ Methode verfügbar ist Python erkennt automatisch Objekt der Klasse als Durchsuchbar.

So, wenn Sie nur erwarten, dass ein iterierbar, Durchlaufen Sie es und vergessen Sie es. Auf der anderen Seite, wenn Sie benötigen, um verschiedene Dinge tun, je nach Eingabe-Typ, finden Sie vielleicht die ABC-Infrastruktur ziemlich nützlich.

InformationsquelleAutor der Antwort Alan Franzoni

Könnten Sie versuchen, diese:

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

Wenn wir einen generator, durchläuft es (aber verwenden Sie niemals den generator, so dass es nicht nehmen Platz), es ist durchsuchbar. Scheint wie ein "duh" Art der Sache. Warum brauchen Sie, um festzustellen, ob eine variable ist durchsuchbar?

InformationsquelleAutor der Antwort Chris Lutz

Oft finde ich praktisch, in meine Skripte zu definieren, die eine iterable Funktion.
(Beinhaltet nun Alfe vorgeschlagenen Vereinfachung):

import collections

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

so können Sie testen, ob ein beliebiges Objekt ist durchsuchbar in der sehr lesbaren form

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

als würden Sie mit dercallable Funktion

EDIT: wenn du numpy installiert haben, können Sie einfach tun:numpy import iterable
das ist einfach etwas, wie

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

Wenn Sie nicht haben, numpy, können Sie einfach dieser code implementieren, oder die oben.

InformationsquelleAutor der Antwort fmonegaglia

Seit Python 3.5 können Sie die Eingabe Modul aus der standard-Bibliothek für Typ-bezogene Dinge:

from typing import Iterable

...

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

InformationsquelleAutor der Antwort Rotareti

Den isiterable func bei der folgende code gibt True wenn ein Objekt ist iterierbar. wenn es nicht durchsuchbar zurück False

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

Beispiel

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

InformationsquelleAutor der Antwort Nomad

Abgesehen von regelmäßigen versuchen, außer, Sie könnten helfen.

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

Hilfe geben würde, die alle die Methoden, die ausgeführt werden könnte, die auf diesem Objekt(es könnte ein beliebiges Objekt und kann nicht eine Liste wie pro Beispiel), die temp in diesem Fall.

Hinweis: Dies wäre etwas, das Sie manuell tun.

InformationsquelleAutor der Antwort prudhvi Indana