To be honest, for me it looks as very strange pattern… If one wants to have static container with functions, there is Enums or classes.
It’s most useful when you’re using some data you already have as the dictionary key. A usecase i had for this was a binary file parser with 10 types of event markers. It was originally coded with if/elif, but performance was a pretty big consideration. Using the event markers as keys to a dictionary dispatch improved performance by about 15% and made the code significantly more readable.
I think a similar result might now be achievable with match statements
This is fun to play around and basically what Python does under the hood to implement classes. In Python2 it was even more obvious that classes are just fancy wrappers around a dict called, unsurprisingly, __dict__.
class Foo:
def __init__(self):
self.__dict__["instance_method"] = lambda: "instance_method"
self.__dict__["shadowed_class_method"] = lambda: "shadowed_class_method_from_instance"
Foo.__dict__["class_method"] = lambda cls: "class_method"
Foo.__dict__["shadowed_class_method"] = lambda cls: "shadowed_class_method_from_class"
f = Foo()
f.__dict__["dynamic_instance_method"] = lambda: "dynamic_instance_method"
print f.instance_method()
print f.dynamic_instance_method()
print f.class_method()
print f.shadowed_class_method()
OUTPUT:
instance_method
dynamic_instance_method
class_method
shadowed_class_method_from_instance
Note: this won’t work in Python3 because the class.__dict__ becomes immutable at some point after declaring it, but the attribute name resolution stays the same. And it gets more interesting once you throw inheritance into the mix.
