Python: декоратор статических переменных

Вот декоратор, который, кажется, работает. Обратите внимание, что для этого требуется вернуть locals() в конце функции из-за невозможности установить локальные значения извне (у меня нет большого опыта программирования, поэтому, если есть способ, я его не знаю).

class Static(object):
    def __init__(self, **kwargs):
        self.kwargs = kwargs

    def __call__(self, f):
        def wrapped_f():
            try:
                new_kwargs = {}
                for key in self.kwargs:
                    i = getattr(f, key)
                    new_kwargs[key] = i
                self.kwargs = new_kwargs
            except:
                pass
            for key, value in f(**self.kwargs).items():
                setattr(f, key, value)
        return wrapped_f

@Static(x=0, y=5, z='...')
def f(x, y, z):
    x += 1
    y += 5
    print x, y, z
    return locals()

Результат будет:

>>> f()
1 10 ...
>>> f()
2 15 ...
>>> f()
3 20 ...

РЕДАКТИРОВАТЬ:

Я нашел кое-что на http://code.activestate.com/recipes/410698/ и решил попробовать добавить его к этому. Теперь работает без возврата.

РЕДАКТИРОВАТЬ снова: изменено на, чтобы сделать его на несколько секунд быстрее. Редактировать 3; изменено на функцию вместо класса

def static(**kwargs):
    def wrap_f(function):
        def probeFunc(frame, event, arg):
            if event == 'call':
                frame.f_locals.update(kwargs)
                frame.f_globals.update(kwargs)
            elif event == 'return':
                for key in kwargs:
                    kwargs[key] = frame.f_locals[key]
                sys.settrace(None)
            return probeFunc
        def traced():
            sys.settrace(probeFunc)
            function()
        return traced
    return wrap_f

проверено:

@static(x=1)
def f():
    x += 1

global_x = 1
def test_non_static():
    global global_x
    global_x += 1


print 'Timeit static function: %s' % timeit.timeit(f)
print 'Timeit global variable: %s' % timeit.timeit(test_non_static)

выход:

Timeit static function: 5.10412869535
Timeit global variable: 0.242917510783

Использование settrace значительно замедляет его.

К тому времени, когда ваш декоратор получит объект функции f, он уже будет скомпилирован — в частности, он был скомпилирован с учетом того, что x является локальным (поскольку он назначается с присваиванием +=), обычная оптимизация (в 2.* вы можете отменить оптимизацию , по ошеломляющей цене производительности, начиная f с exec ''; в 2.* оптимизацию не победить). По сути, чтобы использовать желаемый синтаксис, вы должны перекомпилировать f (путем восстановления его исходных кодов, если вы знаете, что они будут доступны во время выполнения, или, что гораздо сложнее, с помощью взлома байт-кода) с каким-либо измененным исходным кодом — как только вы Если мы решили пойти по этому пути, самый простой способ, вероятно, состоит в том, чтобы изменить x на f.x во всем теле f.

Лично, если и когда я обнаруживаю, что так сильно борюсь с языком (или другой технологией), что пытаюсь подчиниться своей воле, чтобы навязать свои желания, я признаю, что либо использую неправильный язык (или другую технологию) , если эти желания абсолютно необходимы, то решение должно заключаться в изменении технологии; или, если эти желания не так важны, откажитесь от них.

В любом случае, я отказываюсь от попыток исказить язык слишком далеко от его очевидных дизайнерских намерений: даже если бы я придумал какой-нибудь хакерский, хрупкий кладж, его, несомненно, было бы невозможно поддерживать. В этом случае намерения Python очень ясны: bar-имена, которые повторно связываются внутри функций, являются локальными для этой функции, если только они явно не обозначены как глобальные — и точка. Таким образом, ваша попытка заставить barenames (которые перепривязываются внутри функции) означать что-то совершенно иное, чем «местные жители», — это именно такая борьба.

Редактировать: если вы готовы отказаться от настойчивого использования barnames для своей «статики», то внезапно вы больше не боретесь с Python, а скорее «в соответствии с зерном» языка (несмотря на сбой дизайна global [и nonlocal], но это отдельная тирада ;-). Так, например:

class _StaticStuff(object):
  _static_stack = []
  def push(self, d):
    self._static_stack.append(d)
  def pop(self):
    self._static_stack.pop()
  def __getattr__(self, n):
    return self._static_stack[-1][n]
  def __setattr__(self, n, v):
    self._static_stack[-1][n] = v
import __builtin__
__builtin__.static = _StaticStuff()

def with_static(**variables):
  def dowrap(f):
    def wrapper(*a, **k):
      static.push(variables)
      try: return f(*a, **k)
      finally: static.pop()
    return wrapper
  return dowrap

@with_static(x=0)
def f():
    static.x += 1
    print static.x

f()
f()

