In Python how do I determine if an object is iterable

Question

Is there a method like isiterable  The only solution I have found so far is to call  hasattr myObj     iter       But I am not sure how fool-proof this is

User · Answer

pandas has a built-in function like that   from pandas util testing import isiterable

User · Answer

def is iterable x       try          0 in x     except TypeError          return False     else          return True   This will say yes to all manner of iterable objects  but it will say no to strings in Python 2   That s what I want for example when a recursive function could take a string or a container of strings   In that situation  asking forgiveness may lead to obfuscode  and it s better to ask permission first    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    Many other strategies here will say yes to strings  Use them if that s what you want   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       Note  is iterable   will say yes to strings of type bytes and bytearray    bytes objects in Python 3 are iterable True    is iterable b string      is iterable  string  encode  utf-8    There is no such type in Python 2  bytearray objects in Python 2 and 3 are iterable True    is iterable bytearray b abc      The O P  hasattr x     iter     approach will say yes to strings in Python 3 and no in Python 2  no matter whether    or b   or u     Thanks to  LuisMasuelli for noticing it will also let you down on a buggy   iter

User · Answer

Not really  correct  but can serve as quick check of most common types like strings  tuples  floats  etc      gt  gt  gt     iter    in dir  sds   True  gt  gt  gt     iter    in dir 56  False  gt  gt  gt     iter    in dir  5 6 9 8   True  gt  gt  gt     iter    in dir   jh   ff    True  gt  gt  gt     iter    in dir   jh    True  gt  gt  gt     iter    in dir 56 9865  False

User · Answer

In Python  lt   2 5  you can t and shouldn t - iterable was an  informal  interface   But since Python 2 6 and 3 0 you can leverage the new ABC  abstract base class  infrastructure along with some builtin ABCs which are available in the collections module   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    Now  whether this is desirable or actually works  is just a matter of conventions  As you can see  you can register a non-iterable object as Iterable - and it will raise an exception at runtime  Hence  isinstance acquires a  new  meaning - it just checks for  declared  type compatibility  which is a good way to go in Python   On the other hand  if your object does not satisfy the interface you need  what are you going to do  Take the following example   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   If the object doesn t satisfy what you expect  you just throw a TypeError  but if the proper ABC has been registered  your check is unuseful  On the contrary  if the   iter   method is available Python will automatically recognize object of that class as being Iterable   So  if you just expect an iterable  iterate over it and forget it  On the other hand  if you need to do different things depending on input type  you might find the ABC infrastructure pretty useful

User · Answer

Kinda late to the party but I asked myself this question and saw this then thought of an answer  I don t know if someone already posted this  But essentially  I ve noticed that all iterable types have   getitem     in their dict  This is how you would check if an object was an iterable without even trying   Pun intended   def is attr arg       return    getitem    in dir arg

User · Answer

The best solution I ve found so far   hasattr obj     contains      which basically checks if the object implements the in operator   Advantages  none of the other solutions has all three     it is an expression  works as a lambda  as opposed to the try   except variant  it is  should be  implemented by all iterables  including strings  as opposed to   iter    works on any Python    2 5   Notes     the Python philosophy of  ask for forgiveness  not permission  doesn t work well when e g  in a list you have both iterables and non-iterables and you need to treat each element differently according to it s type  treating iterables on try and non-iterables on except would work  but it would look butt-ugly and misleading  solutions to this problem which attempt to actually iterate over the object  e g   x for x in obj   to check if it s iterable may induce significant performance penalties for large iterables  especially if you just need the first few elements of the iterable  for example  and should be avoided

User · Answer

Checking for   iter   works on sequence types  but it would fail on e g  strings in Python 2  I would like to know the right answer too  until then  here is one possibility  which would work on strings  too    from   future   import print function  try      some object iterator   iter some object  except TypeError as te      print some object   is not iterable     The iter built-in checks for the   iter   method or in the case of strings the   getitem   method  Another general pythonic approach is to assume an iterable  then fail gracefully if it does not work on the given object  The Python glossary      Pythonic programming style that determines an object s type by inspection of its method or attribute signature rather than by explicit relationship to some type object   If it looks like a duck and quacks like a duck  it must be a duck    By emphasizing interfaces rather than specific types  well-designed code improves its flexibility by allowing polymorphic substitution  Duck-typing avoids tests using type   or isinstance    Instead  it typically employs the EAFP  Easier to Ask Forgiveness than Permission  style of programming            try          e for e in my object  except TypeError     print my object   is not iterable    The collections module provides some abstract base classes  which allow to ask classes or instances if they provide particular functionality  for example   from collections abc import Iterable  if isinstance e  Iterable         e is iterable   However  this does not check for classes that are iterable through   getitem

User · Answer

