判断python对象是否可调用的三种方式及其区别详解

查找资料，基本上判断python对象是否为可调用的函数，有三种方法

使用内置的callable函数

callable(func)

用于检查对象是否可调用，返回true也可能调用失败，但是返回false一定不可调用。

官方文档：

判断对象类型是否是functiontype

type(func) is functiontype
# 或者
isinstance(func, functiontype)

判断对象是否实现 __call__ 方法

hasattr(func, '__call__')

写个小demo，测试下这三种验证方式的区别

from types import functiontype
__author__ = 'blackmatrix'


class classa:

 @staticmethod
 def func_a():
  pass

 @classmethod
 def func_b(cls, arg):
  pass

 def func_c(self, arg):
  pass


def func_d():
 pass

if __name__ == '__main__':

 class_a = classa()

 print('静态方法，实例调用验证')
 print("callable(class_a.func_a) result: {result}".format(result=callable(class_a.func_a)))
 print("type(class_a.func_a) is functiontype result: {result}".format(result=type(class_a.func_a) is functiontype))
 print("hasattr(class_a.func_a, '__call__') result: {result}".format(result=hasattr(class_a.func_a, '__call__')))

 print('静态方法，类调用验证')
 print("callable(classa.func_a) result: {result}".format(result=callable(classa.func_a)))
 print("type(classa.func_a) is functiontype result: {result}".format(result=type(classa.func_a) is functiontype))
 print("hasattr(classa.func_a, '__call__') result: {result}".format(result=hasattr(classa.func_a, '__call__')))

 print('类方法验证')
 print("callable(classa.func_b) result: {result}".format(result=callable(classa.func_b)))
 print("type(classa.func_b) is functiontype result: {result}".format(result=type(classa.func_b) is functiontype))
 print("hasattr(classa.func_b, '__call__') result: {result}".format(result=hasattr(classa.func_b, '__call__')))

 print('实例方法验证')
 print("callable(class_a.func_c) result: {result}".format(result=callable(class_a.func_c)))
 print("type(class_a.func_c) is functiontype result: {result}".format(result=type(class_a.func_c) is functiontype))
 print("hasattr(class_a.func_c, '__call__') result: {result}".format(result=hasattr(class_a.func_c, '__call__')))

 print('函数验证')
 print("callable(func_d) result: {result}".format(result=callable(func_d)))
 print("type(func_d) is functiontype result: {result}".format(result=type(func_d) is functiontype))
 print("hasattr(func_d, '__call__') result: {result}".format(result=hasattr(func_d, '__call__')))

通过运行结果，发现三种方法的验证结果并不相同。

主要是type(func) is functiontype方法，在验证类方法和实例方法时，会返回false，

从调试的结果上看，实例方法，和类方法的类型都是<class 'method'>，不是functiontype，所以会返回false

静态方法，实例调用验证
callable(class_a.func_a) result: true
type(class_a.func_a) is functiontype result: true
hasattr(class_a.func_a, '__call__') result: true
静态方法，类调用验证
callable(classa.func_a) result: true
type(classa.func_a) is functiontype result: true
hasattr(classa.func_a, '__call__') result: true
类方法验证
callable(classa.func_b) result: true
type(classa.func_b) is functiontype result: false
hasattr(classa.func_b, '__call__') result: true
实例方法验证
callable(class_a.func_c) result: true
type(class_a.func_c) is functiontype result: false
hasattr(class_a.func_c, '__call__') result: true
函数验证
callable(func_d) result: true
type(func_d) is functiontype result: true
hasattr(func_d, '__call__') result: true

因为python中分为函数（function）和方法（method），函数是python中一个可调用对象（用户定义的可调用对象，及lambda表达式创建的函数，都是函数，其类型都是functiontype），方法是一种特殊的类函数。

官方文档中，对于method的定义：

methods are always bound to an instance of a user-defined class

类方法和类进行绑定，实例方法与实例进行绑定，所以两者的类型都是method。

而静态方法，本身即不和类绑定，也不和实例绑定，不符合上述定义，所以其类型应该是function。

其中还有需要注意的是，如果一个类实现了__call__方法，那么其实例也会成为一个可调用对象，其类型为创建这个实例的类，而不是函数或方法。

class theclass:

 def __call__(self, *args, **kwargs):
  return self

if __name__ == '__main__':
　　the_class = theclass()
　　# true
　　print('class_instance callable {callable} '.format(callable=callable(the_class)))

所以通过类型去判断python对象是否可调用，需要同时判断是函数（functiontype）还是方法（methodtype），或者类是否实现__call__方法。

如果只是单纯判断python对象是否可调用，用callable()方法会更稳妥。

以上这篇判断python对象是否可调用的三种方式及其区别详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。