下面的函数应该返回一个布尔值:

callable(x)

尝试使用callable(x)。

摘录:

如果对象参数显示为可调用，则返回True，否则返回False。

如果这是针对Python 2。对于Python 3.2+，可以使用callable()。它曾经被弃用，但现在不弃用了，所以您可以再次使用它。你可以在这里阅读讨论:http://bugs.python.org/issue10518。你可以这样做:

callable(obj)

如果这是针对Python 3。X但在3.2之前，检查对象是否有__call__属性。你可以这样做:

hasattr(obj, '__call__')

经常被提及的类型。函数类型或检查。Isfunction方法(两者做的是完全相同的事情)有一些注意事项。对于非python函数，它返回False。例如，大多数内置函数是用C而不是Python实现的，因此它们返回False:

>>> isinstance(open, types.FunctionType)
False
>>> callable(open)
True

所以类型。FunctionType可能会给您带来令人惊讶的结果。检查鸭子类型对象属性的正确方法是询问它们是否嘎嘎叫，而不是查看它们是否适合鸭子大小的容器。

在内置命名空间中没有构造函数的内置类型(例如函数、生成器、方法)在types模块中。你可以使用类型。isinstance调用中的函数类型:

>>> import types
>>> types.FunctionType
<class 'function'>

>>> def f(): pass

>>> isinstance(f, types.FunctionType)
True
>>> isinstance(lambda x : None, types.FunctionType)
True

注意，这里使用了一个非常具体的“函数”概念，这通常不是您所需要的。例如，它拒绝zip(严格来说是一个类):

>>> type(zip), isinstance(zip, types.FunctionType)
(<class 'type'>, False)

Open(内置函数有不同类型):

>>> type(open), isinstance(open, types.FunctionType)
(<class 'builtin_function_or_method'>, False)

和随机的。Shuffle(技术上是一种隐藏随机的方法。随机实例):

>>> type(random.shuffle), isinstance(random.shuffle, types.FunctionType)
(<class 'method'>, False)

如果你在做一些特定类型的事情。FunctionType实例，如反编译字节码或检查闭包变量，使用类型。FunctionType，但如果你只是需要一个对象像函数一样可调用，请使用callable。

如果传递的对象可以在Python中调用，callable(x)将返回true，但该函数在Python 3.0中不存在，正确地说，将不区分:

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)

你将得到<class 'A'> True和<type function> True作为输出。

isinstance可以很好地确定某个东西是否是函数(尝试isinstance(b, types.FunctionType));如果你真的想知道某个东西是否可以被调用，你可以使用hasattr(b， '__call__')或直接尝试。

test_as_func = True
try:
    b()
except TypeError:
    test_as_func = False
except:
    pass

当然，这不会告诉您它是可调用的，但在执行时抛出TypeError，还是一开始就不可调用。这对你来说可能无关紧要。

函数只是一个带有__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!

Python的2to3工具(http://docs.python.org/dev/library/2to3.html)建议:

import collections
isinstance(obj, collections.Callable)

这似乎是选择了hasattr(x， '__call__')方法，因为http://bugs.python.org/issue7006。

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

从Python 2.1开始，你可以从inspect模块导入isfunction。

>>> from inspect import isfunction
>>> def f(): pass
>>> isfunction(f)
True
>>> isfunction(lambda x: x)
True

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

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

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

根据之前的回复，我想出了这个:

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)

任何函数都是一个类，所以你可以取实例x的类名并比较:

if(x.__class__.__name__ == 'function'):
     print "it's a function"

你可以检查用户定义的函数是否具有func_name、func_doc等属性，而不是检查'__call__'(它不是函数独有的)。这对方法不起作用。

>>> def x(): pass
... 
>>> hasattr(x, 'func_name')
True

另一种检查方法是使用inspect模块中的isfunction()方法。

>>> import inspect
>>> inspect.isfunction(x)
True

要检查对象是否是方法，请使用inspect.ismethod()

被接受的答案在当时被认为是正确的。因为它 结果是，没有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()

