Using lookup table for class method calls in python

Question

having a class

class MyClass:
    def func_a(self):
        """do a"""

    def func_b(self):
        """do b"""

and a mapping

mapping = {
    "A": lambda: Myclass.do_a,
    "B": lambda: Myclass.do_b
}

I would like to be able to do something like this:

thing = Myclass()

for i in ["A", "B"]:
    # call things appropriate method

So in the case of ["A", "B"] first call func_a on thing, and then func_b. How could I do that?

Thanks!

try `mapping[i].(thing)`, why does `func_a` not have a `self` — rioV8, Aug 24 '23 at 09:25
This is a very strange setup. Are you sure you want to do this? — roganjosh, Aug 24 '23 at 09:26
what is the point of the mapping and the lambdas? why not just `for method in [Myclass.do_a, Myclass.do_b]` ? — Anentropic, Aug 24 '23 at 09:32
You don't need the mapping at all: just use [getattr](https://docs.python.org/library/functions.html#getattr): `for i in ['func_a', 'func_b']: getattr(thing, i)()`. — ekhumoro, Aug 24 '23 at 09:52
In that case, store the method name in the mapping and do `getattr(thing, [mapping[i]])()`. This has the potential benefit of decoupling the mapping from the class object. — ekhumoro, Aug 25 '23 at 11:44

score 1 · Accepted Answer · answered Aug 24 '23 at 09:32

1

You don't need lambda for that

mapping = {
    "A": MyClass.func_a,
    "B": MyClass.func_b
}

thing = MyClass()

for i in ["A", "B"]:
    mapping[i](thing)

answered Aug 24 '23 at 09:32

Guy

46,488
10
44
88

score 0 · Answer 2 · answered Aug 24 '23 at 09:30

You're on the right track! To achieve what you're looking for, you can use the mapping you provided to dynamically call the methods of your MyClass instance. However, you need to make a couple of adjustments to your mapping and function calls.

Here's how you can do it:

class MyClass:
    def func_a(self):
        print("do a")

    def func_b(self):
        print("do b")

thing = MyClass()

mapping = {
    "A": lambda: thing.func_a(),
    "B": lambda: thing.func_b()
}

for i in ["A", "B"]:
    mapping[i]()  # Call the appropriate method based on the mapping

In this code, the lambda functions defined in the mapping call the corresponding methods on the thing instance of MyClass. The loop iterates over the list ["A", "B"], and for each item, it calls the corresponding lambda function, which in turn calls the appropriate method on the thing instance.

Using lookup table for class method calls in python

2 Answers2