Python: отзыв кэшированного результата функции, зависящего от нового параметра функции

С Python3. 2 или новее, вы можете использовать functools.lru_cache. Если вы должны были украсить total с functools.lru_cache непосредственно, то lru_cache будет кэшировать возвращаемые значения total на основе значения обоих аргументов, self и x. Поскольку внутренний dict lru_cache хранит ссылку на self, применение @lru_cache непосредственно к методу класса создает циклическую ссылку на self, которая делает экземпляры класса неотразимыми (следовательно, утечка памяти).

Вот обходной путь , который позволяет использовать lru_cache с методами класса - он кэширует результаты, основанные на всех аргументах, кроме первого, self, и использует weakref , чтобы избежать проблемы циклической ссылки:

import functools
import weakref

def memoized_method(*lru_args, **lru_kwargs):
    """
    https://stackoverflow.com/a/33672499/190597 (orly)
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapped_func(self, *args, **kwargs):
            # We're storing the wrapped method inside the instance. If we had
            # a strong reference to self the instance would never die.
            self_weak = weakref.ref(self)
            @functools.wraps(func)
            @functools.lru_cache(*lru_args, **lru_kwargs)
            def cached_method(*args, **kwargs):
                return func(self_weak(), *args, **kwargs)
            setattr(self, func.__name__, cached_method)
            return cached_method(*args, **kwargs)
        return wrapped_func
    return decorator


class MyObject(object):

    def __init__(self, a, b):
        self.a, self.b = a, b

    @memoized_method()
    def total(self, x):
        print('Calling total (x={})'.format(x))
        return (self.a + self.b) * x


    def subtotal(self, y, z):
        return self.total(x=y) + z 

mobj = MyObject(1,2)
mobj.subtotal(10, 20)
mobj.subtotal(10, 30)

Отпечатки

Calling total (x=10)

Только один раз.

---

В качестве альтернативы, это то, как вы можете свернуть свой собственный кэш, используя дикт:

class MyObject(object):

    def __init__(self, a, b):
        self.a, self.b = a, b
        self._total = dict()

    def total(self, x):
        print('Calling total (x={})'.format(x))
        self._total[x] = t = (self.a + self.b) * x
        return t

    def subtotal(self, y, z):
        t = self._total[y] if y in self._total else self.total(y)
        return t + z 

mobj = MyObject(1,2)
mobj.subtotal(10, 20)
mobj.subtotal(10, 30)

Одно из преимуществ lru_cache над этим кэшем на основе dict состоит в том, что lru_cache является потокобезопасным. lru_cache также имеет параметр maxsize, который может помощь защита от роста использования памяти без привязки (например, из-за длительный процесс, вызывающий total много раз с различными значениями x).

В этом случае я бы сделал что-то простое, возможно, не самый элегантный способ, но работает для Проблемы:

class MyObject(object):
    param_values = {}
    def __init__(self, a, b):
        self.a, self.b = a, b

    def total(self, x):
        if x not in MyObject.param_values:
          MyObject.param_values[x] = (self.a + self.b) * x
          print(str(x) + " was never called before")
        return MyObject.param_values[x]

    def subtotal(self, y, z):
        if y in MyObject.param_values:
          return MyObject.param_values[y] + z
        else:
          return self.total(y) + z