Switch case like mapping of a dictionary (values = methods)

Question

As I'm fairly new python, I can't decide which of the following two solutions makes more sense, or maybe no sense at all.

Let's say my abstracted object class look like:

class SimpleData(object):

    def __init__(self, data):
        self.__data = data

    def __getData(self):
        return self.__data

    def __setData(self, data):
        self.__data = data

    data = property(__getData, __setData)

    @classmethod
    def create_new(cls, data):
        return cls(data)

Objects of this class, that I need frequently (having a 'predifined object payload'), I'd like to simply create by 'assigning' a preset_name to them. Using the preset_name I can create new copies of those specific objects, having that predefined payload, repeatedly.

I could use a dictionary:

class PresetDict(object):

    @classmethod
    def get_preset(cls, preset_name):
        return {
            'preset_111': SimpleData.create_new('111'),
            'preset_222': SimpleData.create_new('222'),
            'preset_333': SimpleData.create_new('333')
        }.get(preset_name, None)

or map methods, using getattr :

class PresetMethod(object):

   @classmethod
   def get_preset(cls, preset_name):
       return getattr(cls, preset_name, lambda: None)()

   @classmethod
   def preset_111(cls):
       return SimpleData.create_new('111')

   @classmethod
   def preset_222(cls):
       return SimpleData.create_new('222')

   @classmethod
   def preset_333(cls):
       return SimpleData.create_new('333')

Both solutions do basically the same:

print(PresetDict.get_preset("preset_111").data)
print(PresetDict.get_preset("preset_333").data)
print(PresetDict.get_preset("not present"))

print(PresetMethod.get_preset("preset_111").data)
print(PresetMethod.get_preset("preset_333").data)
print(PresetMethod.get_preset("not present"))

I strongly prefer the dictionary solution, as it is easier to 'read', extend and will be easier to maintain in the future, especially with a big list of presets.

Here's the BUT: Performace is of importance. Here, I have absolutely no insight, which of those two solutions will perform better, especially if the preset list grows. Especially the dictionary in PresetDict.get_preset looks 'dodgy' to me. Will it create only the SimpleData instance specified via 'preset_name' when called, or will it create all possible instances specified in the dictionary when PresetDict.get_preset is called, then return the instance specified via 'preset_name' and then discard all other instances.

Hope you can enlighten me on this matter. Maybe you know of possible improvements or even a better solution of what I'd like to achieve?

Thx in advance!

Answer 1

you're right, PresetDict.get_preset will create all three objects and then return one. You could just add a class variable to SimpleData that holds the dictionary so it is only created once, and the get_preset can return instances from that

class SimpleData(object):

    _presets = {
        'preset_111': SimpleData('111'),
        'preset_222': SimpleData('222'),
        'preset_333': SimpleData('333')
    }

    @classmethod
    def get_preset(cls, preset_name):
        return cls._presets.get(preset_name, None)

Note that this isn't really any more efficient, it will just make it easier to create commonly used classes.

Also see functools.lru_cache