How do I detect whether a Python variable is a function

Question

I have a variable  x  and I want to know whether it is pointing to a function or not   I had hoped I could do something like    gt  gt  gt  isinstance x  function    But that gives me   Traceback  most recent call last     File   lt stdin gt    line 1  in   NameError  name  function  is not defined   The reason I picked that is because   gt  gt  gt  type x   lt type  function  gt

User · Answer

In Python3 I came up with type  f     type  lambda x x  which yields True if f is a function and False if it is not  But I think I prefer isinstance  f  types FunctionType   which feels less ad hoc  I wanted to do type  f  is function  but that doesn t work

User · Answer

callable x  will return true if the object passed can be called in Python  but the function does not exist in Python 3 0  and properly speaking will not distinguish between   class A object       def   call   self           return  Foo   def B        return  Bar   a   A   b   B  print type a   callable a  print type b   callable b    You ll get  lt class  A  gt  True and  lt type function gt  True as output   isinstance works perfectly well to determine if something is a function  try isinstance b  types FunctionType    if you re really interested in knowing if something can be called  you can either use hasattr b     call     or just try it   test as func   True try      b   except TypeError      test as func   False except      pass   This  of course  won t tell you whether it s callable but throws a TypeError when it executes  or isn t callable in the first place   That may not matter to you

User · Answer

Note that Python classes are also callable   To get functions  and by functions we mean standard functions and lambdas  use   import types  def is func obj       return isinstance obj   types FunctionType  types LambdaType     def f x       return x   assert is func f  assert is func lambda x  x

User · Answer

If the code will go on to perform the call if the value is callable  just perform the call and catch TypeError   def myfunc x     try      x     except TypeError      raise Exception  Not callable

User · Answer

The following is a  repr way  to check it  Also it works with lambda   def a   pass type a    lt class  function  gt  str type a      lt class  function  gt    True  b   lambda x x 2 str type b      lt class  function  gt    True

User · Answer

The solutions using hasattr obj     call     and callable    mentioned in some of the answers have a main drawback  both also return True for classes and instances of classes with a   call     method  Eg    gt  gt  gt  import collections  gt  gt  gt  Test   collections namedtuple  Test        gt  gt  gt  callable Test  True  gt  gt  gt  hasattr Test     call     True   One proper way of checking if an object is a user-defined function  and nothing but a that  is to use isfunction       gt  gt  gt  import inspect  gt  gt  gt  inspect isfunction Test  False  gt  gt  gt  def t    pass  gt  gt  gt  inspect isfunction t  True   If you need to check for other types  have a look at inspect     Inspect live objects

User · Answer

