Is it possible to override a class' __call__ method?

Question

I need to change the behavior of the __call__ method of a given object. The naive approach would be something like:

class A(object):
    def __call__(self):
        return 1

def new_call():
    return 42


a = A()
a.__call__ = new_call

Why is it not the output of a() 42? Is there a workaround I can exploit to achieve the same effect? (without using the class)

---

============================ EDIT =================================

For the records, the short answer is no. Python calls the "special methods" like __call_ directly on the class and not on the instance, therefore if you need to change the method, you need to change it on the class itself.

Answer 1

Special methods (aka "dunder" methods) are looked-up with respect to the class of the object, so to override it you would need to change the class, not the instance. Also note that methods all have an initial argument passed to them, usually called self.

The following would do what you want (notice how that it affects all instances of the class):

class A(object):
    def __call__(self):
        return 1

def new_call(self):
    return 42


a1 = A()
a2 = A()
A.__call__ = new_call

print(a1())  # -> 42
print(a2())  # -> 42

If you only want to change a specific instance, a relatively simple workaround is to make the class' __call_() method call one that's not "special" like it is — i.e. by introducing a level of indirection.

Here's what I mean:

# Workaround

class B(object):
    def __call__(self):
        return self.call_method(self)

    @staticmethod
    def call_method(self):
        return 1

def new_call(self):
    return 42

# Create two instances for testing.
b1 = B()
b2 = B()
b2.call_method = new_call  # Will only affect this instance.

print(b1())  # -> 1
print(b2())  # -> 42

Answer 2

Typically, special method names, such as __call__, are accessed via the object's type, rather than the instance's attribute collection. From Special Method Names:

If a class defines a method named __getitem__(), and x is an instance of this class, then x[i] is roughly equivalent to type(x).__getitem__(x, i).

This also applies to __call__. a() is roughly equivalent to type(a).__call__(a). Changing a's __call__ attribute doesn't have an effect, because the code is looking for A's __call__ attribute.

Assigning a new function to A.__call__ should do what you want.

class A(object):
    def __call__(self):
        return 1

def new_call(self):
    return 42


a = A()
A.__call__ = new_call
print(a())

Result:

42

Answer 3

Because A.__call__ is resolved before a.__call__. If you want to bind __call__ per instance, then you have to change the resolution by attempting to resolve it from there. E.g.

class A(object):
    def __call__(self):
        try:
            return vars(self)['__call__']()
        except KeyError:
            return 1

def new_call():
    return 42


a = A()

print(a())
a.__call__ = new_call
print(a())

Would prints:

1
42

If you want it to be a method, and have access to self, then you have to bind it. E.g.

from types import MethodType

class A(object):
    def __call__(self):
        try:
            return vars(self)['__call__']()
        except KeyError:
            return 1

def new_call_method(self):
    return self

a = A()
a.__call__ = MethodType(new_call_method, a)
also_a = a()

Would return a.