被接受的答案在当时被认为是正确的。因为它 结果是，没有callable()的替代品，这又回到了Python中 3.2:具体来说，callable()检查对象的tp_call字段 测试。在普通的Python中没有对等的。大多数建议的测试都是 大多数时候是正确的:

>>> class Spam(object):
...     def __call__(self):
...         return 'OK'
>>> can_o_spam = Spam()


>>> can_o_spam()
'OK'
>>> callable(can_o_spam)
True
>>> hasattr(can_o_spam, '__call__')
True
>>> import collections
>>> isinstance(can_o_spam, collections.Callable)
True

方法中删除__call__来解决这个问题 类。为了让事情更有趣，在实例中添加一个假__call__ !

>>> del Spam.__call__
>>> can_o_spam.__call__ = lambda *args: 'OK?'

注意这个真的是不可调用的:

>>> can_o_spam()
Traceback (most recent call last):
  ...
TypeError: 'Spam' object is not callable

Callable()返回正确的结果:

>>> callable(can_o_spam)
False

但是hasattr错了:

>>> hasattr(can_o_spam, '__call__')
True

Can_o_spam确实有这个属性;它只是在调用时不使用 实例。

更微妙的是，isinstance()也会出错:

>>> isinstance(can_o_spam, collections.Callable)
True

因为我们之前使用了这个检查，后来删除了方法abc。ABCMeta 缓存结果。可以说这是abc.ABCMeta中的一个bug。也就是说, 没有比这更准确的结果了 结果比使用callable()本身，因为typeobject->tp_call 槽方法不能以任何其他方式访问。

只需使用callable()

在Python3中，我提出了type (f) == type (lambda x:x)，如果f是一个函数，则输出True，如果不是则输出False。但我想我更喜欢isinstance (f, types.FunctionType)，它感觉不那么特别。我想写type (f) is function，但这行不通。

函数只是一个带有__call__方法的类，所以你可以这样做

hasattr(obj, '__call__')

例如:

>>> hasattr(x, '__call__')
True

>>> x = 2
>>> hasattr(x, '__call__')
False

这是“最好”的方法，但这取决于你为什么需要知道它是可调用的还是注释的，你可以把它放在try/execpt块中:

try:
    x()
except TypeError:
    print "was not callable"

如果try/except比doing if hasattr(x， '__call__'): x()更适合Python，这是有争议的。我会说hasattr更准确，因为你不会意外地捕捉到错误的TypeError，例如:

>>> def x():
...     raise TypeError
... 
>>> hasattr(x, '__call__')
True # Correct
>>> try:
...     x()
... except TypeError:
...     print "x was not callable"
... 
x was not callable # Wrong!

一个精确的功能检查器

Callable是一个很好的解决方案。然而，我想用与John Feminella相反的方式来对待这个问题。不要像这样对待它:

检查鸭子类型对象属性的正确方法是询问它们是否嘎嘎叫，而不是查看它们是否适合鸭子大小的容器。“直接比较”的方法会对许多函数给出错误的答案，比如内置函数。

我们会这样对待它:

判断一个东西是不是鸭子的正确方法不是看它会不会嘎嘎叫，而是通过几个过滤器来判断它是否真的是一只鸭子，而不是仅仅从表面上看它是否像一只鸭子。

我们将如何实现它

'types'模块有很多类来检测函数，最有用的是类型。FunctionType，但也有很多其他类型，比如方法类型、内置类型和lambda类型。我们还将考虑一个'functools '。作为函数的Partial对象。

检查它是否是函数的简单方法是对所有这些类型使用isinstance条件。以前，我想创建一个继承上述所有类的基类，但我无法做到这一点，因为Python不允许我们继承上面的一些类。

下面是一个表，说明什么类可以分类什么函数:

以上函数表由kinght-金编写

实现它的代码

现在，这段代码完成了我们上面描述的所有工作。

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)
>>> [True, True, True, False, True]