If you have learned C    you must be familiar with function object or functor  means any object that can be called as if it is a function  In C     an ordinary function is a function object  and so is a function pointer  more generally  so is an object of a class that defines operator    In C  11 and greater  the lambda expression is the functor too  Similarity  in Python  those functors are all callable  An ordinary function can be callable  a lambda expression can be callable  a functional partial can be callable  the instances of class with a   call     method can be callable   Ok  go back to question   I have a variable  x  and I want to know whether it is pointing to a function or not   If you want to judge weather the object acts like a function  then the callable method suggested by  John Feminella is ok  If you want to judge whether a object is just an ordinary function or not  not a callable class instance  or a lambda expression   then the xtypes XXX suggested by  Ryan is a better choice   Then I do an experiment using those code     usr bin python3   2017 12 10 14 25 01 CST   2017 12 10 15 54 19 CST  import functools import types import pprint   Define a class and an ordinary function   class A        def   call   self  a b           print a b      def func1 self  a  b           print  quot  classfunction   quot   a  b       classmethod     def func2 cls  a b           print  quot  classmethod   quot   a  b       staticmethod     def func3 a b           print  quot  staticmethod   quot   a  b   def func a b       print  quot  function  quot   a b    Define the functors     1 1  built-in function builtins func   open   1 2  ordinary function ordinary func   func   1 3  lambda expression lambda func    lambda a   func a 4    1 4  functools partial partial func   functools partial func  b 4     2 1  callable class instance class callable instance   A     2 2  ordinary class function class ordinary func   A func1   2 3  bound class method class bound method   A func2   2 4  static class method class static func   A func3   Define the functors  list and the types  list      list of functors xfuncs    builtins func  ordinary func  lambda func  partial func  class callable instance  class ordinary func  class bound method  class static func     list of type xtypes    types BuiltinFunctionType  types FunctionType  types MethodType  types LambdaType  functools partial    Judge wether the functor is callable  As you can see  they all are callable   res    callable xfunc   for xfunc in xfuncs  print  quot functors callable  quot   print res    quot  quot  quot  functors callable   True  True  True  True  True  True  True  True   quot  quot  quot    Judge the functor s type  types XXX   Then the types of functors are not all the same   res     isinstance xfunc  xtype  for xtype in xtypes  for xfunc in xfuncs      output the result print  quot functors  types quot   for  row  xfunc  in zip res  xfuncs       print row  xfunc    quot  quot  quot  functors  types  True  False  False  False  False   lt built-in function open gt   False  True  False  True  False   lt function func at 0x7f1b5203e048 gt   False  True  False  True  False   lt function  lt lambda gt  at 0x7f1b5081fd08 gt   False  False  False  False  True  functools partial  lt function func at 0x7f1b5203e048 gt   b 4   False  False  False  False  False   lt   main   A object at 0x7f1b50870cc0 gt   False  True  False  True  False   lt function A func1 at 0x7f1b5081fb70 gt   False  False  True  False  False   lt bound method A func2 of  lt class    main   A  gt  gt   False  True  False  True  False   lt function A func3 at 0x7f1b5081fc80 gt   quot  quot  quot    I draw a table of callable functor s types using the data    Then you can choose the functors  types that suitable   such as  def func a b       print  quot  function  quot   a b    gt  gt  gt  callable func  True  gt  gt  gt  isinstance func   types FunctionType  True  gt  gt  gt  isinstance func   types BuiltinFunctionType  types FunctionType  functools partial   True  gt  gt  gt    gt  gt  gt  isinstance func   types MethodType  functools partial   False

User · Answer

A function is just a class with a   call   method  so you can do  hasattr obj     call       For example    gt  gt  gt  hasattr x     call     True   gt  gt  gt  x   2  gt  gt  gt  hasattr x     call     False   That is the  best  way of doing it  but depending on why you need to know if it s callable or note  you could just put it in a try execpt block   try      x   except TypeError      print  was not callable    It s arguable if try except is more Python y than doing if hasattr x     call      x     I would say hasattr is more accurate  since you wont accidently catch the wrong TypeError  for example    gt  gt  gt  def x            raise TypeError       gt  gt  gt  hasattr x     call     True   Correct  gt  gt  gt  try          x       except TypeError          print  x was not callable       x was not callable   Wrong

User · Answer

Builtin types that don t have constructors in the built-in namespace  e g  functions  generators  methods  are in the types module  You can use types FunctionType in an isinstance call   gt  gt  gt  import types  gt  gt  gt  types FunctionType  lt class  function  gt    gt  gt  gt  def f    pass   gt  gt  gt  isinstance f  types FunctionType  True  gt  gt  gt  isinstance lambda x   None  types FunctionType  True  Note that this uses a very specific notion of  quot function quot  that is usually not what you need  For example  it rejects zip  technically a class    gt  gt  gt  type zip   isinstance zip  types FunctionType    lt class  type  gt   False   open  built-in functions have a different type    gt  gt  gt  type open   isinstance open  types FunctionType    lt class  builtin function or method  gt   False   and random shuffle  technically a method of a hidden random Random instance    gt  gt  gt  type random shuffle   isinstance random shuffle  types FunctionType    lt class  method  gt   False   If you re doing something specific to types FunctionType instances  like decompiling their bytecode or inspecting closure variables  use types FunctionType  but if you just need an object to be callable like a function  use callable

User · Answer

If you want to detect everything that syntactically looks like a function  a function  method  built-in fun meth  lambda     but exclude callable objects  objects with   call   method defined   then try this one   import types isinstance x   types FunctionType  types BuiltinFunctionType  types MethodType  types BuiltinMethodType  types UnboundMethodType     I compared this with the code of is    checks in inspect module and the expression above is much more complete  especially if your goal is filtering out any functions or detecting regular properties of an object

User · Answer

