Как определить, является ли переменная Python функцией?

Функция является просто классом с __call__ метод, таким образом, можно сделать

hasattr(obj, '__call__')

, Например:

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

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

, Который является "лучшим" способом сделать его, но в зависимости от того, почему необходимо знать, если это является вызываемым или отмечает, Вы могли бы просто поместить его в try/execpt блок:

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

спорно, является ли попыткой/кроме больше Python'y, чем выполнение if hasattr(x, '__call__'): x().. Я сказал бы 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(x).

callable(x) будет возвращать true, если объект передал, может быть назван в Python, но функция не существует в 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, когда это выполняется или не является вызываемым во-первых. Это не может иметь значения для Вас.

Следующее должно возвратить булевскую переменную:

callable(x)

Встроенные типы, которые не имеют конструкторов во встроенном пространстве имен (например, функции, генераторы, методы) находятся в types модуль. Можно использовать types.FunctionType в вызове isinstance.

In [1]: import types
In [2]: types.FunctionType
Out[2]: <type 'function'>
In [3]: def f(): pass
   ...:
In [4]: isinstance(f, types.FunctionType)
Out[4]: True
In [5]: isinstance(lambda x : None, types.FunctionType)
Out[5]: True

Точное Функциональное Средство проверки

вызываемый является очень хорошим решением. Однако я хотел рассматривать это противоположный способ John Feminella. Вместо того, чтобы рассматривать его как это высказывание:

надлежащий способ проверить свойства утиных типизированных объектов состоит в том, чтобы спросить их, если они шарлатан, чтобы не видеть, помещаются ли они в контейнер размера утки. "Выдерживают сравнение, это непосредственно" подход даст неправильный ответ для многих функций, как builtins.

Мы будем рассматривать его как это:

надлежащий способ проверить, является ли что-то уткой, не состоит в том, чтобы видеть, может ли он шарлатан, а скорее видеть - ли это действительно утка через несколько фильтров, вместо того, чтобы просто проверить, походит ли он на утку от поверхности.

, Как Мы Реализовали бы Его

, модуль 'типов' имеет много классов для обнаружения функций, самое полезное существо типы. FunctionType, но существует также много других, как тип метода, созданный в типе и типе лямбды. Мы также рассмотрим объект '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]

одна ложь была (неравнодушным) is_function, потому что это - класс, не функция, и это - точно функции, не классы. Вот предварительный просмотр , чтобы Вы испытали код от.

Заключение

, вызываемое (obj) , является предпочтительным методом проверить, является ли объект функцией, если Вы хотите пойти ввод утки более чем абсолютные понятия .

Наше пользовательское is_function (obj) , возможно, с некоторыми редактированиями является предпочтительным методом проверить, является ли объект функцией, если Вы не проводите никакого подсчета вызываемый экземпляр класса как функция, но только функции, определяемые встроенный , или с лямбда , определение , или неравнодушный .

И я думаю, что это оборачивает все это.Хорошего дня!