Determine the type of an object

Question

Is there a simple way to determine if a variable is a list  dictionary  or something else  I am getting an object back that may be either type and I need to be able to tell the difference

User · Answer

You can do that using type      gt  gt  gt  a       gt  gt  gt  type a   lt type  list  gt   gt  gt  gt  f       gt  gt  gt  type f   lt type  tuple  gt

User · Answer

You can use type   or isinstance      gt  gt  gt  type     is list True   Be warned that you can clobber list or any other type by assigning a variable in the current scope of the same name    gt  gt  gt  the d       gt  gt  gt  t   lambda x   aight  if type x  is dict else  NOPE   gt  gt  gt  t the d   aight   gt  gt  gt  dict    dude    gt  gt  gt  t the d   NOPE    Above we see that dict gets reassigned to a string  therefore the test   type     is dict      fails   To get around this and use type   more cautiously    gt  gt  gt  import   builtin    gt  gt  gt  the d       gt  gt  gt  type     is dict True  gt  gt  gt  dict      gt  gt  gt  type     is dict False  gt  gt  gt  type     is   builtin   dict True

User · Answer

There are two built-in functions that help you identify the type of an object  You can use type    if you need the exact type of an object  and isinstance   to check an object   s type against something  Usually  you want to use isinstance   most of the times since it is very robust and also supports type inheritance   To get the actual type of an object  you use the built-in type   function  Passing an object as the only parameter will return the type object of that object   gt  gt  gt  type     is list True  gt  gt  gt  type     is dict True  gt  gt  gt  type     is str True  gt  gt  gt  type 0  is int True  This of course also works for custom types   gt  gt  gt  class Test1  object           pass  gt  gt  gt  class Test2  Test1           pass  gt  gt  gt  a   Test1    gt  gt  gt  b   Test2    gt  gt  gt  type a  is Test1 True  gt  gt  gt  type b  is Test2 True  Note that type   will only return the immediate type of the object  but won   t be able to tell you about type inheritance   gt  gt  gt  type b  is Test1 False  To cover that  you should use the isinstance function  This of course also works for built-in types   gt  gt  gt  isinstance b  Test1  True  gt  gt  gt  isinstance b  Test2  True  gt  gt  gt  isinstance a  Test1  True  gt  gt  gt  isinstance a  Test2  False  gt  gt  gt  isinstance     list  True  gt  gt  gt  isinstance     dict  True  isinstance   is usually the preferred way to ensure the type of an object because it will also accept derived types  So unless you actually need the type object  for whatever reason   using isinstance   is preferred over type    The second parameter of isinstance   also accepts a tuple of types  so it   s possible to check for multiple types at once  isinstance will then return true  if the object is of any of those types   gt  gt  gt  isinstance      tuple  list  set   True

User · Answer

be careful using isinstance   isinstance True  bool  True  gt  gt  gt  isinstance True  int  True   but type  type True     bool True  gt  gt  gt  type True     int False

User · Answer

While the questions is pretty old  I stumbled across this while finding out a proper way myself  and I think it still needs clarifying  at least for Python 2 x  did not check on Python 3  but since the issue arises with classic classes which are gone on such version  it probably doesn t matter    Here I m trying to answer the title s question  how can I determine the type of an arbitrary object  Other suggestions about using or not using isinstance are fine in many comments and answers  but I m not addressing those concerns   The main issue with the type   approach is that it doesn t work properly with old-style instances   class One      pass  class Two      pass   o   One   t   Two    o type   type o  t type   type t   print  Are o and t instances of the same class    o type is t type   Executing this snippet would yield   Are o and t instances of the same class  True   Which  I argue  is not what most people would expect   The   class   approach is the most close to correctness  but it won t work in one crucial case  when the passed-in object is an old-style class  not an instance    since those objects lack such attribute   This is the smallest snippet of code I could think of that satisfies such legitimate question in a consistent fashion      usr bin env python from types import ClassType  we adopt the null object pattern in the  unlikely  case  that   class   is None for some strange reason  NO CLASS object   def get object type obj       obj type   getattr obj     class      NO CLASS      if obj type is not  NO CLASS          return obj type       AFAIK the only situation where this happens is an old-style class     obj type   type obj      if obj type is not ClassType          raise ValueError  Could not determine object      type   format obj type       return obj type

User · Answer

On instances of object you also have the     class     attribute  Here is a sample taken from Python 3 3 console   gt  gt  gt  str    str   gt  gt  gt  str   class    lt class  str  gt   gt  gt  gt  i   2  gt  gt  gt  i   class    lt class  int  gt   gt  gt  gt  class Test            pass      gt  gt  gt  a   Test    gt  gt  gt  a   class    lt class    main   Test  gt    Beware that in python 3 x and in New-Style classes  aviable optionally from Python 2 6  class and type have been merged and this can sometime lead to unexpected results  Mainly for this reason my favorite way of testing types classes is to the isinstance built in function

User · Answer