I d like to shed a little bit more light on the interplay of iter    iter   and   getitem   and what happens behind the curtains  Armed with that knowledge  you will be able to understand why the best you can do is try      iter maybe iterable      print  iteration will probably work   except TypeError      print  not iterable    I will list the facts first and then follow up with a quick reminder of what happens when you employ a for loop in python  followed by a discussion to illustrate the facts  Facts  You can get an iterator from any object o by calling iter o  if at least one of the following conditions holds true  a  o has an   iter   method which returns an iterator object  An iterator is any object with an   iter   and a   next    Python 2  next  method  b  o has a   getitem   method   Checking for an instance of Iterable or Sequence  or checking for the attribute   iter   is not enough   If an object o implements only   getitem    but not   iter    iter o  will construct an iterator that tries to fetch items from o by integer index  starting at index 0  The iterator will catch any IndexError  but no other errors  that is raised and then raises StopIteration itself   In the most general sense  there s no way to check whether the iterator returned by iter is sane other than to try it out   If an object o implements   iter    the iter function will make sure that the object returned by   iter   is an iterator  There is no sanity check if an object only implements   getitem       iter   wins  If an object o implements both   iter   and   getitem    iter o  will call   iter     If you want to make your own objects iterable  always implement the   iter   method    for loops In order to follow along  you need an understanding of what happens when you employ a for loop in Python  Feel free to skip right to the next section if you already know  When you use for item in o for some iterable object o  Python calls iter o  and expects an iterator object as the return value  An iterator is any object which implements a   next    or next in Python 2  method and an   iter   method  By convention  the   iter   method of an iterator should return the object itself  i e  return self   Python then calls next on the iterator until StopIteration is raised  All of this happens implicitly  but the following demonstration makes it visible  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 over a DemoIterable   gt  gt  gt  di   DemoIterable    gt  gt  gt  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  Discussion and illustrations On point 1 and 2  getting an iterator and unreliable checks Consider the following class  class BasicIterable object       def   getitem   self  item           if item    3              raise IndexError         return item  Calling iter with an instance of BasicIterable will return an iterator without any problems because BasicIterable implements   getitem     gt  gt  gt  b   BasicIterable    gt  gt  gt  iter b   lt iterator object at 0x7f1ab216e320 gt   However  it is important to note that b does not have the   iter   attribute and is not considered an instance of Iterable or Sequence   gt  gt  gt  from collections import Iterable  Sequence  gt  gt  gt  hasattr b     iter     False  gt  gt  gt  isinstance b  Iterable  False  gt  gt  gt  isinstance b  Sequence  False  This is why Fluent Python by Luciano Ramalho recommends calling iter and handling the potential TypeError as the most accurate way to check whether an object is iterable  Quoting directly from the book   As of Python 3 4  the most accurate way to check whether an object x is iterable is to call iter x  and handle a TypeError exception if it isn   t  This is more accurate than using isinstance x  abc Iterable    because iter x  also considers the legacy   getitem   method  while the Iterable ABC does not   On point 3  Iterating over objects which only provide   getitem    but not   iter   Iterating over an instance of BasicIterable works as expected  Python constructs an iterator that tries to fetch items by index  starting at zero  until an IndexError is raised  The demo object s   getitem   method simply returns the item which was supplied as the argument to   getitem   self  item  by the iterator returned by iter   gt  gt  gt  b   BasicIterable    gt  gt  gt  it   iter b   gt  gt  gt  next it  0  gt  gt  gt  next it  1  gt  gt  gt  next it  2  gt  gt  gt  next it  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  StopIteration  Note that the iterator raises StopIteration when it cannot return the next item and that the IndexError which is raised for item    3 is handled internally  This is why looping over a BasicIterable with a for loop works as expected   gt  gt  gt  for x in b          print x      0 1 2  Here s another example in order to drive home the concept of how the iterator returned by iter tries to access items by index  WrappedDict does not inherit from dict  which means instances won t have an   iter   method  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  Note that calls to   getitem   are delegated to dict   getitem   for which the square bracket notation is simply a shorthand   gt  gt  gt  w   WrappedDict  -1   not printed                         0   hi   1   StackOverflow   2                             4   not printed                           x    not printed     gt  gt  gt  for x in w          print x       hi StackOverflow    On point 4 and 5  iter checks for an iterator when it calls   iter    When iter o  is called for an object o  iter will make sure that the return value of   iter    if the method is present  is an iterator  This means that the returned object must implement   next    or next in Python 2  and   iter    iter cannot perform any sanity checks for objects which only provide   getitem    because it has no way to check whether the items of the object are accessible by integer index  class FailIterIterable object       def   iter   self           return object     not an iterator  class FailGetitemIterable object       def   getitem   self  item           raise Exception  Note that constructing an iterator from FailIterIterable instances fails immediately  while constructing an iterator from FailGetItemIterable succeeds  but will throw an Exception on the first call to   next     gt  gt  gt  fii   FailIterIterable    gt  gt  gt  iter fii  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt  TypeError  iter   returned non-iterator of type  object   gt  gt  gt   gt  gt  gt  fgi   FailGetitemIterable    gt  gt  gt  it   iter fgi   gt  gt  gt  next it  Traceback  most recent call last     File  quot  lt stdin gt  quot   line 1  in  lt module gt    File  quot  path iterdemo py quot   line 42  in   getitem       raise Exception Exception  On point 6    iter   wins This one is straightforward  If an object implements   iter   and   getitem    iter will call   iter    Consider the following class class IterWinsDemo object       def   iter   self           return iter     iter      wins         def   getitem   self  item           return     getitem      wins   item   and the output when looping over an instance   gt  gt  gt  iwd   IterWinsDemo    gt  gt  gt  for x in iwd          print x        iter   wins  On point 7  your iterable classes should implement   iter   You might ask yourself why most builtin sequences like list implement an   iter   method when   getitem   would be sufficient  class WrappedList object     note  no inheritance from list      def   init   self  lst           self  list   lst      def   getitem   self  item           return self  list item   After all  iteration over instances of the class above  which delegates calls to   getitem   to list   getitem    using the square bracket notation   will work fine   gt  gt  gt  wl   WrappedList   A    B    C     gt  gt  gt  for x in wl          print x       A B C  The reasons your custom iterables should implement   iter   are as follows   If you implement   iter    instances will be considered iterables  and isinstance o  collections abc Iterable  will return True  If the object returned by   iter   is not an iterator  iter will fail immediately and raise a TypeError  The special handling of   getitem   exists for backwards compatibility reasons  Quoting again from Fluent Python    That is why any Python sequence is iterable  they all implement   getitem     In fact  the standard sequences also implement   iter    and yours should too  because the special handling of   getitem   exists for backward compatibility reasons and may be gone in the future  although it is not deprecated as I write this