Since Python 2 1 you can import isfunction from the inspect module    gt  gt  gt  from inspect import isfunction  gt  gt  gt  def f    pass  gt  gt  gt  isfunction f  True  gt  gt  gt  isfunction lambda x  x  True

User · Answer

Instead of checking for    call     which is not exclusive to functions   you can check whether a user-defined function has attributes func name  func doc  etc  This does not work for methods     gt  gt  gt  def x    pass       gt  gt  gt  hasattr x   func name   True   Another way of checking is using the isfunction   method from the inspect module    gt  gt  gt  import inspect  gt  gt  gt  inspect isfunction x  True   To check if an object is a method  use inspect ismethod

User · Answer

Since classes also have   call   method  I recommend another solution   class A object       def   init   self           pass     def   call   self           print  I am a Class   MyClass   A    def foo        pass  print hasattr foo   class     func name     Returns True print hasattr A   class     func name       Returns False as expected  print hasattr foo     call       Returns True print hasattr A     call             Returns True while it is not a function

User · Answer

Python s 2to3 tool  http   docs python org dev library 2to3 html  suggests   import collections isinstance obj  collections Callable    It seems this was chosen instead of the hasattr x     call     method because of http   bugs python org issue7006

User · Answer

The following should return a boolean   callable x

User · Answer

An Exact Function Checker callable is a very good solution  However  I wanted to treat this the opposite way  of John Feminella  Instead of treating it like this saying   The proper way to check properties of duck-typed objects is to ask them if they quack  not to see if they fit in a duck-sized container  The  quot compare it directly quot  approach will give the wrong answer for many functions  like builtins   We ll treat it like this   The proper way to check if something is a duck is not to see if it can quack  but rather to see if it truly is a duck through several filters  instead of just checking if it seems like a duck from the surface   How Would We Implement It The  types  module has plenty of classes to detect functions  the most useful being types FunctionType  but there are also plenty of others  like a method type  a built in type  and a lambda type  We also will consider a  functools partial  object as being a function  The simple way we check if it is a function is by using an isinstance condition on all of these types  Previously  I wanted to make a base class which inherits from all of the above  but I am unable to do that  as Python does not allow us to inherit from some of the above classes  Here s a table of what classes can classify what functions   Above function table by kinght-  The Code Which Does It Now  this is the code which does all of the work we described from above  from types import BuiltinFunctionType  BuiltinMethodType   FunctionType  MethodType  LambdaType from functools import partial  def is function obj     return isinstance obj   BuiltinFunctionType  BuiltinMethodType   FunctionType  MethodType  LambdaType  partial     -------------------------------------------------  def my func      pass  def add both x  y     return x   y  class a    def b self       pass  check      is function lambda x  x   x   is function my func   is function a b   is function partial   is function partial add both  2       print check   gt  gt  gt   True  True  True  False  True   The one false was is function partial   because that s a class  not a function  and this is exactly functions  not classes  Here is a preview for you to try out the code from  Conclusion callable obj  is the preferred method to check if an object is a function if you want to go by duck-typing over absolutes  Our custom is function obj   maybe with some edits is the preferred method to check if an object is a function if you don t any count callable class instance as a function  but only functions defined built-in  or with lambda  def  or partial  And I think that wraps it all up  Have a good day

User · Answer

As the accepted answer  John Feminella stated that      The proper way to check properties of duck-typed objects is to ask them if they quack  not to see if they fit in a duck-sized container  The  compare it directly  approach will give the wrong answer for many functions  like builtins    Even though   there re two libs to distinguish functions strictly  I draw an exhaustive comparable table   8 9  types     Dynamic type creation and names for built-in types     Python 3 7 0 documentation  30 13  inspect     Inspect live objects     Python 3 7 0 documentation   import inspect              import types   isabstract     isasyncgen                 AsyncGeneratorType     isasyncgenfunction      isawaitable     isbuiltin                  BuiltinFunctionType                                BuiltinMethodType     isclass     iscode                     CodeType     iscoroutine                CoroutineType     iscoroutinefunction     isdatadescriptor     isframe                    FrameType     isfunction                 FunctionType                                LambdaType                                MethodType     isgenerator                GeneratorType     isgeneratorfunction     ismethod     ismethoddescriptor     ismodule                   ModuleType             isroutine                 istraceback                TracebackType                               MappingProxyType       The  duck typing  is a preferred solution for general purpose   def detect function obj       return hasattr obj    call      In  26   detect function detect function  Out 26   True In  27   callable detect function  Out 27   True   As for the builtins function  In  43   callable hasattr  Out 43   True   When go one more step to check if builtin function or user-defined funtion   check inspect isfunction and type FunctionType In  46   inspect isfunction detect function  Out 46   True In  47   inspect isfunction hasattr  Out 47   False In  48   isinstance detect function  types FunctionType  Out 48   True In  49   isinstance getattr  types FunctionType  Out 49   False  so they both just applied to judge the user-definded   Determine if builtin function  In  50   isinstance getattr  types BuiltinFunctionType  Out 50   True In  51   isinstance detect function  types BuiltinFunctionType  Out 51   False   Summary  Employ callable to duck type checking a function  Use types BuiltinFunctionType if you have further specified demand

