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

У меня есть переменная, xи я хочу знать, указывает ли она на функцию или нет.

Я надеялся, что смогу сделать что-то вроде:

>>> isinstance(x, function)

Но это дает мне:

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

Я выбрал это потому, что

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

Если это для Python 2.x или для Python 3.2+, вы также можете использовать callable(). Раньше он устарел, но теперь не устарел, поэтому вы можете использовать его снова. Вы можете прочитать обсуждение здесь: http://bugs.python.org/issue10518 . Вы можете сделать это с:

callable(obj)

Если это для Python 3.x, но до 3.2, проверьте, есть ли у объекта __call__атрибут. Вы можете сделать это с:

hasattr(obj, '__call__')

Часто предлагаемый types.FunctionTypesподход не верен, потому что он не охватывает многие случаи, которые вы, вероятно, хотели бы, чтобы он прошел, как с buildins:

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

>>> callable(open)
True

Правильный способ проверить свойства объектов типа «утка» - это спросить их, если они крякают, а не посмотреть, помещаются ли они в контейнер размером с утку. Не используйте, types.FunctionTypeесли у вас нет четкого представления о функции.

Встроенные типы, которые не имеют конструкторов во встроенном пространстве имен (например, функции, генераторы, методы), находятся в 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

Обратите внимание, что здесь используется очень специфическое понятие «функция», которое обычно не то, что вам нужно. Например, он отклоняет zip(технически класс):

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

open (встроенные функции имеют другой тип):

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

и random.shuffle(технически метод скрытого random.Randomэкземпляра):

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

Если вы делаете что-то конкретное для types.FunctionTypeэкземпляров, например, декомпилируете их байт-код или просматриваете переменные замыкания, используйте types.FunctionType, но если вам просто нужен объект, который можно вызывать как функцию, используйте callable.

Начиная с Python 2.1 вы можете импортировать isfunctionиз inspectмодуля.

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

Принятый ответ был в то время, когда он был предложен, считался правильным. Как выясняется, нет никакой замены для 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. Тем не менее, на самом деле нет никакого возможного способа, которым он мог бы дать более точный результат, чем результат, чем при использовании callable()самого себя, поскольку typeobject->tp_call метод слота недоступен каким-либо другим способом.

Просто используйте callable()

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

callable(x)

Инструмент Python 2to3 ( http://docs.python.org/dev/library/2to3.html ) предлагает:

import collections
isinstance(obj, collections.Callable)

Кажется, это был выбран вместо hasattr(x, '__call__')метода из-за http://bugs.python.org/issue7006 .

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

Если вы хотите обнаружить все, что синтаксически похоже на функцию: функцию, метод, встроенную функцию fun / meth, lambda ..., но исключить вызываемые объекты (объекты с __call__определенным методом), попробуйте следующее:

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

Я сравнил это с кодом is*()проверок в inspectмодуле, и приведенное выше выражение гораздо более полно, особенно если ваша цель - отфильтровать какие-либо функции или обнаружить обычные свойства объекта.

Попробуйте использовать callable(x).

Если вы узнали C++, вы должны быть знакомы с function objectили functorозначает любой объект, который может be called as if it is a function.

В C ++ an ordinary function- это объект функции, а также указатель на функцию; в более общем смысле - это объект класса, который определяет operator(). В C ++ 11 и выше, the lambda expressionэто functorтоже.

Сходство, в Python, functorsэто все callable. An ordinary functionможет быть вызвано, a lambda expressionможет быть вызвано, functional.partialможет быть вызвано, экземпляры class with a __call__() methodмогут быть вызваны.

Хорошо, вернемся к вопросу: I have a variable, x, and I want to know whether it is pointing to a function or not.

Если вы хотите судить о том, действует ли объект как функция, то предложенный callableметод @John Feminellaв порядке.

Если вы хотите judge whether a object is just an ordinary function or not(не экземпляр вызываемого класса или лямбда-выражение), то xtypes.XXXпредложенный @Ryanвариант является лучшим выбором.

Затем я делаю эксперимент с использованием этого кода:

#!/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

В качестве принятого ответа Джон Феминелла заявил, что:

Правильный способ проверить свойства объектов типа «утка» - это спросить их, если они крякают, а не посмотреть, помещаются ли они в контейнер размером с утку. Подход «сравните это напрямую» даст неправильный ответ для многих функций, таких как встроенные функции.

Несмотря на то, что есть две библиотеки, чтобы строго различать функции, я рисую исчерпывающую сопоставимую таблицу:

8.9. types - Создание динамических типов и имен для встроенных типов - Документация Python 3.7.0

30,13. осмотреть - осмотреть живые объекты - документация 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',
]

«Утиная печать» является предпочтительным решением общего назначения:

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

Определите, если builtin function

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

Резюме

Наймите callableтипу утиной проверки функции,
используйте , types.BuiltinFunctionTypeесли вы дополнительно указаны требование.

Функция - это просто класс с __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!

Вот несколько других способов:

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__'(которая не является исключительными функции), вы можете проверить , есть ли определенный пользователь функции атрибуты func_name, func_docи т.д. Это не работает для методов.

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

Другой способ проверки - использование isfunction()метода из inspectмодуля.

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

Чтобы проверить, является ли объект методом, используйте inspect.ismethod()

Так как у классов также есть __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 также могут вызываться.

Чтобы получить функции (и под функциями мы подразумеваем стандартные функции и лямбды), используйте:

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)

Какая бы функция ни была классом, вы можете взять имя класса экземпляра x и сравнить:

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

Решения, использующие hasattr(obj, '__call__')и callable(.)упомянутые в некоторых ответах, имеют главный недостаток: оба возвращаются Trueдля классов и экземпляров классов с __call__()методом. Например.

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

Один правильный способ проверки, является ли объект пользовательской функцией (и ничего кроме этого), заключается в использовании isfunction(.):

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

Если вам нужно проверить другие типы, взгляните на осмотр - осмотр живых объектов .

Точная проверка функций

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

Правильный способ проверить свойства объектов типа «утка» - это спросить их, если они крякают, а не посмотреть, помещаются ли они в контейнер размером с утку. Подход «сравните это напрямую» даст неправильный ответ для многих функций, таких как встроенные функции.

Мы будем относиться к этому так:

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

Как бы мы это реализовали?

Модуль 'types' имеет множество классов для обнаружения функций, наиболее полезными из которых являются types.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 (частичный), потому что это класс, а не функция, и это именно функции, а не классы. Вот предварительный просмотр для вас, чтобы попробовать код из.

Вывод

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

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

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

В Python3 я придумал, type (f) == type (lambda x:x)что дает, Trueесли fявляется функцией, а Falseесли нет. Но я думаю, что я предпочитаю isinstance (f, types.FunctionType), который чувствует себя менее специальным. Я хотел сделать type (f) is function, но это не работает.

Следуя предыдущим ответам, я придумал это:

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)

Вы можете попробовать это:

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

Если код будет продолжать выполнять вызов, если значение вызывается, просто выполните вызов и поймайте TypeError.

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

Ниже приведен «способ 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

Это работает для меня:

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