User · Answer

You could try this   def iterable a       try           x for x in a          return True     except TypeError          return False   If we can make a generator that iterates over it  but never use the generator so it doesn t take up space   it s iterable  Seems like a  duh  kind of thing  Why do you need to determine if a variable is iterable in the first place

User · Answer

I ve been studying this problem quite a bit lately  Based on that my conclusion is that nowadays this is the best approach   from collections abc import Iterable     drop   abc  with Python 2 7 or lower  def iterable obj       return isinstance obj  Iterable    The above has been recommended already earlier  but the general consensus has been that using iter   would be better   def iterable obj       try          iter obj      except Exception          return False     else          return True   We ve used iter   in our code as well for this purpose  but I ve lately started to get more and more annoyed by objects which only have   getitem   being considered iterable  There are valid reasons to have   getitem   in a non-iterable object and with them the above code doesn t work well  As a real life example we can use Faker  The above code reports it being iterable but actually trying to iterate it causes an AttributeError  tested with Faker 4 0 2     gt  gt  gt  from faker import Faker  gt  gt  gt  fake   Faker    gt  gt  gt  iter fake       No exception  must be iterable  lt iterator object at 0x7f1c71db58d0 gt   gt  gt  gt  list fake       Ooops Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   home     site-packages faker proxy py   line 59  in   getitem       return self  factory map locale replace  -         AttributeError   int  object has no attribute  replace    If we d use insinstance    we wouldn t accidentally consider Faker instances  or any other objects having only   getitem    to be iterable    gt  gt  gt  from collections abc import Iterable  gt  gt  gt  from faker import Faker  gt  gt  gt  isinstance Faker    Iterable  False   Earlier answers commented that using iter   is safer as the old way to implement iteration in Python was based on   getitem   and the isinstance   approach wouldn t detect that  This may have been true with old Python versions  but based on my pretty exhaustive testing isinstance   works great nowadays  The only case where isinstance   didn t work but iter   did was with UserDict when using Python 2  If that s relevant  it s possible to use isinstance item   Iterable  UserDict   to get that covered

User · Answer

try     treat object as iterable except TypeError  e     object is not actually iterable   Don t run checks to see if your duck really is a duck to see if it is iterable or not  treat it as if it was and complain if it wasn t

User · Answer

According to the Python 2 Glossary  iterables are     all sequence types  such as list  str  and tuple  and some non-sequence types like dict and file and objects of any classes you define with an   iter     or   getitem     method  Iterables can be used in a for loop and in many other places where a sequence is needed  zip    map          When an iterable object is passed as an argument to the built-in function iter    it returns an iterator for the object    Of course  given the general coding style for Python based on the fact that it s    Easier to ask for forgiveness than permission      the general expectation is to use  try      for i in object in question          do something except TypeError      do something for non iterable   But if you need to check it explicitly  you can test for an iterable by hasattr object in question     iter     or hasattr object in question     getitem      You need to check for both  because strs don t have an   iter   method  at least not in Python 2  in Python 3 they do  and because generator objects don t have a   getitem   method