如果值是可调用的，代码将继续执行调用，只需执行调用并捕获TypeError。

def myfunc(x):
  try:
    x()
  except TypeError:
    raise Exception("Not callable")

在一些答案中提到的使用hasattr(obj， '__call__')和callable(.)的解决方案有一个主要缺点:对于具有__call__()方法的类和类的实例，它们都返回True。如。

>>> import collections
>>> Test = collections.namedtuple('Test', [])
>>> callable(Test)
True
>>> hasattr(Test, '__call__')
True

检查一个对象是否是用户定义的函数(只有a that)的一个正确方法是使用isfunction(.):

>>> import inspect
>>> inspect.isfunction(Test)
False
>>> def t(): pass
>>> inspect.isfunction(t)
True

如果您需要检查其他类型，请查看inspect -检查活动对象。

这里有一些其他的方法:

def isFunction1(f) :
    return type(f) == type(lambda x: x);

def isFunction2(f) :
    return 'function' in str(type(f));

我是这样想到第二个的:

>>> type(lambda x: x);
<type 'function'>
>>> str(type(lambda x: x));
"<type 'function'>"
# Look Maa, function! ... I ACTUALLY told my mom about this!

由于类也有__call__方法，我推荐另一种解决方案:

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

注意，Python类也是可调用的。

要获得函数(这里的函数指的是标准函数和lambdas)，请使用:

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)

如果你学过c++，你一定熟悉函数对象或函子，这意味着任何可以像函数一样调用的对象。

在c++中，普通函数是函数对象，函数指针也是;更一般地说，定义operator()的类的对象也是。在c++ 11及以上版本中，lambda表达式也是函子。

相似的是，在Python中，这些函子都是可调用的。一个普通的函数可以被调用，一个lambda表达式可以被调用，一个函数。Partial可以被调用，具有__call__()方法的类的实例可以被调用。

好，回到问题:我有一个变量x，我想知道它是否指向一个函数。

如果你想判断对象是否像一个函数，那么@John Feminella建议的callable方法是可以的。 如果您想判断一个对象是否只是一个普通函数(不是一个可调用的类实例或lambda表达式)，那么xtypes。@Ryan建议的XXX是更好的选择。

然后我用这些代码做了一个实验:

#!/usr/bin/python3
# 2017.12.10 14:25:01 CST
# 2017.12.10 15:54:19 CST

import functools
import types
import pprint

定义一个类和一个普通函数。

class A():
    def __call__(self, a,b):
        print(a,b)
    def func1(self, a, b):
        print("[classfunction]:", a, b)
    @classmethod
    def func2(cls, a,b):
        print("[classmethod]:", a, b)
    @staticmethod
    def func3(a,b):
        print("[staticmethod]:", a, b)

def func(a,b):
    print("[function]", a,b)

定义函子:

#(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

定义函子列表和类型列表:

## 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]

判断函数是否可调用。如您所见，它们都是可调用的。

res = [callable(xfunc)  for xfunc in xfuncs]
print("functors callable:")
print(res)

"""
functors callable:
[True, True, True, True, True, True, True, True]
"""

判断函数类型(types.XXX)。那么函子的类型就不一样了。

res = [[isinstance(xfunc, xtype) for xtype in xtypes] for xfunc in xfuncs]

## output the result
print("functors' types")
for (row, xfunc) in zip(res, xfuncs):
    print(row, xfunc)

"""
functors' types
[True, False, False, False, False] <built-in function open>
[False, True, False, True, False] <function func at 0x7f1b5203e048>
[False, True, False, True, False] <function <lambda> at 0x7f1b5081fd08>
[False, False, False, False, True] functools.partial(<function func at 0x7f1b5203e048>, b=4)
[False, False, False, False, False] <__main__.A object at 0x7f1b50870cc0>
[False, True, False, True, False] <function A.func1 at 0x7f1b5081fb70>
[False, False, True, False, False] <bound method A.func2 of <class '__main__.A'>>
[False, True, False, True, False] <function A.func3 at 0x7f1b5081fc80>
"""

