我如何检测一个变量是否是一个函数?

我有一个变量x，我想知道它是否指向一个函数。

我希望我能做一些像这样的事情:

>>> isinstance(x, function)

但这给了我:

Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'function' is not defined

我选这个是因为

>>> type(x)
<type 'function'>

当前回答

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

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

2013-11-11 03:45:17

其他回答

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

callable(x)

2009-03-09 03:33:49

这对我来说很管用:

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

2019-04-29 14:49:41

尝试使用callable(x)。

摘录:

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

2009-03-09 03:35:11

结果

	callable(x)	hasattr(x, '__call__')	inspect.isfunction(x)	inspect.ismethod(x)	inspect.isgeneratorfunction(x)	inspect.iscoroutinefunction(x)	inspect.isasyncgenfunction(x)	isinstance(x, typing.Callable)	isinstance(x, types.BuiltinFunctionType)	isinstance(x, types.BuiltinMethodType)	isinstance(x, types.FunctionType)	isinstance(x, types.MethodType)	isinstance(x, types.LambdaType)	isinstance(x, functools.partial)
print	√	√	×	×	×	×	×	√	√	√	×	×	×	×
func	√	√	√	×	×	×	×	√	×	×	√	×	√	×
functools.partial	√	√	×	×	×	×	×	√	×	×	×	×	×	√
<lambda>	√	√	√	×	×	×	×	√	×	×	√	×	√	×
generator	√	√	√	×	√	×	×	√	×	×	√	×	√	×
async_func	√	√	√	×	×	√	×	√	×	×	√	×	√	×
async_generator	√	√	√	×	×	×	√	√	×	×	√	×	√	×
A	√	√	×	×	×	×	×	√	×	×	×	×	×	×
meth	√	√	√	×	×	×	×	√	×	×	√	×	√	×
classmeth	√	√	×	√	×	×	×	√	×	×	×	√	×	×
staticmeth	√	√	√	×	×	×	×	√	×	×	√	×	√	×

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)

	time/s
callable(x)	0.86
hasattr(x, '__call__')	1.36
isinstance(x, typing.Callable)	12.19

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

2021-11-03 10:42:50

下面是一个“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

2018-01-12 10:42:52

我如何检测一个变量是否是一个函数?

推荐文章

最新文章

标签