अजगर

Question

में एक 'स्थानीय स्थिर' चर का अनुकरण करने पर विचार करें निम्नलिखित कोड:

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

CalcSomething._cache = { } 

यह सबसे आसान तरीका है मैं अजगर में एक 'स्थानीय स्थिर' चर का अनुकरण के लिए के बारे में सोच सकते हैं।
मुझे क्या परेशान करती है कि CalcSomething._cache समारोह की परिभाषा के बाहर बताया गया है है, लेकिन वैकल्पिक ऐसा ही कुछ होगा: समारोह की परिभाषा, जो वास्तव में बोझिल है अंदर

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

।

क्या कोई और शानदार तरीका है?

[संपादित करें]
बस स्पष्ट करने के लिए, यह प्रश्न स्थानीय फ़ंक्शन कैश के बारे में नहीं है, जैसा उपरोक्त उदाहरण सुझाव दे सकता है। यहां एक और छोटा उदाहरण दिया गया है जहां 'स्थैतिक स्थानीय' आसान हो सकता है:

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

एक प्रतिदेय वस्तु में इसे चालू करें (के बाद से है कि क्या यह वास्तव में है।)

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() 

अब आप calcSomething उपयोग कर सकते हैं जैसे कि यह एक समारोह थे। लेकिन यह साफ और आत्मनिर्भर रहता है।

Answer 2

इसे एक सजावट में बदल दें।

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

डेकोरेटर कि कैश बनाए रखेंगे और अपने समारोह कैशिंग कोड से दूषित नहीं किया जाएगा लिखने पर विचार:

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) 

शायद यह पहली बार में बहुत अच्छी लग रही नहीं है, लेकिन आप cacheResults() कहीं भी आप उपयोग कर सकते हैं कीवर्ड पैरामीटर की आवश्यकता नहीं है। समान सजावट बनाना संभव है जो कीवर्ड पैराम्स के लिए भी काम करेगा, लेकिन इस बार यह आवश्यक नहीं था।

Answer 4

एक विकल्प डिफ़ॉल्ट मानकों का दुरुपयोग करना है। अर्थात्:

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

यह लाभ है कि आप नाम अर्हता प्राप्त करने की जरूरत नहीं है, और नहीं बल्कि दो धीमी dict लुकअप कर की तुलना में चर के लिए तेजी से स्थानीय पहुंच मिल जाएगी है। हालांकि यह अभी भी समस्या है कि फ़ंक्शन के बाहर इसका उल्लेख किया गया है (वास्तव में यह फ़ंक्शन हस्ताक्षर में अब से भी बदतर है।)

इसे रोकने के लिए, एक बेहतर समाधान फ़ंक्शन को अपनी स्थिरता वाले बंद करने के लिए लपेटना होगा :

@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

एसएलॉट द्वारा प्रस्तावित समाधान समाधान है जो मैं प्रस्तावित करता हूं।

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

कि सभी, मैं एक पर अपने प्रारंभिक प्रयास के लिए एक वैकल्पिक प्रदान कर रहा हूँ यह देखते हुए:

वहाँ उपयोगी "memoize" सज्जाकार के आसपास भी की तरह हैं, फ़ंक्शन और एक "स्थैतिक स्थानीय", जो स्टैंडअलोन है:

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