Python functools lru_cache с методами класса: объект выпуска

Это не самое чистое решение, но оно полностью прозрачно для программиста:

import functools
import weakref

def memoized_method(*lru_args, **lru_kwargs):
    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

Он принимает те же параметры, что и lru_cache, и работает точно так же. Однако он никогда не передает self в lru_cache и вместо этого использует lru_cache для каждого экземпляра.

Я представлю methodtools для этого варианта использования.

pip install methodtools для установки https://pypi.org/project/methodtools/.

Тогда ваш код будет работать, просто заменив functools на methodtools.

from methodtools import lru_cache
class Foo:
    @lru_cache(maxsize=16)
    def cached_method(self, x):
        return x + 5

Конечно, тест gc тоже возвращает 0.

python 3.8 представил декоратор cached_property в модуле functools. при тестировании кажется, что экземпляры не сохраняются.

Если вы не хотите обновляться до Python 3.8, вы можете использовать исходный код. Все, что вам нужно, это импортировать RLock и создать объект _NOT_FOUND. имея в виду:

from threading import RLock

_NOT_FOUND = object()

class cached_property:
    # https://github.com/python/cpython/blob/v3.8.0/Lib/functools.py#L930
    ...

Простое упаковочное решение

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

import functools
import weakref

def weak_lru(maxsize=128, typed=False):
    'LRU Cache decorator that keeps a weak reference to "self"'
    def wrapper(func):

        @functools.lru_cache(maxsize, typed)
        def _func(_self, *args, **kwargs):
            return func(_self(), *args, **kwargs)

        @functools.wraps(func)
        def inner(self, *args, **kwargs):
            return _func(weakref.ref(self), *args, **kwargs)

        return inner

    return wrapper

Пример

Используйте это так:

class Weather:
    "Lookup weather information on a government website"

    def __init__(self, station_id):
        self.station_id = station_id

    @weak_lru(maxsize=10)
    def climate(self, category='average_temperature'):
        print('Simulating a slow method call!')
        return self.station_id + category

Когда это использовать

Поскольку weakrefs добавляет некоторые накладные расходы, вы можете использовать это только тогда, когда экземпляры большие, и приложение не может дождаться, когда старые неиспользуемые вызовы выйдут из кеша.

Почему это лучше

В отличие от другого ответа, у нас есть только один кеш для класса, а не один для каждого экземпляра. Это важно, если вы хотите получить пользу от наименее использованного алгоритма. Имея один кеш для каждого метода, вы можете установить maxsize так, чтобы общее использование памяти было ограничено независимо от количества активных экземпляров.

Работа с изменяемыми атрибутами

Если какие-либо атрибуты, используемые в методе, являются изменяемыми, обязательно добавьте _ eq _ () и _ hash _ ( ) методы:

class Weather:
    "Lookup weather information on a government website"

    def __init__(self, station_id):
        self.station_id = station_id

    def update_station(station_id):
        self.station_id = station_id

    def __eq__(self, other):
        return self.station_id == other.station_id

    def __hash__(self):
        return hash(self.station_id)

Еще более простое решение этой проблемы - объявить кеш в конструкторе, а не в определении класса:

from functools import lru_cache
import gc

class BigClass:
    pass
class Foo:
    def __init__(self):
        self.big = BigClass()
        self.cached_method = lru_cache(maxsize=16)(self.cached_method)
    def cached_method(self, x):
        return x + 5

def fun():
    foo = Foo()
    print(foo.cached_method(10))
    print(foo.cached_method(10)) # use cache
    return 'something'
    
if __name__ == '__main__':
    fun()
    gc.collect()  # collect garbage
    print(len([obj for obj in gc.get_objects() if isinstance(obj, Foo)]))  # is 0