Introduction
A callable
is an object in Python that can be called / executed when called with parantheses ( )
. Classes and functions are callable.
Callables can be a class, a function, or an instance of a class. In simple terms, a class/function/instance/builtin is callable if it gets executed while being called with the parantheses ()
.
Example 1:
In [1]: help() Welcome to Python 3.6's help utility! -- content omitted -- -------- In [2]: int() Out[2]: 0 In [3]: callable(int) Out[3]: True -------- In [4]: callable(help) Out[4]: True -------- In [5]: def hello(): ..: print("Howdy!!") In [6]: hello() Howdy!! In [7]: callable(hello) Out[7]: True
In Example 1, we can see that the builtins like help()
, a pre-defined type such as int()
, and a custom function hello()
are all callable. These can be executed while being called with parantheses.
The __call__() method
The callable()
builtin helps to determine if an object is callable or not. Internally, it translates to the magic method __call__()
.
In short:
my_object(*args)
translates to my_object.__call__(*args)
All classes and functions are callable, as well as instances of classes with the __call__
magic method. An instance of a class/function is usually not callable (even though the class/function itself is), unless the class carries a __call__
magic method.
In other words, an instance is callable only if the class it is instantiated from contains the __call__
magic method.
- The inbuilt documentation on
callable
states:
In [1]: print(callable.__doc__) Return whether the object is callable (i.e., some kind of function). Note that classes are callable, as are instances of classes with a __call__() method.
Example 2:
In [5]: def hello(): ...: print("Howdy!!") In [6]: hello() Howdy!! In [7]: hello.__call__() Howdy!! In [8]: callable(hello) Out[8]: True
Example 2 shows that a function when called with the parantheses (including any required arguments) is equivalent to calling the __call__()
magic method. ie.. calling a function/class with parantheses translates to calling the __call__()
magic method.
NOTE:
Read more on Magic methods in Python
Example 3: Non-callable Instances
In [1]: type(1) Out[1]: int In [2]: callable(1) Out[2]: False In [3]: x = 1 In [4]: type(x) Out[4]: int In [5]: callable(int) Out[5]: True In [6]: callable(x) Out[6]: False
Example 3 above shows that even though the int
class is callable, the instances created from the int
class are not.
Remember that instances will only be callable if the class from which it was instantiated contains a __call__
method. Inspecting the methods of class int
reveals that it does not have a __call__
method.
NOTE: You can view the methods of the int
class using help(int)
or dir(int)
.
Example 4: Another example with Classes
In [52]: class tell: ...: def __call__(self): ...: pass In [53]: telling = tell() In [54]: callable(tell) Out[54]: True In [55]: callable(telling) Out[55]: True -------- In [56]: class test: ...: pass In [57]: testing = test() In [58]: callable(test) Out[58]: True In [59]: callable(testing) Out[59]: False
Since all classes are by default callable, both the classes tell
and test
in Example 4 are callable. But the instances of these classes necessarily need not be so. Since the class tell
has the magic method __call__
, the instance telling
is callable. But the instance testing
instantiated from the class test
is not since the class does not have the magic method. Another set of examples.
Example 5: Non-callable instance of a class
In [1]: class new: ...: def foo(self): ...: print("Hello") In [2]: n = new() In [3]: n() ------------------ TypeError Traceback (most recent call last) in module() ----> 1 n() TypeError: 'new' object is not callable
Example 6: Callable instance of the same class
In [4]: class new: ...: def __call__(self): ...: print("I'm callable!") In [5]: n = new() In [6]: n Out[6]: __main__.new at 0x7f7a614b1f98 In [7]: n() I'm callable!
Example 5 and Example 6 shows how a class is itself callable, but unless it carries a __call__()
method, the instances spawned out of it are not so.