Dynamically Change Self Binding

Question

In Javascript, bind, call, and apply allow you to change the reference to this on demand. I'm looking at a situation in Python where the code would look a bit nicer if I were able to do this instead of using getattr.

I'd like to pass a reference to a method, but change the instance the method refers to within a thread. In Javascript, I'd like to do this:

function produce (x) {
   enqueue(this.api.delete.bind(this.api, x))
}

function consume () { 
   api = new API()
   task = dequeue()
   task.call(api)
}

In Python, I have to do this:

def produce(self, x):
   enqueue(partial(self.api.delete, x))

def consume(self):
   api = API()
   task = dequeue() # callable
   ?????????

This may look a little odd, but what's going on is each api instance is running on a separate thread. getattr works, but I would prefer to pass verbs instead of nouns to the queue.

I might not completely get it, but what about `enqueue(lambda api: api.delete(x))`, and `dequeue()(api)`? — phipsgabler, Apr 27 '17 at 17:29
That totally works and is cleaner I think. Thank you! I'm curious if the other method I suggested is possible. — SapphireSun, Apr 27 '17 at 17:35
Probably, see my answer; but I don't know JS enough to translate your original. — phipsgabler, Apr 27 '17 at 17:45

score 2 · Accepted Answer · answered Apr 27 '17 at 17:45

You can enqueue a lambda closing over x and waiting for its api instance:

enqueue(lambda api: api.delete(x))

And later just pass the API object:

task = dequeue()
task(api)

You also can get an "unbound method reference" in Python 3, to which you can later pass self, by simply naming the class member:

>>> class A:
...    def foo(self, x):
...       print(x)
... 
>>> f = A.foo
>>> f(A(), 1)  # equivalent to A().foo(1)
1
>>> f
<function A.foo at 0x7f86c9b872f0>

(IIRC, it will behave the same in Python 2, but the type of f will be something special.)

score 2 · Answer 2 · answered Apr 27 '17 at 17:52

Related to (OK, basically identical to) phg's answer, the operator module provides a methodcaller function, which takes a method name (and optionally, arguments for that method) and returns a new callable which, when called with an object, invokes the named method on the object with the given arguments.

from operator import methodcaller

# methodcaller('foo', arg1)(thing) == thing.foo(arg1)

def produce(self, x):
   enqueue(methodcaller('delete', x))

def consume(self):
   api = API()
   task = dequeue() # callable
   task(api)

That looks a bit nicer, indeed. – phipsgabler Apr 27 '17 at 18:06 — phipsgabler, Apr 27 '17 at 18:06

Dynamically Change Self Binding

2 Answers2