Mô phỏng một 'tĩnh địa phương' biến trong python

Question

Xét đoạn mã sau:

def CalcSomething(a): 
    if CalcSomething._cache.has_key(a): 
     return CalcSomething._cache[a] 
    CalcSomething._cache[a] = ReallyCalc(a) 
    return CalcSomething._cache[a] 

CalcSomething._cache = { } 

Đây là cách đơn giản nhất tôi có thể nghĩ ra để mô phỏng một 'tĩnh địa phương' biến trong python.
gì làm tôi bực mình là CalcSomething._cache được đề cập bên ngoài định nghĩa của chức năng, nhưng thay thế sẽ là một cái gì đó như thế:

if not hasattr(CalcSomething, "_cache"): 
    setattr(CalcSomething, "_cache", { }) 

bên trong định nghĩa của chức năng, đó là thực sự cồng kềnh.

Có cách nào thanh lịch hơn không?

[EDIT]
Chỉ cần làm rõ, câu hỏi này không phải về bộ đệm chức năng cục bộ, như ví dụ trên có thể đề xuất. Dưới đây là một ví dụ ngắn khác về một 'địa phương tĩnh' có thể hữu ích:

def ParseString(s): 
    return ParseString._parser.parse(s) 
# Create a Parser object once, which will be used for all parsings. 
# Assuming a Parser object is heave on resources, for the sake of this example. 
ParseString._parser = Parser() 

Answer 1

Biến nó thành một đối tượng có thể được gọi (vì đó là những gì nó thực sự là.)

class CalcSomething(object): 
    def __init__(self): 
     self._cache = {} 
    def __call__(self, a): 
     if a not in self._cache: 
      self._cache[a] = self.reallyCalc(a) 
     return self._cache[a] 
    def reallyCalc(self, a): 
     return # a real answer 
calcSomething = CalcSomething() 

Bây giờ bạn có thể sử dụng calcSomething như thể nó là một hàm. Nhưng nó vẫn gọn gàng và độc lập.

Answer 2

Biến nó thành trang trí.

def static_var(var_name, initial_value): 
    def _set_var(obj): 
     setattr(obj, var_name, initial_value) 
     return obj 
    return _set_var 

@static_var("_cache", {}) 
def CalcSomething(a): 
    ... 

Answer 3

Hãy xem xét văn bản trang trí mà sẽ duy trì bộ nhớ cache và chức năng của bạn sẽ không bị ô nhiễm bởi mã bộ nhớ đệm:

def cacheResults(aFunc): 
    '''This decorator funcion binds a map between the tuple of arguments 
     and results computed by aFunc for those arguments''' 
    def cachedFunc(*args): 
     if not hasattr(aFunc, '_cache'): 
      aFunc._cache = {} 
     if args in aFunc._cache: 
      return aFunc._cache[args] 
     newVal = aFunc(*args) 
     aFunc._cache[args] = newVal 
     return newVal 
    return cachedFunc 

@cacheResults 
def ReallyCalc(a): 
    '''This function does only actual computation''' 
    return pow(a, 42) 

Có lẽ nó không nhìn tuyệt vời lúc đầu, nhưng bạn có thể sử dụng bất cứ nơi nào bạn cacheResults() không cần tham số từ khóa. Nó có thể tạo ra trang trí tương tự mà sẽ làm việc cũng cho params từ khóa, nhưng điều đó dường như không cần thiết thời gian này.

Answer 4

Một tùy chọn là lạm dụng thông số mặc định. nghĩa là:

def CalcSomething(a, _cache={}): 
    if _cache.has_key(a): 

Điều này có lợi thế là bạn không cần phải đủ điều kiện tên và sẽ nhanh chóng truy cập vào các biến thay vì thực hiện hai lần tra cứu chậm. Tuy nhiên nó vẫn có vấn đề mà nó được đề cập bên ngoài chức năng (trên thực tế nó tồi tệ hơn kể từ bây giờ trong chữ ký chức năng.)

Để ngăn chặn điều này, một giải pháp tốt hơn là bao bọc chức năng trong bao đóng chứa số liệu thống kê của bạn :

@apply 
def CalcSomething(): 
    cache = {} # statics go here 

    def CalcSomething(a): 
     if cache.has_key(a): 
      return cache[a] 
     cache[a] = ReallyCalc(a) 
     return cache[a] 
    return CalcSomething 

Answer 5

Giải pháp được đề xuất bởi S.Lott là giải pháp tôi cũng đề xuất.

Có hữu ích "memoize" trang trí xung quanh, quá, như:

• Memoize decorator function with cache size limit
• Memoize decorator with O(1) length-limited LRU cache, supports mutable types

Với tất cả những gì, tôi đang cung cấp một thay thế cho nỗ lực ban đầu của bạn tại một và "địa phương tĩnh", độc lập:

def calc_something(a): 

    try: 
     return calc_something._cache[a] 
    except AttributeError: # _cache is not there 
     calc_something._cache= {} 
    except KeyError: # the result is not there 
     pass 

    # compute result here 

    calc_something._cache[a]= result 
    return result