Lo que quiero es un decorador de memoria que:

puede memorizar métodos de instancia con argumentos y argumentos de palabras clavetiene un caché que se puede borrar (globalmente) con una llamada (frente a esta que usa un caché por función:decorador de memoria de método de instancia reiniciable de Python)es razonablemente eficiente

He modificado un ejemplo que vi y se me ocurrió lo siguiente:

import functools

class Memoized(object):
  """Decorator that caches a function's return value each time it is called.
  If called later with the same arguments, the cached value is returned, and
  not re-evaluated.
  """

  __cache = {}

  def __init__(self, func):
    self.func = func
    self.key = (func.__module__, func.__name__)

  def __call__(self, *args):
    try:
      return Memoized.__cache[self.key][args]
    except KeyError:
      value = self.func(*args)
      Memoized.__cache[self.key] = {args : value}
      return value
    except TypeError:
      # uncachable -- for instance, passing a list as an argument.
      # Better to not cache than to blow up entirely.
      return self.func(*args)

  def __get__(self, obj, objtype):
    """Support instance methods."""
    return functools.partial(self.__call__, obj)

  @staticmethod
  def reset():
    Memoized.__cache = {}

Mi problema con esto es que la parte de almacenamiento en caché parece implicar mucha sobrecarga (por ejemplo, para funciones recursivas). Usando la siguiente función como ejemplo, puedo llamar a fib (30) diez veces con la versión no memorizada en menos tiempo que la versión memorizada.

def fib(n):

   if n in (0, 1):
      return n
   return fib(n-1) + fib(n-2)

¿Alguien puede sugerir una mejor manera de escribir este decorador? (o señalarme un decorador mejor (es decir, más rápido) que haga lo que quiero). No me interesa preservar las firmas de métodos ni ayudar a las herramientas de introspección a "saber" nada sobre la función decorada.

Gracias.

PD Usando Python 2.7