User · Answer

It s always eluded me as to why python has callable obj  - gt  bool but not iterable obj  - gt  bool    surely it s easier to do hasattr obj    call     even if it is slower   Since just about every other answer recommends using try except TypeError  where testing for exceptions is generally considered bad practice among any language  here s an implementation of iterable obj  - gt  bool I ve grown more fond of and use often   For python 2 s sake  I ll use a lambda just for that extra performance boost     in python 3 it doesn t matter what you use for defining the function  def has roughly the same speed as lambda   iterable   lambda obj  hasattr obj    iter     or hasattr obj    getitem       Note that this function executes faster for objects with   iter   since it doesn t test for   getitem     Most iterable objects should rely on   iter   where special-case objects fall back to   getitem    though either is required for an object to be iterable   and since this is standard  it affects C objects as well

User · Answer

Since Python 3 5 you can use the typing module from the standard library for type related things   from typing import Iterable       if isinstance my item  Iterable       print True

User · Answer

This isn t sufficient  the object returned by   iter   must implement the iteration protocol  i e  next method   See the relevant section in the documentation   In Python  a good practice is to  try and see  instead of  checking

User · Answer

I found a nice solution here   isiterable   lambda obj  isinstance obj  basestring        or getattr obj     iter     False

User · Answer

Instead of checking for the   iter   attribute  you could check for the   len   attribute  which is implemented by every python builtin iterable  including strings   gt  gt  gt  hasattr 1   quot   len   quot   False  gt  gt  gt  hasattr 1 3   quot   len   quot   False  gt  gt  gt  hasattr  quot a quot    quot   len   quot   True  gt  gt  gt  hasattr  1 2 3    quot   len   quot   True  gt  gt  gt  hasattr  1 2    quot   len   quot   True  gt  gt  gt  hasattr   quot a quot  1    quot   len   quot   True  gt  gt  gt  hasattr   quot a quot   1    quot   len   quot   True  None-iterable objects would not implement this for obvious reasons  However  it does not catch user-defined iterables that do not implement it  nor do generator expressions  which iter can deal with  However  this can be done in a line  and adding a simple or expression checking for generators would fix this problem   Note that writing type my generator expression     generator would throw a NameError  Refer to this answer instead    You can use GeneratorType from types   gt  gt  gt  import types  gt  gt  gt  types GeneratorType  lt class  generator  gt   gt  gt  gt  gen    i for i in range 10    gt  gt  gt  isinstance gen  types GeneratorType  True  --- accepted answer by utdemir   This makes it useful for checking if you can call len on the object though

User · Answer

I often find convenient  inside my scripts  to define an iterable function   Now incorporates Alfe s suggested simplification    import collections  def iterable obj       return isinstance obj  collections Iterable     so you can test if any object is iterable in the very readable form  if iterable obj         act on iterable else        not iterable   as you would do with thecallable function  EDIT  if you have numpy installed  you can simply do  from numpy import iterable   which is simply something like  def iterable obj       try  iter obj      except  return False     return True   If you do not have numpy  you can simply implement this code  or the one above

User · Answer

The isiterable func at the following code returns True if object is iterable  if it s not iterable returns False  def isiterable object        return hasattr type object       iter       example  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

User · Answer

The easiest way  respecting the Python s duck typing  is to catch the error  Python knows perfectly what does it expect from an object to become an iterator    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      Notes    It is irrelevant the distinction whether the object is not iterable  or a buggy   iter   has been implemented  if the exception type is the same  anyway you will not be able to iterate the object  I think I understand your concern  How does callable exists as a check if I could also rely on duck typing to raise an AttributeError if   call   is not defined for my object  but that s not the case for iterable checking   I don t know the answer  but you can either implement the function I  and other users  gave  or just catch the exception in your code  your implementation in that part will be like the function I wrote - just ensure you isolate the iterator creation from the rest of the code so you can capture the exception and distinguish it from another TypeError

User · Answer

Duck typing  try      iterator   iter theElement  except TypeError        not iterable else        iterable    for obj in iterator        pass   Type checking  Use the Abstract Base Classes  They need at least Python 2 6 and work only for new-style classes   from collections abc import Iterable     import directly from collections for Python  lt  3 3  if isinstance theElement  Iterable         iterable else        not iterable   However  iter   is a bit more reliable as described by the documentation      Checking isinstance obj  Iterable  detects classes that are   registered as Iterable or that have an   iter     method  but   it does not detect classes that iterate with the   getitem       method  The only reliable way to determine whether an object   is iterable is to call iter obj

[python] In Python, how do I determine if an object is iterable?

Examples related to python

Examples related to iterable