It might be more Pythonic to use a try   except block  That way  if you have a class which quacks like a list  or quacks like a dict  it will behave properly regardless of what its type really is   To clarify  the preferred method of  telling the difference  between variable types is with something called duck typing  as long as the methods  and return types  that a variable responds to are what your subroutine expects  treat it like what you expect it to be  For example  if you have a class that overloads the bracket operators with getattr and setattr  but uses some funny internal scheme  it would be appropriate for it to behave as a dictionary if that s what it s trying to emulate   The other problem with the type A  is type B  checking is that if A is a subclass of B  it evaluates to false when  programmatically  you would hope it would be true  If an object is a subclass of a list  it should work like a list  checking the type as presented in the other answer will prevent this   isinstance will work  however

User · Answer

In general you can extract a string from object with the class name   str class   object   class     name     and using it for comparison   if str class     dict         blablabla   elif str class     customclass         blebleble

User · Answer

For the sake of completeness  isinstance will not work for type checking of a subtype that is not an instance  While that makes perfect sense  none of the answers  including the accepted one  covers it  Use issubclass for that   gt  gt  gt  class a list         pass       gt  gt  gt  isinstance a  list  False  gt  gt  gt  issubclass a  list  True

User · Answer

type   is a better solution than isinstance    particularly for booleans   True and False are just keywords that mean 1 and 0 in python  Thus    isinstance True  int    and  isinstance False  int    both return True  Both booleans are an instance of an integer  type    however  is more clever   type True     int   returns False

User · Answer

As an aside to the previous answers  it s worth mentioning the existence of collections abc which contains several abstract base classes  ABCs  that complement duck-typing   For example  instead of explicitly checking if something is a list with    isinstance my obj  list    you could  if you re only interested in seeing if the object you have allows getting items  use collections abc Sequence   from collections abc import Sequence isinstance my obj  Sequence     if you re strictly interested in objects that allow getting  setting and deleting items  i e mutable sequences   you d opt for collections abc MutableSequence   Many other ABCs are defined there  Mapping for objects that can be used as maps  Iterable  Callable  et cetera  A full list of all these can be seen in the documentation for collections abc

User · Answer

In many practical cases instead of using type or isinstance you can also use  functools singledispatch  which is used to define generic functions  function composed of multiple functions implementing the same operation for different types    In other words  you would want to use it when you have a code like the following   def do something arg       if isinstance arg  int                 some code specific to processing integers     if isinstance arg  str                 some code specific to processing strings     if isinstance arg  list                 some code specific to processing lists            etc   Here is a small example of how it works   from functools import singledispatch    singledispatch def say type arg       raise NotImplementedError f I don t work with  type arg        say type register def   arg  int       print f  arg  is an integer      say type register def   arg  bool       print f  arg  is a boolean      gt  gt  gt  say type 0  0 is an integer  gt  gt  gt  say type False  False is a boolean  gt  gt  gt  say type dict      long error traceback ending with  NotImplementedError  I don t work with  lt class  dict  gt      Additionaly we can use abstract classes to cover several types at once   from collections abc import Sequence    say type register def   arg  Sequence       print f  arg  is a sequence       gt  gt  gt  say type  0  1  2    0  1  2  is a sequence   gt  gt  gt  say type  1  2  3    1  2  3  is a sequence

User · Answer

Determine the type of a Python object  Determine the type of an object with type   gt  gt  gt  obj   object    gt  gt  gt  type obj   lt class  object  gt    Although it works  avoid double underscore attributes like   class   - they re not semantically public  and  while perhaps not in this case  the builtin functions usually have better behavior    gt  gt  gt  obj   class     avoid this   lt class  object  gt    type checking     Is there a simple way to determine if a variable is a list  dictionary  or something else  I am getting an object back that may be either type and I need to be able to tell the difference    Well that s a different question  don t use type - use isinstance   def foo obj          given a string with items separated by spaces       or a list or tuple       do something sensible             if isinstance obj  str           obj   str split       return  foo handles only lists or tuples obj    This covers the case where your user might be doing something clever or sensible by subclassing str - according to the principle of Liskov Substitution  you want to be able to use subclass instances without breaking your code - and isinstance supports this    Use Abstractions  Even better  you might look for a specific Abstract Base Class from collections or numbers   from collections import Iterable from numbers import Number  def bar obj          does something sensible with an iterable of numbers       or just one number             if isinstance obj  Number     make it a 1-tuple         obj    obj       if not isinstance obj  Iterable           raise TypeError  obj must be either a number or iterable of numbers       return  bar sensible with iterable obj    Or Just Don t explicitly Type-check  Or  perhaps best of all  use duck-typing  and don t explicitly type-check your code  Duck-typing supports Liskov Substitution with more elegance and less verbosity    def baz obj          given an obj  a dict  or anything with an  items method       do something sensible with each key-value pair             for key  value in obj items             baz something sensible key  value    Conclusion   Use type to actually get an instance s class   Use isinstance to explicitly check for actual subclasses or registered abstractions   And just avoid type-checking where it makes sense

[python] Determine the type of an object?

Examples related to python

Examples related to dictionary

Examples related to types

Examples related to typeof