Uellue's Blog

Python attribute caching with low overhead

For my work I need to do various lengthy numerical calculations on large datasets with results that do not change. The program is interactive, which means I do not know in advance which calculations on which data I need to perform. The results of the calculations depend completely on the dataset, there are no additional parameters. One can implement such a thing with a cache and corresponding code that checks if the result is in the cache before doing the calculation. I developed a generic technique to cache the results in such a way that no function call is necessary at all if the result is cached. It works by dynamically generating and deleting object attributes. If the attribute is set, it is used. If it is not set, a corresponding function to calculate the attribute is called and the attribute is set. If the data changes, all designated attributes are unset and will be recalculated when they are accessed next time.

A class for lists demonstrates how it works:

#!/usr/bin/env python3
# works similarly with python 2.x, except different syntax in some points

# -*- coding: utf-8 -*-

class CachedList(object):
    # List of attributes that can be cached.
    # Use keys of a hash to quickly look up if an attribute is managed.
    # Leading underscores do not work due to the way attributes 
    # with two underscores are handled.
    # A method that calculates the result has to be defined for each of these attributes. 
    # It has the same name as the attribute plus a leading underscore: average -> _average(), ...
    _managed_attributes = {'average': 1, 'sum': 1, 'len': 1, 'exc': 1}
    def __init__(self, l):
        # copy the list
        self._list = list(l)
        self._exception_cache = {}
    # This method is called automatically if an undefined attribute is accessed.
    # If the attribute already exists, this method will not be called.
    def __getattr__(self, attr):
        # Avoid recalculating attributes that raised an exception.
        # Instead raise the cached exception.
        # Some of my calculations fail with an exception after a very long calculation,
        # so it makes sense to cache the exception.
        exception = self._exception_cache.get(attr)
        if exception is not None:
            raise exception
        if attr in self._managed_attributes:
            # Try to get and call a method that "makes" the entry
            f = getattr(self, '_'+attr)
                # Just some tracing code for the example
                print("calculate {0}".format(attr))
                result = f()
                setattr(self, attr, result)
            except Exception as e:
                # "remember" the exception
                self._exception_cache[attr] = e
            raise AttributeError('{0} object has no attribute {1}'.format(type(self), attr))
        # result has been set if this point is reached
        return result
    def append(self, x):
    def _invalidate_cache(self):
        # just some tracing
        print("empty cache")
        self._exception_cache = {}
        for a in self._managed_attributes.keys():
                delattr(self, a)
            except AttributeError:
    def _average(self):
        # Cached attributes can be used just like normal attributes
        return self.sum/self.len
    def _sum(self):
        return sum(self._list)
    def _len(self):
        return len(self._list)
    def _exc(self):
        raise Exception("Exception!")
# now test the code!    

l = range(10000000)
cl = CachedList(l)
# attribute is calculated and set
# attribute is used
# cache is cleared
# attribute is recalculated
# exceptions are also cached
except Exception as e:

except Exception as e:

user@host:~$ ./propertycache.py

calculate average
calculate sum
calculate len
empty cache
calculate average
calculate sum
calculate len
calculate exc