如何将使用实例变量的实例方法作为另一个函数的参数传递？

Question

I want to pass a method foo of an instance of a class A to another function run_function . The method foo will use instance variables of its class A .

Here is a minimal example, in which the instance variable of A is simply self.a_var , and foo just prints that variable.

class A:
    def __init__(self,a_var):
        self.a_var=a_var
    def foo(self):
        print(self.a_var)


class B:
    def __init__(self, A):
        self.A=A

        # EDIT (comment to compile)
        self.A.do_something()

    def run_function(self):
        self.A.foo()
    def run_function_2(self, bar):
        bar()



myA = A(42)
myA.foo()

# Current implementation
myB=B(myA)
myB.run_function()

# Better(?) implementation
myB.run_function_2(myA.foo)

At the moment I pass the instance myA of class A to the instance of B and explicitly call self.A.foo() . This forces the name of the function of A to be foo . Which is stupid.

The better (?) implementation passes the function of the instance to run_function2 . This works, but I am not sure if this is "safe".

Question:

Are there any loopholes that I don't see at the moment?

The important part is, that the method foo , that is passed, needs to access instance variables of the (its) class instance. So, will foo that is called inside run_function_2 always have access to all instance variables of myA ?

Is there a better way to implement this?

EDIT: I forgot to add, that class B will always have an instance of A , since it has to do_something with that instance. Maybe that will change something(?). Sorry!

Answer 1

To answer your questions:

1. Any function executed in the context of an object instance will have access to the instance variables.
2. There may be a better way to implement this, you could try defining an interface for class A and other classes that might be like it. The you know that the function will always be called foo(). If not, I'd question why it is you need to have some object call an arbitrary method on another object. If you can give more concrete examples about what you're trying to do it would help.

Answer 2

For your second implementation, have you considered the following:

>>> myAa = A(42)
>>> myAb = A(43)
>>> myB = B(myAb)
>>> myB.run_function_2(myAa.foo)
42

This might not be what you want. How about using getattr() and just passing in the desired method name:

>>> class C:
...     def __init__(self, A):
...             self.A = A
...     def run_fct(self, bar):
...             fct = getattr(self.A, bar)
...             fct()
... 
>>> myC = C(myAa)
>>> myC.run_fct('foo')
42

Answer 3

The main difference between run_function and run_function_2 is that the former calls foo on the object that was given to the B() constructor. run_function_2 is independent of what object is saved as self.A ; it just calls the function/method you give it. For example

class A:
    def __init__(self,a_var):
        self.a_var=a_var
    def foo(self):
        print(self.a_var)


class B:
    def __init__(self, A):
        self.A=A
    def run_function(self):
        self.A.foo()
    def run_function_2(self, bar):
        bar()

myA = A(42)
myB = B(myA)
myA2 = A(3.14)

myB.run_function()
myB.run_function_2(myA.foo)
myB.run_function_2(myA2.foo)

Output

42
42
3.14

Are there any loopholes that I don't see at the moment?

These two ways of calling methods are fine. Though I agree that function_run_2 is more convenient since it doesn't fix the method name, it makes you ask... what's the purpose of giving an A object to the B constructor in the first place if it's never used?

The important part is, that the method foo, that is passed, needs to access instance variables of the (its) class instance. So, will foo that is called inside run_function_2 always have access to all instance variables of myA?

Yes. run_function_2 arguments requires a function. In this case, you pass myA.foo , an object myA 's method defined in class A . When you call foo inside run_function_2 , you are only dealing with attributes variables of the instance myA ; this is the idea of encapsulation in classes.

Is there a better way to implement this?

Answering also your question on safety, it's perfectly safe. Functions and methods are objects in Python, and they can be passed around like values. You're basically leaning on the idea of function currying or partial functions. See How do I pass a method as a parameter in Python . These two ways are fine.