一个false是is_function(partial)，因为那是一个类，而不是一个函数，而这正是函数，而不是类。下面是一个预览，您可以从中试用代码。

结论

Callable (obj)是检查对象是否是函数的首选方法，如果您想通过鸭子类型检查绝对值。

我们的自定义is_function(obj)，如果你没有将任何可调用的类实例作为函数，而只是内置或lambda, def或partial定义的函数，那么可能经过一些编辑后，它是检查对象是否是函数的首选方法。

我想这就是全部内容了。祝你有愉快的一天!

结果

import types
import inspect
import functools
import typing


def judge(x):
    name = x.__name__ if hasattr(x, '__name__') else 'functools.partial'
    print(name)
    print('\ttype({})={}'.format(name, type(x)))
    print('\tcallable({})={}'.format(name, callable(x)))
    print('\thasattr({}, \'__call__\')={}'.format(name, hasattr(x, '__call__')))
    print()
    print('\tinspect.isfunction({})={}'.format(name, inspect.isfunction(x)))
    print('\tinspect.ismethod({})={}'.format(name, inspect.ismethod(x)))
    print('\tinspect.isgeneratorfunction({})={}'.format(name, inspect.isgeneratorfunction(x)))
    print('\tinspect.iscoroutinefunction({})={}'.format(name, inspect.iscoroutinefunction(x)))
    print('\tinspect.isasyncgenfunction({})={}'.format(name, inspect.isasyncgenfunction(x)))
    print()
    print('\tisinstance({}, typing.Callable)={}'.format(name, isinstance(x, typing.Callable)))
    print('\tisinstance({}, types.BuiltinFunctionType)={}'.format(name, isinstance(x, types.BuiltinFunctionType)))
    print('\tisinstance({}, types.BuiltinMethodType)={}'.format(name, isinstance(x, types.BuiltinMethodType)))
    print('\tisinstance({}, types.FunctionType)={}'.format(name, isinstance(x, types.FunctionType)))
    print('\tisinstance({}, types.MethodType)={}'.format(name, isinstance(x, types.MethodType)))
    print('\tisinstance({}, types.LambdaType)={}'.format(name, isinstance(x, types.LambdaType)))
    print('\tisinstance({}, functools.partial)={}'.format(name, isinstance(x, functools.partial)))


def func(a, b):
    pass


partial = functools.partial(func, a=1)

_lambda = lambda _: _


def generator():
    yield 1
    yield 2


async def async_func():
    pass


async def async_generator():
    yield 1


class A:
    def __call__(self, a, b):
        pass

    def meth(self, a, b):
        pass

    @classmethod
    def classmeth(cls, a, b):
        pass

    @staticmethod
    def staticmeth(a, b):
        pass


for func in [print,
             func,
             partial,
             _lambda,
             generator,
             async_func,
             async_generator,
             A,
             A.meth,
             A.classmeth,
             A.staticmeth]:
    judge(func)

Time

选择三种最常见的方法:

可调用的(x) hasattr (x, __call__) isinstance (x, typing.Callable)

import typing
from timeit import timeit


def x():
    pass


def f1():
    return callable(x)


def f2():
    return hasattr(x, '__call__')


def f3():
    return isinstance(x, typing.Callable)


print(timeit(f1, number=10000000))
print(timeit(f2, number=10000000))
print(timeit(f3, number=10000000))
# 0.8643081
# 1.3563508
# 12.193492500000001

如果你想检测所有语法上看起来像函数的东西:函数、方法、内置的fun/meth、lambda…但排除可调用对象(定义了__call__方法的对象)，然后尝试这个:

import types
isinstance(x, (types.FunctionType, types.BuiltinFunctionType, types.MethodType, types.BuiltinMethodType, types.UnboundMethodType))

我将其与inspect模块中的is*()检查代码进行了比较，上面的表达式要完整得多，特别是如果您的目标是过滤任何函数或检测对象的常规属性。