except KeyError, everywhere

[Wilbert Berendsen]

Hi,

I find myself all over the place associating objects with each other using 
dicts as caches:

something like this:

_cache = {}

def get_something(obj):
    """Returns the frobnicate-plugin for the specified object."""
    try:
        return _cache[obj]
    except KeyError:
        res = _cache[obj] = LargeClass(obj)
        return res


I would like a dict that would do this by itself, so that I could write:

_cache = somelazydict(LargeClass)

def get_something(obj):
    """Returns the frobnicate-plugin for the specified object."""
    return _cache[obj]

or even using the dict directly:

plugin_store = somelazydict(LargeClass)

It seems that I can't use defaultdict for this, because it calls the factory 
function without an argument, where I need to have the key as argument.

So I came up with this (using the __missing__ dict hook since Python 2.5):

class cachedict(dict):
    """A dict, but with a factory function as the first argument.
    
    On lookup, if the key is missing, the function is called with the key as
    argument. The returned value is also stored in the dict.
    
    """
    def __init__(self, func, *args, **kwargs):
        """Creates the dict, with the factory function as the first argument.
        
        All other arguments work just like dict.
        
        """
        dict.__init__(self, *args, **kwargs)
        self.func = func
    
    def __missing__(self, key):
        res = self[key] = self.func(key)
        return res

Are there other peoply using things like this? Is there a solution like this 
in the standard lib that I'm overlooking? Of course 'except KeyError' 
everywhere is not really a big deal...

With best regards,
Wilbert Berendsen

-- 
http://www.wilbertberendsen.nl/
"You must be the change you wish to see in the world."
        -- Mahatma Gandhi