Ich habe eine Variable, xund ich möchte wissen, ob es auf eine Funktion zeigt oder nicht.

Ich hatte gehofft, ich könnte so etwas tun:

>>> isinstance(x, function)

Aber das gibt mir:

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

Der Grund, warum ich das ausgewählt habe, ist, weil

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

Wenn dies für Python 2.x oder für Python 3.2+ ist, können Sie verwenden callable(). Es war früher veraltet, ist aber jetzt nicht mehr veraltet, sodass Sie es wieder verwenden können. Die Diskussion können Sie hier nachlesen: http://bugs.python.org/issue10518. Sie können dies tun mit:

callable(obj)

Wenn dies für Python 3.x, aber vor 3.2 ist, überprüfen Sie, ob das Objekt eine hat __call__ Attribut. Sie können dies tun mit:

hasattr(obj, '__call__')

Das oft suggerierte types.FunctionTypes oder inspect.isfunction Ansatz (beide tun genau dasselbe) enthält eine Reihe von Einschränkungen. Es kehrt zurück False für Nicht-Python-Funktionen. Die meisten eingebaute Funktionensind beispielsweise in C und nicht in Python implementiert, daher kehren sie zurück False:

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

Also types.FunctionType könnte Ihnen überraschende Ergebnisse liefern. Der richtige Weg, die Eigenschaften von entenartigen Objekten zu überprüfen, besteht darin, sie zu fragen, ob sie quaken, und nicht, um zu sehen, ob sie in einen Behälter in Entengröße passen.

Eingebaute Typen, die keine Konstruktoren im eingebauten Namensraum haben (z. B. Funktionen, Generatoren, Methoden), befinden sich in der types Modul. Sie können verwenden types.FunctionType in einem (n isinstance Anruf:

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

>>> def f(): pass

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

Beachten Sie, dass dies einen sehr spezifischen Begriff von “Funktion” verwendet, der normalerweise nicht das ist, was Sie brauchen. Sie lehnt zum Beispiel ab zip (technisch eine Klasse):

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

open (eingebaute Funktionen haben einen anderen Typ):

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

und random.shuffle (technisch gesehen eine Methode eines versteckten random.Random Beispiel):

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

Wenn Sie etwas Bestimmtes tun types.FunctionType Instanzen, wie das Dekompilieren ihres Bytecodes oder das Untersuchen von Closure-Variablen, verwenden types.FunctionTypeaber wenn Sie nur ein Objekt benötigen, das wie eine Funktion aufgerufen werden kann, verwenden Sie callable.

Seit Python 2.1 kannst du importieren isfunction von dem inspect Modul.

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

Die akzeptierte Antwort wurde zum Zeitpunkt des Angebots für richtig gehalten. Wie sich herausstellt, gibt es das kein Ersatz zum callable()das wieder in Python 3.2 enthalten ist: Insbesondere callable() prüft die tp_call Feld des zu testenden Objekts. Es gibt kein einfaches Python-Äquivalent. Die meisten der vorgeschlagenen Tests sind meistens richtig:

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

Wir können einen Schraubenschlüssel hineinwerfen, indem wir die entfernen __call__ aus der Klasse. Und nur um die Dinge besonders spannend zu halten, fügen Sie eine Fälschung hinzu __call__ zur Instanz!

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

Beachten Sie, dass dies wirklich nicht aufrufbar ist:

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

callable() gibt das richtige Ergebnis zurück:

>>> callable(can_o_spam)
False

Aber hasattr ist falsch:

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

can_o_spam hat dieses Attribut doch; Es wird nur nicht verwendet, wenn die Instanz aufgerufen wird.

Noch subtiler, isinstance() versteh das auch falsch:

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

Da wir diese Überprüfung früher verwendet und die Methode später gelöscht haben, abc.ABCMeta
speichert das Ergebnis. Vermutlich handelt es sich hier um einen Bug-in abc.ABCMeta. Das heißt, es gibt wirklich keine Möglichkeit könnte produzieren ein genaueres Ergebnis als das Ergebnis als mit callable() selbst, da die typeobject->tp_call
Die Slot-Methode ist auf keine andere Weise zugänglich.

Benutz einfach callable()

Folgendes sollte einen booleschen Wert zurückgeben:

callable(x)

Ergebnis

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)

Zeit

Wählen Sie die drei gängigsten Methoden:

• 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

Das 2to3-Tool von Python (http://docs.python.org/dev/library/2to3.html) schlägt vor:

import collections
isinstance(obj, collections.Callable)

Es scheint, dass dies anstelle von gewählt wurde hasattr(x, '__call__') Methode wegen http://bugs.python.org/issue7006.