User · Answer

You could try this   if obj   class     name   in   function    builtin function or method        print  probably a function     or even something more bizarre   if  function  in lower obj   class     name         print  probably a function

User · Answer

Try using callable x

User · Answer

This works for me   str type a      lt class  function  gt

User · Answer

If this is for Python 2 x or for Python 3 2   you can also use callable    It used to be deprecated  but is now undeprecated  so you can use it again  You can read the discussion here  http   bugs python org issue10518  You can do this with   callable obj    If this is for Python 3 x but before 3 2  check if the object has a   call   attribute  You can do this with   hasattr obj     call       The oft-suggested types FunctionTypes approach is not correct because it fails to cover many cases that you would presumably want it to pass  like with builtins    gt  gt  gt  isinstance open  types FunctionType  False   gt  gt  gt  callable open  True   The proper way to check properties of duck-typed objects is to ask them if they quack  not to see if they fit in a duck-sized container  Don t use types FunctionType unless you have a very specific idea of what a function is

User · Answer

Here s a couple of other ways   def isFunction1 f        return type f     type lambda x  x    def isFunction2 f        return  function  in str type f      Here s how I came up with the second    gt  gt  gt  type lambda x  x    lt type  function  gt   gt  gt  gt  str type lambda x  x      lt type  function  gt     Look Maa  function      I ACTUALLY told my mom about this

User · Answer

Whatever function is a class so you can take the name of the class of instance x and compare    if x   class     name       function         print  it s a function

User · Answer

Following previous replies  I came up with this   from pprint import pprint  def print callables of obj       li          for name in dir obj           attr   getattr obj  name          if hasattr attr     call                  li append name      pprint li

User · Answer

The accepted answer was at the time it was offered thought to be correct  As it turns out  there is no substitute for callable    which is back in Python 3 2  Specifically  callable   checks the tp call field of the object being tested  There is no plain Python equivalent   Most of the suggested tests are correct most of the time    gt  gt  gt  class Spam object           def   call   self               return  OK   gt  gt  gt  can o spam   Spam      gt  gt  gt  can o spam    OK   gt  gt  gt  callable can o spam  True  gt  gt  gt  hasattr can o spam     call     True  gt  gt  gt  import collections  gt  gt  gt  isinstance can o spam  collections Callable  True   We can throw a monkey-wrench into this by removing the   call   from the class  And just to keep things extra exciting  add a fake   call   to the instance    gt  gt  gt  del Spam   call    gt  gt  gt  can o spam   call     lambda  args   OK     Notice this really isn t callable    gt  gt  gt  can o spam   Traceback  most recent call last         TypeError   Spam  object is not callable   callable   returns the correct result    gt  gt  gt  callable can o spam  False   But hasattr is wrong    gt  gt  gt  hasattr can o spam     call     True   can o spam does have that attribute after all  it s just not used when calling the instance   Even more subtle  isinstance   also gets this wrong    gt  gt  gt  isinstance can o spam  collections Callable  True   Because we used this check earlier and later deleted the method  abc ABCMeta caches the result  Arguably this is a bug in abc ABCMeta  That said  there s really no possible way it could produce a more accurate result than the result than by using callable   itself  since the typeobject- gt tp call slot method is not accessible in any other way   Just use callable

[python] How do I detect whether a Python variable is a function?

Examples related to python