tengo la variable x y quiero saber si es una función o no.

Esperaba poder hacer algo como:

>>> isinstance(x, function)

Pero eso me da:

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

La razón por la que elegí eso es porque

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

Si esto es para Python 2.x o para Python 3.2+, puede usar callable(). Solía ​​estar en desuso, pero ahora no está en desuso, por lo que puede usarlo nuevamente. Puedes leer la discusión aquí: http://bugs.python.org/issue10518. Puedes hacer esto con:

callable(obj)

Si esto es para Python 3.x pero anterior a 3.2, verifique si el objeto tiene un __call__ atributo. Puedes hacer esto con:

hasattr(obj, '__call__')

El sugerido a menudo types.FunctionTypes o inspect.isfunction enfoque (ambos lo hacen exactamente lo mismo) viene con una serie de advertencias. Vuelve False para funciones que no son de Python. La mayoría funciones integradaspor ejemplo, se implementan en C y no en Python, por lo que devuelven False:

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

asi que types.FunctionType podría darte resultados sorprendentes. La forma adecuada de verificar las propiedades de los objetos tipo pato es preguntarles si graznan, no para ver si caben en un recipiente del tamaño de un pato.

Los tipos integrados que no tienen constructores en el espacio de nombres integrado (por ejemplo, funciones, generadores, métodos) están en el types módulo. Puedes usar types.FunctionType en un isinstance llamar:

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

>>> def f(): pass

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

Tenga en cuenta que esto utiliza una noción muy específica de “función” que generalmente no es lo que necesita. Por ejemplo, rechaza zip (técnicamente una clase):

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

open (las funciones integradas tienen un tipo diferente):

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

y random.shuffle (técnicamente un método de un oculto random.Random instancia):

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

Si estás haciendo algo específico para types.FunctionType instancias, como descompilar su código de bytes o inspeccionar variables de cierre, use types.FunctionTypepero si solo necesita que se pueda llamar a un objeto como una función, use callable.

Desde Python 2.1 puedes importar isfunction desde el inspect módulo.

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

En el momento en que se ofreció, se pensó que la respuesta aceptada era correcta. Resulta que hay sin sustituto por callable()que está de vuelta en Python 3.2: Específicamente, callable() comprueba el tp_call campo del objeto que se está probando. No hay un equivalente simple de Python. La mayoría de las pruebas sugeridas son correctas la mayor parte del tiempo:

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

Podemos lanzar una llave inglesa en esto quitando el __call__ de la clase Y solo para mantener las cosas aún más emocionantes, agregue un falso __call__ a la instancia!

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

Tenga en cuenta que esto realmente no es invocable:

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

callable() devuelve el resultado correcto:

>>> callable(can_o_spam)
False

Pero hasattr es equivocado:

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

can_o_spam tiene ese atributo después de todo; simplemente no se usa al llamar a la instancia.

Aún más sutil, isinstance() también se equivoca en esto:

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

Debido a que usamos esta verificación antes y luego eliminamos el método, abc.ABCMeta
almacena en caché el resultado. Podría decirse que esto es un error en abc.ABCMeta. Dicho esto, realmente no hay forma posible de que pudo producir un resultado más preciso que el resultado que usando callable() mismo, desde el typeobject->tp_call
el método de ranura no es accesible de ninguna otra manera.

Solo usa callable()

Lo siguiente debería devolver un valor booleano:

callable(x)

Resultado

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)

Tiempo

Elija los tres métodos más comunes:

• callable(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

La herramienta 2to3 de Python (http://docs.python.org/dev/library/2to3.html) sugiere:

import collections
isinstance(obj, collections.Callable)

Parece que este fue elegido en lugar del hasattr(x, '__call__') método debido a http://bugs.python.org/issue7006.