Что можно сделать, чтобы ускорить оформление памятки?

Question

Что мне нужно, так это декоратор памятки, который:

• может запоминать методы экземпляра как с аргументами, так и с аргументами ключевых слов
• имеет кэш, который можно очистить (глобально) одним вызовом(в отличие от того, который использует кэш для каждой функции: декомпозер с пометкой для сбрасываемого метода экземпляра Python )
• достаточно эффективен

Я настроил примерЯ увидел и придумал следующее:

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 = {}

Моя проблема с этим заключается в том, что часть кэширования, похоже, связана с большими издержками (например, для рекурсивных функций).Используя в качестве примера следующую функцию, я могу вызывать fib (30) десять раз с незафиксированной версией за меньшее время, чем с записанной версией.

def fib(n):

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

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

Спасибо.

PS Использование python 2.7

Answer 1

Вы фактически не кэшируете никаких данных, потому что каждый раз, когда вы устанавливаете новое кэшированное значение, вы перезаписываете предыдущее:

Memoized.__cache[self.key] = {args : value}

например.

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__)
        self.cache[self.key] = {}

    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 = {}

• fib(30) без кэширования: 2.86742401123
• fib (30) с кэшированием: 0.000198125839233

Некоторые другие примечания:

• Не использовать __prefix;здесь нет никаких причин, и это только ухудшает код.
• Вместо того, чтобы использовать один монолитный диктант класса-атрибута, присвойте каждому экземпляру Memoized свой собственный dict и ведите реестр Memoizedобъекты.Это улучшает инкапсуляцию и устраняет странность зависимости от имени модуля и функции.

.

import functools
import weakref

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.

    >>> counter = 0
    >>> @Memoized
    ... def count():
    ...     global counter
    ...     counter += 1
    ...     return counter

    >>> counter = 0
    >>> Memoized.reset()
    >>> count()
    1
    >>> count()
    1
    >>> Memoized.reset()
    >>> count()
    2

    >>> class test(object):
    ...     @Memoized
    ...     def func(self):
    ...         global counter
    ...         counter += 1
    ...         return counter
    >>> testobject = test()
    >>> counter = 0
    >>> testobject.func()
    1
    >>> testobject.func()
    1
    >>> Memoized.reset()
    >>> testobject.func()
    2
    """

    caches = weakref.WeakSet()

    def __init__(self, func):
        self.func = func
        self.cache = {}
        Memoized.caches.add(self)

    def __call__(self, *args):
      try:
          return self.cache[args]
      except KeyError:
          value = self.func(*args)
          self.cache[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():
        for memo in Memoized.caches:
            memo.cache = {}

if __name__ == '__main__':
    import doctest
    doctest.testmod()

Отредактировано: добавьте тесты и используйте weakref.WeakSet.Обратите внимание, что WeakSet доступен только в 2.7 (который использует OP);для версии, которая работает в 2.6, см. историю редактирования.

Answer 2

Вот версия, которая значительно быстрее. К сожалению, reset больше не может полностью очистить кеш, поскольку все экземпляры хранят свою собственную локальную копию ссылки на словарь для каждой функции. Хотя вы можете заставить его работать:

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
    key = (func.__module__, func.__name__)
    if key not in self.__cache:
      self.__cache[key] = {}
    self.mycache = self.__cache[key]

  def __call__(self, *args):
    try:
      return self.mycache[args]
    except KeyError:
      value = self.func(*args)
      self.mycache[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)

  @classmethod
  def reset(cls):
    for v in cls.__cache.itervalues():
      v.clear()