我用这些数据绘制了一个可调用函子类型的表。

然后你可以选择合适的函子类型。

如:

def func(a,b):
    print("[function]", a,b)

>>> callable(func)
True
>>> isinstance(func,  types.FunctionType)
True
>>> isinstance(func, (types.BuiltinFunctionType, types.FunctionType, functools.partial))
True
>>> 
>>> isinstance(func, (types.MethodType, functools.partial))
False

下面是一个“repr方法”来检查它。它也适用于。

def a():pass
type(a) #<class 'function'>
str(type(a))=="<class 'function'>" #True

b = lambda x:x*2
str(type(b))=="<class 'function'>" #True

作为公认的答案，John Feminella说:

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

尽管有两个库来严格区分函数，但我画了一个详尽的可比表:

8.9. 内置类型的动态类型创建和名称。Python 3.7.0文档

30.13. inspect -检查活动对象- Python 3.7.0文档

#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',
]

“duck typing”是一般用途的首选解决方案:

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

至于内置函数

In [43]: callable(hasattr)
Out[43]: True

当进一步检查是内置函数还是用户定义函数

#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

确定是否内置函数

In [50]: isinstance(getattr, types.BuiltinFunctionType)
Out[50]: True
In [51]: isinstance(detect_function, types.BuiltinFunctionType)
Out[51]: False

总结

采用可调用鸭类型检查函数， 使用类型。如果您有进一步指定的需求，请使用BuiltinFunctionType。

这对我来说很管用:

str(type(a))=="<class 'function'>"

一个精确的功能检查器

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定义的函数，那么可能经过一些编辑后，它是检查对象是否是函数的首选方法。

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

你可以试试这个:

if obj.__class__.__name__ in ['function', 'builtin_function_or_method']:
    print('probably a function')

或者更奇怪的事情:

if "function" in lower(obj.__class__.__name__):
    print('probably a function')

结合@Sumukh Barve， @Katsu和@tinnick的回答，如果你的动机只是想在控制台中获取可用的内置函数列表，这两个选项是可行的:

(我对j __builtin__.__dict__.items如果j.__class__()。__name__ in ['function'， 'builtin_function_or_method']] (我对j __builtin__.__dict__.items()如果str (j)(18): = = ' <内置函数)

结果

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

你可以DIY一个简短的函数来检查输入是否不是字符串，并将输入转换为字符串将返回匹配的名称定义:

def isFunction(o):return not isinstance(o,str) and str(o)[:3]=='<fu';

我认为这段代码已经兼容所有python版本。

或者如果有什么变化，你可以添加额外的转换为小写并检查内容长度。我看到的函数的格式字符串是“<函数”+名称+“在0xFFFFFFFF>”

这是我的代码:

# -*- coding: utf-8 -*-
import hashlib
import inspect

# calc everything to md5!!
def count_md5(content):
    if isinstance(content, dict):
        return count_md5(
            [(str(k), count_md5(content[k])) for k in sorted(content.keys())],
        )
    elif isinstance(content, (list, tuple)):
        content = [count_md5(k) for k in content]
    elif callable(content):
        return make_callable_hash(content)
    return calc_md5(str(content))


def calc_md5(content):
    m2 = hashlib.md5()
    if isinstance(content, str):
        m2.update(content.encode("utf8"))
    else:
        m2.update(content)
    return m2.hexdigest()


def make_callable_hash(content):
    if inspect.isclass(content):
        h = []
        for attr in [i for i in sorted(dir(content)) if not i.startswith("__")]:
            v = getattr(content, attr)
            h.append(count_md5(v))

        return calc_md5("".join(h))

    return calc_md5(content.__name__)

对于callable，大多数时候我们只是想看看属性的值是否一致，所以我们可以取callable的所有属性并计算它。 如果它是一个类'callable'将返回true，所以它不是很严格

使用isinstance()和type()，它们都是Python中的内置函数，你可以检查它是否是一个函数，这样你就不需要导入任何东西:

def test():
    pass

print(isinstance(test, type(test)))

输出:

True