I have a long if-elif chain, like this:
class MyClass:
def my_func(self, item, value):
if item == "this":
self.do_this(value)
elif item == "that":
self.do_that(value)
# and so on
I find that difficult to read, so I prefer to use a dictionary:
class MyClass:
def my_func(self, item, value):
do_map = {
"this" : self.do_this,
"that" : self.do_that,
# and so on
}
if item in do_map:
do_map[item](value)
It's silly to recreate the map every time the function is called. How can I refactor this class so that the dictionary is only created once, for all instances? Can I somehow turn do_map
into a class member, yet still map to instance methods?
You have lots of options!
You could initialize the map in the __init__
method:
def __init__(self):
self.do_map = {"this": self.do_this, "that": self.do_that}
Now the methods are bound to self
, by virtue of having been looked up on the instance.
Or, you could use a string-and-getattr approach, this also ensures the methods are bound:
class Foo(object):
do_map = {"this": "do_this", "that": "do_that"}
def my_func(self, item, value):
if item in self.do_map:
getattr(self, self.do_map[item])(value)
Or you can manually bind functions in a class-level dictionary to your instance using the __get__
descriptor protocol method:
class Foo(object):
def do_this(self, value):
...
def do_that(self, value):
...
# at class creation time, the above functions are 'local' names
# so can be assigned to a dictionary, but remain unbound
do_map = {"this": do_this, "that": do_that}
def my_func(self, item, value):
if item in self.do_map:
# __get__ binds a function into a method
method = self.do_map[item].__get__(self, type(self))
method(value)
This is what self.method_name
does under the hood; look up the method_name
attribute on the class hierarchy and bind it into a method object.
Or, you could pass in self
manually:
class Foo(object):
def do_this(self, value):
...
def do_that(self, value):
...
# at class creation time, the above functions are 'local' names
# so can be assigned to a dictionary, but remain unbound
do_map = {"this": do_this, "that": do_that}
def my_func(self, item, value):
if item in self.do_map:
# unbound functions still accept self manually
self.do_map[item](self, value)
What you pick depends on how comfortable you feel with each option (developer time counts!), how often you need to do the lookup (once or twice per instance or are these dispatches done a lot per instance? Then perhaps put binding the methods in the __init__
method to cache the mapping up front), and on how dynamic this needs to be (do you subclass this a lot? Then don't hide the mapping in a method, that's not going to help).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With