在Python中使用兩個參數緩存函數的結果

Question

我有一個方法，它有兩個參數來執行一些複雜的計算。它經常以相同的參數被調用，所以我使用字典進行緩存。目前，這看起來是這樣的：

def foo(self, a, b): 
    params = frozenset([a, b]) 
    if not params in self._cache: 
     self._cache[params] = self._calculate(a, b) 
    return self._cache[params] 

之所以建立frozenset是該參數可以按任意順序排列，但結果是一樣的。我想知道是否有更簡單的（也是最重要的更高效）解決方案。

Answer 1

您的代碼有兩個問題：

（1）使用舊dict.has_key（）方法，該方法是緩慢的，已經消失在Python 3.x的而是使用「鍵入字典」或「鍵不在字典中」。

所以：

def foo(self, a, b): 
    params = frozenset([a, b]) 
    if params in self._cache: 
     self._cache[params] = self._calculate(a, b) 
    return self._cache[params] 

（2）「在字典鍵」是更具可讀性，且暴露出太多糟糕的問題：你的代碼不能正常工作！如果參數在字典中，則重新計算。如果他們不在字典中，它將炸燬一個KeyError。考慮複製/粘貼而不是從內存中打字。

所以：

def foo(self, a, b): 
    params = frozenset([a, b]) 
    if params not in self._cache: 
     self._cache[params] = self._calculate(a, b) 
    return self._cache[params] 

（3）一些更效率的建議：

def foo(self, a, b): 
    if a < b: 
     params = (a, b) 
    else: 
     params = (b, a) 
    try: 
     return self._cache[params] 
    except KeyError: 
     v = self._cache[params] = self._calculate(a, b) 
     return v 

Answer 2

您可以將這兩個值合併爲一個散列值，如str（a）+'\ 0'+ str（b），然後將其放入緩存中，也可以製作二維數組，以便緩存[a] [b]返回你想要的值。

您可能還想將此功能轉換爲@decorator類型的函數，然後您可以在多個函數上重複使用裝飾器，併爲緩存維護一個代碼位置。

Answer 3

我只是將它存儲在緩存中兩次，每次訂購一次。

def foo(self, a, b): 
    try: 
     return self._cache[(a, b)] 
    except KeyError: 
     value = self._calculate(a, b) 
     self._cache[(a, b)] = self._cache[(b, a)] = value 
     return value 

Answer 4

你可以使用beaker.cache爲（http://beaker.groovie.org/index.html）

# define a cache manager 
cache = CacheManager(dict_of_config_options) 

# in your class, apply a cache decorator 
@cache.cache('mycache') 
def foo(self, a,b): 
    return self._calculate 

我覺得它就像你想用默認值。不知道這是否使用自我作爲關鍵的一部分。它假設a，b是pickleable。

Answer 5

關於如何實現緩存，沒有什麼特別低效或複雜的;這基本上是需要發生的事情。但是，這並不是很通常的。

爲方便起見，您可以實現某種更廣義的緩存策略，如果喜歡，可以使用裝飾器。一個可行的方法可能是：

class Memoizer(object): 
    def __init__(self): 
     self._cache = dict() 

    def memoize_unordered(self, f): 
     def wrapper(s, *args, **kwargs): 
      key = (s, f, frozenset(args), frozenset(kwargs.iteritems())) 
      if key not in self._cache: 
       print 'calculating', args, kwargs 
       self._cache[key] = f(s, *args, **kwargs) 
      return self._cache[key] 
     return wrapper 

    def memoize_ordered(self, f): 
     def wrapper(s, *args, **kwargs): 
      key = (s, f, tuple(args), frozenset(kwargs.iteritems())) 
      if key not in self._cache: 
       print 'calculating', args, kwargs 
       self._cache[key] = f(s, *args, **kwargs) 
      return self._cache[key] 
     return wrapper 

memoizer = Memoizer() 

class Foo(object): 

    @memoizer.memoize_unordered 
    def foo(self, a, b): 
     return self._calculate(a, b) 

    def _calculate(self, a, b): 
     return frozenset([a,b]) 

foo = Foo() 


results = [foo.foo(*a) for a in [(1, 5), (1, 5), (5, 1), (9, 12), (12, 9)]] 
for result in results: 
    print 'RESULT', result 

印刷：

calculating (1, 5) {} 
calculating (9, 12) {} 
RESULT frozenset([1, 5]) 
RESULT frozenset([1, 5]) 
RESULT frozenset([1, 5]) 
RESULT frozenset([9, 12]) 
RESULT frozenset([9, 12]) 

當然缺點，你的對象之外實現緩存，就是當你的對象消失緩存中的數據沒有被刪除，除非你謹慎地做到這一點。