I'm wondering if there is an accepted way to pass functions as parameters to objects (i.e. to define methods of that object in the init block).

More specifically, how would one do this if the function depends on the objects parameters.

It seems pythonic enough to pass functions to objects, functions are objects like anything else:

def foo(a,b):return a*bclass FooBar(object):def __init__(self, func):self.func = funcfoobar = FooBar(foo)
foobar.func(5,6)# 30

So that works, the problem shows up as soon as you introduce dependence on the object's other properties.

def foo1(self, b):return self.a*bclass FooBar1(object):def __init__(self, func, a):self.a=aself.func=func# Now, if you try the following:
foobar1 = FooBar1(foo1,4)
foobar1.func(3)
# You'll get the following error:
# TypeError: foo0() missing 1 required positional argument: 'b'

This may simply violate some holy principles of OOP in python, in which case I'll just have to do something else, but it also seems like it might prove useful.

I've though of a few possible ways around this, and I'm wondering which (if any) is considered most acceptable.

Solution 1

foobar1.func(foobar1,3)# 12
# seems ugly

Solution 2

class FooBar2(object):def __init__(self, func, a):self.a=aself.func = lambda x: func(self, x)# Actually the same as the above but now the dirty inner-workings are hidden away. 
# This would not translate to functions with multiple arguments unless you do some ugly unpacking.
foobar2 = FooBar2(foo1, 7)
foobar2.func(3)# 21

Any ideas would be appreciated!

Passing functions to an object is fine. There's nothing wrong with that design.

If you want to turn that function into a bound method, though, you have to be a little careful. If you do something like self.func = lambda x: func(self, x), you create a reference cycle - self has a reference to self.func, and the lambda stored in self.func has a reference to self. Python's garbage collector does detect reference cycles and cleans them up eventually, but that can sometimes take a long time. I've had reference cycles in my code in the past, and those programs often used upwards of 500 MB memory because python would not garbage collect unneeded objects often enough.

The correct solution is to use the weakref module to create a weak reference to self, for example like this:

import weakrefclass WeakMethod:def __init__(self, func, instance):self.func = funcself.instance_ref = weakref.ref(instance)self.__wrapped__ = func  # this makes things like `inspect.signature` workdef __call__(self, *args, **kwargs):instance = self.instance_ref()return self.func(instance, *args, **kwargs)def __repr__(self):cls_name = type(self).__name__return '{}({!r}, {!r})'.format(cls_name, self.func, self.instance_ref())class FooBar(object):def __init__(self, func, a):self.a = aself.func = WeakMethod(func, self)f = FooBar(foo1, 7)
print(f.func(3))  # 21

All of the following solutions create a reference cycle and are therefore bad:

• self.func = MethodType(func, self)
• self.func = func.__get__(self, type(self))
• self.func = functools.partial(func, self)