Что такое "вызываемый" в Python?

из источников Python .

другого объекта x вызываемый iffx->ob_type->tp_call != NULL

описание tp_call поле:

ternaryfunc tp_call необязательный указатель на функцию, которая реализует вызов объекта. Это должно быть NULL, если объект не вызывается. Подпись такая же, как и для PyObject_Call (). Это поле наследуется по подтипам.

вы всегда можете использовать встроенный callable функция, чтобы определить, является ли данный объект вызываемым или нет; или еще лучше просто вызвать его и поймать TypeError позже. callable удалены в Python 3.0 и 3.1, используйте callable = lambda o: hasattr(o, '__call__') или isinstance(o, collections.Callable).

пример, упрощенный кэш реализация:

class Cached:
    def __init__(self, function):
        self.function = function
        self.cache = {}

    def __call__(self, *args):
        try: return self.cache[args]
        except KeyError:
            ret = self.cache[args] = self.function(*args)
            return ret    

использование:

@Cached
def ack(x, y):
    return ack(x-1, ack(x, y-1)) if x*y else (x + y + 1) 

пример из стандартной библиотеки, file site.py, определение встроенного exit() и quit() функции:

class Quitter(object):
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return 'Use %s() or %s to exit' % (self.name, eof)
    def __call__(self, code=None):
        # Shells like IDLE catch the SystemExit, but listen when their
        # stdin wrapper is closed.
        try:
            sys.stdin.close()
        except:
            pass
        raise SystemExit(code)
__builtin__.quit = Quitter('quit')
__builtin__.exit = Quitter('exit')

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

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

class a(object):
    def __call__(self, *args):
        print 'Hello'

func = a()

# or ... 
def func(*args):
    print 'Hello'

вы можете использовать этот метод вместо метода как doit или выполнить, Я думаю, что это просто более ясно, чтобы увидеть obj (), чем параметр obj.сделайэто()

позвольте мне объяснить в обратном порядке:

рассмотреть этот вопрос...

foo()

... как синтаксический сахар для:

foo.__call__()

здесь foo может быть любой объект, который реагирует на __call__. Когда я говорю любой объект, я имею в виду его: встроенные типы, ваши собственные классы и их экземпляры.

в случае встроенных типов, когда вы пишете:

int('10')
unicode(10)

вы по существу делаете:

int.__call__('10')
unicode.__call__(10)

вот почему у вас нет foo = new int в Python: вы просто сделайте объект класса возвращать экземпляр его на __call__. То, как Python решает это, на мой взгляд, очень элегантно.

вызываемый объект-это объект, который имеет __call__ метод. Это означает, что вы можете подделать вызываемые функции или делать аккуратные вещи, такие как Частичная Функция Приложения где вы берете функцию и добавляете что-то, что улучшает ее или заполняет некоторые параметры, возвращая что-то, что можно вызвать в свою очередь (известный как карринг в кругах функционального программирования).

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

[nigel@k9 ~]$ python
Python 2.5 (r25:51908, Nov  6 2007, 15:55:44) 
[GCC 4.1.2 20070925 (Red Hat 4.1.2-27)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 'aaa'()    # <== Here we attempt to call a string.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable
>>> 

просто "вызвать" то, что можно назвать как способ. Встроенная функция "callable ()" скажет вам, является ли что-то вызываемым, как и проверка на вызов собственность. Функции вызываются так же, как и классы, экземпляры классов могут быть вызываемыми. Смотрите об этом подробнее здесь и здесь.

__call__ делает любой объект вызываемым как функция.

этот пример выведет 8:

class Adder(object):
  def __init__(self, val):
    self.val = val

  def __call__(self, val):
    return self.val + val

func = Adder(5)
print func(3)

в Python вызываемый объект-это объект, тип которого имеет __call__ способ:

>>> class Foo:
...  pass
... 
>>> class Bar(object):
...  pass
... 
>>> type(Foo).__call__(Foo)
<__main__.Foo instance at 0x711440>
>>> type(Bar).__call__(Bar)
<__main__.Bar object at 0x712110>
>>> def foo(bar):
...  return bar
... 
>>> type(foo).__call__(foo, 42)
42

так просто:)

Это конечно можно перегружать:

>>> class Foo(object):
...  def __call__(self):
...   return 42
... 
>>> f = Foo()
>>> f()
42

Это то, что вы можете поставить "(args)" после и ожидать, что он будет работать. Вызываемый обычно является методом или классом. Вызываются методы, создаются экземпляры классов.

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

Class A:
    def __init__(self,val):
        self.val = val
    def bar(self):
        print "bar"

obj = A()      
callable(obj.bar)
True
callable(obj.__init___)
False
def foo(): return "s"
callable(foo)
True
callable(foo())
False

Callable-это тип или класс "встроенной функции или метода" с методом вызов

>>> type(callable)
<class 'builtin_function_or_method'>
>>>

пример: print является вызываемым объектом. Со встроенной функцией _ _ call__ Когда вы вызываете print функция, Python создает объект типа print и вызывает его метод _ _ call__ передача параметров, если таковые имеются.

>>> type(print)
<class 'builtin_function_or_method'>
>>> print.__call__(10)
10
>>> print(10)
10
>>>

спасибо. С уважением, Марис

callables реализации __call__ специальный метод, таким образом, любой объект с помощью такого метода можно вызывать.