What Is a "Callable"

What is a callable?

A callable is anything that can be called.

The built-in callable (PyCallable_Check in objects.c) checks if the argument is either:

an instance of a class with a __call__ method or
is of a type that has a non null tp_call (c struct) member which indicates callability otherwise (such as in functions, methods etc.)

The method named __call__ is (according to the documentation)

Called when the instance is ''called'' as a function

Example

class Foo:
  def __call__(self):
    print 'called'

foo_instance = Foo()
foo_instance() #this is calling the __call__ method

What is the definition of a callable type?

Is the operator for "the function call operatation" ()? So is a callable type defined as a type whose instances the function call operator () can be applied to?

Yes, exactly.

Does it mean that a callable type may or might not have a __call__() method? If a class has a __call__() method, then it must be a callable type? If a class doesn't have a __call__() method, then it might or might not be a callable type?

For a given object to be a callable, it must define __call__, functions do, for example:

def foo():
    pass
callable(foo) # True

staticmethod's or classmethods (to continue from the previous question), don't define __call__:

s = staticmethod(foo)
callable(s)  # False

(callable essentially does something like getattr(foo, '__call__', False))

Do "user-defined functions, built-in functions, methods of built-in objects, class objects, methods of class instances" not have a call() method? Are they instances of callable types? What specific types do they have respectively?

User defined functions (function type, like foo) have __call__.
Built-in functions (e.g max) also have __call__, see callable(max).
Methods of built-in objects, yes: callable(str.isupper).
Class objects, yes (type defines a __call__ for them):
```
>>> class Spam: pass
>>> callable(Spam) # True
```

Methods of class instances:

>>> class Spam2: 
...     def do_spam(self):
...         return "spam"
...
>>> callable(Spam2().do_spam)  # True

They are all callable because they define a __call__ special method. That's the only way to make an object callable.

As for staticmethods and classmethods, though they usually wrap callables (which they then expose via the descriptor protocol), they themselves are not callable since they don't define a __call__ special method.

what is the difference between a function and a callable object in python?

In your super-simple example. there's no practical difference, since functions are also callable objects.

However, a callable object is an object of a class that you write, so you may write this code:

class Counter:
    def __init__(self, value = 0):
        self.n = 0

    def __call__(self):
        self.n += 1
        return self.n

    def __repr__(self):
        return str(self.n)

redWins = Counter()
blueWins = Counter()

if foo():
    redWins()
else:
    blueWins()

print("Red has won {} times.\nBlue has won {} times."
      .format(redWins, blueWins))

And you'll find it hard to implement such a class using only functions. Even if you try to do it with global variables, you can't have separate instances of one single global variable.

See more: Functions, Callable Objects, and how both are created in Python

what exactly is python typing.Callable?

typing.Callable is the type you use to indicate a callable. Most python types that support the () operator are of the type collections.abc.Callable. Examples include functions, classmethods, staticmethods, bound methods and lambdas.

In summary, anything with a __call__ method (which is how () is implemented), is a callable.

PEP 677 attempted to introduce implicit tuple-with-arrow syntax, so that something like Callable[[int, str], list[float]] could be expressed much more intuitively as (int, str) -> list[float]. The PEP was rejected because the benefits of the new syntax were not deemed sufficient given the added maintenance burden and possible room for confusion.

Python - What does it mean for a Class to be callable?

So, start with the fact that in Python, ordinarily functions are callable, and classes are callable.
Leaving apart the mechanisms that mark functions as callable, Python classes have, as you know, special methods. The method that makes instances of a class callable is __call__. So, if your class has an explicit __call__ method, its instances are callable and end of story: when you call the instance, it is the __call__ method that is called.

That answers half your question - now let's check what the __call__ method on the class of classes does.

Classes in Python are themselves also first class objects - but they have to be an instance of type. That is, calling type as one calls a class to create an instance, creates a new class. The Python runtime does this automatically when a class body block is met in code.
(but one can also create new classes programmaticaly by explicitly calling type in its three+ parameter form)

