Имитация локальной статической переменной в Python

Превратите его в декоратора.

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):
    ...

Подумайте о написании декоратора, который будет поддерживать кеш, и ваша функция не будет испорчена кеширующим кодом:

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() везде, где вам не нужны параметры ключевого слова. Можно создать аналогичный декоратор, который работал бы также для параметров ключевого слова, но на этот раз это не казалось необходимым.

Превратите его в вызываемый объект (так как он есть на самом деле).

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 как функцию. Но он остается аккуратным и автономным.

Один из вариантов - злоупотребить параметрами по умолчанию. то есть:

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

Решение, предложенное С.Лоттом, - это решение, которое я бы тоже предложил.

Также есть полезные "мемоизирующие" декораторы, например:

• Функция декоратора Memoize с ограничением размера кеша
• Декоратор Memoize с кешем LRU с ограничением длины O (1), поддерживает изменяемые типы

Учитывая все это, я предлагаю альтернативу для вашей первоначальной попытки использования функции и «статический локальный», который является автономным:

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