интернируя неизменные объекты

Question

У меня есть программа с объектом формы

class MyObj(object): 
    def __init__(self, a, b): 
     self.__a = a 
     self.__b = b 
     self.cache = very_expensive_computation(a, b) 

a,b, где неизменен и пространством возможных параметров a,b очень малы. Эти объекты создаются и выходят за рамки постоянно во время выполнения программы, поэтому неудивительно много времени потрачено на пересчет self.cache для тех же значений a,b. Поскольку very_expensive_computation стоит очень дорого, кажется, было бы лучше просто избегать сбора мусора этих элементов и, если возможно, конструктора возвращать ссылки на уже существующие объекты, вроде как интернирование строк.

Очевидный способ сделать это мне кажется, чтобы добавить словарь в класс и переопределить __new__ и __init__ так, что они проверяют словарь и возвращать уже существующие экземпляры, если это возможно, но в то же время это чувствует своего рода неудовлетворительно так как это нужно было бы сделать для каждого класса отдельно, и с момента обнаружения того, являетесь ли вы фактическим новым объектом в __init__, вероятно, будет довольно хаки.

Любые другие предложения?

Answer 1

Я memoize very_expensive_computation хранения результатов в кэш LRU, чтобы гарантировать верхний предел на количество используемой памяти:

_very_expensive_computation_cache = RecentlyUsedContainer(100) 

def cached_very_expensive_computation(a, b): 
    if (a, b) not in _very_expensive_computation_cache: 
     _very_expensive_computation_cache[(a, b)] = very_expensive_computation(a, b) 
    return _very_expensive_computation_cache[(a, b)] 

Где RecentlyUsedContainer может быть такой: https://github.com/shazow/unstdlib.py/blob/master/unstdlib/standard/collections_.py#L12

Вы может также упростить код с декоратора:

from unstdlib.standard.functools_ import memoized 

@memoized(cache=RecentlyUsedContainer(100)) 
def cached_very_expensive_comptuation(a, b): 
    return very_expensive_computation(a, b) 

См: https://github.com/shazow/unstdlib.py/blob/master/unstdlib/standard/functools_.py#L59

Я предпочитаю хранить сохраненные в памяти версии функций отдельно от «реальных» версий, поэтому вызывающие могут явно видеть, что они могут получать кешированный результат, и это может облегчить тестирование. Это, в основном, личное предпочтение.

Редактировать: как указано в комментариях, Python 3 поставляется с functools.lru_cache.

Answer 2

Вы также можете сделать это с переменным класса и экземпляра:

class BaseMyObj(object): 
    result_store = {} 

class MyObj(BaseMyObj): 
    def __init__(self, a, b): 
     self.__a = a 
     self.__b = b 
     try: 
      self.cache = BaseMyObj.result_store[(a,b)] 
     except KeyError: 
      self.cache = very_expensive_computation(a, b) 
      BaseMyObj.result_store[(a,b)] = self.cache 

def very_expensive_computation(a, b): 
    print('did calc') 
    return a+b 

item = MyObj(2, 9) 
>did calc 

item2 = MyObj(2, 9) 

item3 = MyObj(1, 4) 
>did calc