Core Python Programming (2nd Edition)

>>> c.foo # bound method object
>> c # instance foo()'s bound to
14.1.3. Classes
The callable property of classes allows instances to be created. "Invoking" a class has the effect of
creating an instance, better known as instantiation. Classes have default constructors that perform no
action, basically consisting of a pass statement. The programmer may choose to customize the
instantiation process by implementing an __init__() method. Any arguments to an instantiation call are
passed on to the constructor:
>>> class C(object):
def__init__(self, *args):
print'Instantiated with these arguments:\n', args
>>> c1 = C() # invoking class to instantiate c1
Instantiated with these arguments:
()
>>> c2 = C('The number of the counting shall be', 3)
Instantiated with these arguments:
('The number of the counting shall be', 3)
We are already familiar with the instantiation process and how it is accomplished, so we will keep this
section brief. What is new, however, is how to make instances callable.
14.1.4. Class Instances
Python provides the __call__() special method for classes, which allows a programmer to create objects
(instances) that are callable. By default, the __call__() method is not implemented, meaning that most
instances are not callable. However, if this method is overridden in a class definition, instances of such a
class are made callable. Calling such instance objects is equivalent to invoking the __call__() method.
Naturally, any arguments given in the instance call are passed as arguments to __call__().
You also have to keep in mind that __call__() is still a method, so the instance object itself is passed in
as the first argument to __call__() as self. In other words, if foo is an instance, then foo() has the
same effect as foo.__call__(foo)the occurrence of foo as an argumentsimply the reference to self that
is automatically part of every method call. If __call__() has arguments, i.e., __call__(self,arg), then
foo(arg) is the same as invoking foo.__call__(foo,arg). Here we present an example of a callable
instance, using a similar example as in the previous section:
>>> class C(object):
... def __call__(self, *args):
... print "I'm callable! Called with args:\n", args
...
>>> c = C() # instantiation
>>> c # our instance