Это работает так, как вы хотите, печатая 1, а затем 2. (Я использую __builtin__, чтобы упростить использование with_static для оформления функций, живущих в любом модуле, конечно). У вас может быть несколько разных реализаций, но ключевым моментом любой хорошей реализации является то, что "статические переменные" будут полными именами, а не пустыми именами. - явно указывать, что они не являются локальными переменными, играть с зерном языка и так далее. (Аналогичные встроенные контейнеры и основанные на них полные имена должны были использоваться в дизайне Python вместо ошибок дизайна global и nonlocal для обозначения других типов переменных, которые не являются локальными. и, следовательно, не следует использовать barenames... ну, вы можете реализовать специальный контейнер globvar на тех же строках, что и вышеперечисленные static, даже не нуждаясь в декорировании, хотя я не уверен, что это полностью осуществимо для nonlocal футляр [возможно, с каким-то украшением и малейшим количеством черной магии...;=)]).

Изменить: комментарий указывает, что приведенный код не работает, когда вы декорируете только функцию, возвращающую замыкание (вместо декорирования самого замыкания). Правильно: конечно, вы должны декорировать конкретную функцию, которая использует static (а может быть только одна, по определению переменных function-static!), а не случайную функцию, которая на самом деле не использует static, а скорее просто оказывается в какой-то лексической связи с тем, что делает. Например:

def f():
  @with_static(x=0)
  def g():
    static.x += 1
    print static.x
  return g

x = f()
x()
x()

это работает, а перемещение декоратора на f вместо g не работает (и не может быть).

Если фактические пожелания связаны не со статическими переменными (видимыми и используемыми только в одной функции), а с какой-то гибридной вещью, которую можно использовать в определенном наборе функций, то это должно быть очень точно указано (и, несомненно, реализовано очень по-разному, в зависимости от каковы фактические спецификации ) - и в идеале это должно произойти в новом и отдельном вопросе SO, потому что этот (который вместо этого конкретно касается static), и этот ответ на этот конкретный вопрос уже достаточно велики.

Вот действительно простое решение, которое работает так же, как обычные статические переменные Python.

def static(**kwargs):
  def wrap(f):
    for key, value in kwargs.items():
      setattr(f, key, value)
    return f
  return wrap

Пример использования:

@static(a=0)
def foo(x):
  foo.a += 1
  return x+foo.a

foo(1)  # => 2
foo(2)  # => 4
foo(14) # => 17

Это более точно соответствует обычному способу выполнения статических переменных python.

def foo(x):
  foo.a += 1
  return x+foo.a
foo.a = 10

Вы можете сделать что-то подобное (но я не тестировал это широко, использовал CPython 2.6):

import types

def static(**dict):
    def doWrap(func):
        scope = func.func_globals
        scope.update(dict)
        return types.FunctionType(func.func_code, scope)
    return doWrap

# if foo() prints 43, then it's wrong
x = 42

@static(x = 0)
def foo():
   global x
   x += 1
   print(x)

foo() # => 1
foo() # => 2

Это требует объявления этих переменных как глобальных и затеняет глобальные переменные верхнего уровня, но в остальном должно работать. Хотя насчет производительности не уверен.

Как насчет этого, без декораторов?

class State(dict):
    """Object interface to dict."""
    def __getattr__(self, name):
        try:
            return self[name]
        except KeyError:
            raise AttributeError, name

def f(d=State(x=0)):
    d.x += 1
    return d.x

И вот он в действии:

>>> f()
1
>>> f()
2
>>> f()
3

Вот кое-что, что может быть намного яснее. Это не связано с декораторами или взломом.

class F( object ):
    def __init__( self ):
        self.x= 0
    def __call__( self ):
        self.x += 1
        print self.x

f= F()

Теперь у вас есть функция f со статической переменной.

f() #prints 1
f() #prints 2

Когда вам нужно сохранить состояние между вызовами функции, почти всегда лучше использовать генератор/сопрограмму или объект. Поскольку вы хотите использовать «голые» имена переменных, вам понадобится версия сопрограммы.

# the coroutine holds the state and yields rather than returns values
def totalgen(x=0, y=0, z=0):
    while True:
       a, b, c = (yield x, y, z)
       x += a
       y += b
       z += c

# the function provides the expected interface to callers
def runningtotal(a, b, c, totalgen=totalgen()):
    try:
        return totalgen.send((a, b, c))    # conveniently gives TypeError 1st time
    except TypeError:
        totalgen.next()                    # initialize, discard results
        return totalgen.send((a, b, c))

Результатом является функция, которая накапливает итоги трех переданных ей значений, точно так же, как если бы у нее были статические переменные, но аккумуляторы — это старые простые локальные переменные в том, что по сути является бесконечным генератором.

Небольшая подстройка другого ответа:

def static(**kwargs):
    def decorator(func):
        return type(func)(func.func_code, dict(func.func_globals, **kwargs))
    return decorator

message = "goodbye, world!"
@static(message="hello, world!")
def hello(): print message

hello()

Мне показалось странным переопределять встроенное имя именем аргумента функции, поэтому я изменил **dict на более каноническое **kwargs. Я также сохранил несколько строк, и IMO сделал код чище, создав новый словарь с dict(the_original, **the_updates). Наконец, я сэкономил несколько строк, обратившись к конструктору функции через type(func), а не через импорт --- типы и объекты класса являются фабричными методами, так что используйте их!

Я также удалил объявление global. Это работает до тех пор, пока вы не перепривязываете переменную, то есть удаление global фактически делает указатель (но не объект) доступным только для чтения. Если вы используете его таким образом, возможно, let будет лучшим именем, чем static для введенной таким образом привязки.