As type itself is a subclass of object - its __new__ method is what it has of special, as it creates a new class, filling up all needed data structures as required by the cPython ABI, allocating memory, and putting values into fields that are not accessible from pure Python codes. As it is the class for any kind of class-object in Python it is called a metaclas. One can derive other classes from type and create custom metaclasses, to run code,r insert attributes, register data and so on at the moment classes are created - but that is optional. Any class created goes through type's __new__.

And when you instantiate a class? I wrote above that what makes an object callable in Python is the presence of a __call__ method in its class. type being the class of all classes, it does feature a __call__ method - and it contains the code needed to orchestrate the call to the class' __new__ and __init__ methods. And that is why classes are callable, and why Python can use the same syntax for function calls and object instantiation.

is A.__call__() being called each time I instantiate with A()?

Not properly - what is called is type(A).__call__. A.__call__ and type(A).__call__ will be the same if there is no explict __call__ method defined in A (then its class, type is searched for __call__. But special methods are not called implicitly by Python by ordinary attribute retrieval: they are always picked from the object's class - and that is made inside the runtime.

You might be confused for the metaclass' call not to be available to the class: that is simply not defined like that in the method retrieval algorithms from Python. When you ask for an attribute or method of an object- including a special method like __call__, the class is searched for the attribute in the form a descriptor (to provide custom attribute access) - and then the base classes of that class, but not the class of that class. (Also, for special methods, they are only special if they are defined in the object's class itself: being attached directly to an instance have no effect).

The key document where this is all published is the Python's Data Model - it can take some time and experimenting to figure everything out from there, though.

What is a callable in Tensorflow?

A callable is anything that can be called. See here.

The cond should be a function. You can use lambda (See here) to make your condition callable.

Here there is a minimal example of how to use tf.while_loop:

i = tf.constant(0)
c = lambda i: tf.less(i, 10)
b = lambda i: tf.add(i, 1)
r = tf.while_loop(c, b, [i])

And in the end, not a bad idea to post a minimal code that actually runs and generates your error.

What does the keyword callable do in PHP

The callable type allows us to pass a callback function to the function that is being called. That is, callback function parameters allow the function being called to dynamically call code that we specify in the callable function parameter. This is useful because it allows us to pass dynamic code to be executed to a function.

For example, one might want to call a function and the function accepts a callback function called log, which would log data in a custom way that you want.

I hope that makes sense. For details, see this link.

How do I use a callable object as a method definition?

By wrapping that function method in a class you are effectively preventing the mechanism that binds an object to a function and thus creates a method. The way this works is that regular python functions are descriptors.

To summarize the docs: When you write the following code:

some_instance.some_function()

The some_functions __get__ method is called with some_instance as the first parameter. The __get__ method then returns a bound method object, that remembers the instance. Later, when the bound method object's __call__ method is called, it passes the saved instance as a first parameter.

We can reimplement that behaviour like this:

def method(*args, **kwargs):
    print("%r %r" % (args, kwargs))


class BoundMethod(object):
    # the bound method remembers the instance and the function
    def __init__(self, instance, function):
        self.instance = instance
        self.function = function

    # when the bound method is called, it passes the instance
    def __call__(self, *args, **kwargs):
        return self.function(self.instance, *args, **kwargs)


class Method(object):
    # the __get__ method assembles a bound method consisting of the
    # instance it was called from and the function
    def __get__(self, instance, cls):
        return BoundMethod(instance, method)


class Test(object):
    method1 = Method()


t = Test()
t.method1()  # (<__main__.Test object at 0x7f94d8c3aad0>,) {}

In your case Method is not a descriptor. So, when internally the __call__ property (which is a function) is requested it is bound to an object of the containing class (Method).

I am not sure if this is useful, as this example is just a simplified version of what happens under the hood anyway.

Note: in this example:

class C:
    def function(self): pass

print(C.function)
print(C().function)

The first print shows us, that an unbound method literally is called <unbound method C.function> while a bound method is called <bound method C.function of ...>.

In python3 however the first print shows us that unbound methods are just the unchanged functions we defined in the class.

What are callable objects in javascript?

I'm sure someone else can give a more comprehensive answer, but basically a callable object is one which you can call, as evidenced by the presence of the call function, e.g.:

if (func.call) {
    func.call();   
}

JSFiddle: https://jsfiddle.net/Lzaonmgo/

MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call