Setting instance method systax

Question

The following code is of course totally pointless; it's not supposed to do anything but illustrate what I'm confused about:

class func():
  def __call__(self, x):
   raise Exception("func.__call__ error")

def double(x):
  return 2*x

doubler = func()
doubler.__call__ = double

print doubler(2)

Can someone explain why this works? I would have expected that if I wanted to set doubler.__call__ to something it would be a function that takes two variables; I'd expect the code above to raise some sort of too-many-parameters error. What gets passed to what, when?

(And then: How could I set doubler.__call__ to a function that will actually have access to both "self" and "x"?)

(Context: An admittedly silly of-academic-interest example of why I might want to set an instance method this way: Each computable instance needs its own Approx method; creating a separate subclass for each instance seems "wrong"...)

Edit. Probably a better example, making it clear it has nothing to do with magic-method magic:

class func():
  def call(self, x):
    raise Exception("func.call error")

def double(x):
  return 2*x
doubler = func()
doubler.call = double

print doubler.call(2)

On third thought, probably the following is the right way to do it. (i) Seems cleaner somehow, using the Python object model instead of tinkering with it (ii) even 24 hours ago with my then much cruder understanding I would have expected it to work; somehow in this version it simply seems to make sense to me that the function passed to the constructor should take only one variable (iii) it seems to work regardless of whether I inherit from object, which I think means it would also work in 3.0.

class func3(object):
  def __init__(self, f):
    self.f = f
  def __call__(self, x):
    return self.f(x)

def double(x):
  return 2.0*x

f3=func3(double)
print f3(2)

Answer 1

When you assign to doubler.__call__, you're binding an function to an instance attribute. This hides the class attribute of the same name that was created in the class statement.

Python's method binding only kicks in when you are looking up a class attribute via an instance. If the attribute's value is a descriptor (which functions are), then the descriptor's __get__ method gets called with appropriate parameters. For a function object, that binds the method to the instance (so self gets passed in automatically as the first argument).

Your first example wouldn't actually work in Python 3, only in Python 2. That's because in Python 2 you're creating an "old-style" class, which does all its method lookups on the instance. In new-style classes (which you can get in Python 2 by inheriting from object, or by default in Python 3), __special__ methods, when they're invoked by the interpreter (e.g. when you do doubler(2) to run doubler.__call__) are looked up only in the class, not in the instance's attributes. So your first example won't work with a new-style class, but the version that uses a normal method (call instead of __call__) would be fine.

Answer 2

This is something between an answer to the question and a continuation of the question. I was kindly referred to another thread where more or less the same question was answered. I didn't follow the answers in that thread very well, being ignorant of the things the people there are talking about, hence the Question: Is what I say below correct? (If yes then this is an answer to the question above; if no I'd appreciate someone explaining why not...)

(i) Since I assign a function to an instance of func instead of to the class, it is now an "instance method", as opposed to a "class method".

(ii) And that's why it's not passed the instance as the first parameter; that happens with class methods but not with instance methods...