Python: passing functions as arguments to initialize the methods of an object. Pythonic or not?

Question

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*b class FooBar(object): def __init__(self, func): self.func = func foobar = 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*b class FooBar1(object): def __init__(self, func, a): self.a=a self.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 s…

Accepted Answer

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 weakref

class WeakMethod:
    def __init__(self, func, instance):
        self.func = func
        self.instance_ref = weakref.ref(instance)

self.__wrapped__ = func  # this makes things like `inspect.signature` work

def __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 = a
        self.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)`

Python: passing functions as arguments to initialize the methods of an object. Pythonic or not?

Solution

Problem

Related problems