Как создать динамические переменные в Python?

Question

Я перевожу некоторый код с lisp на Python.

В lisp у вас может быть конструкция let с введенными переменными, объявленными как особые и имеющими динамическую область видимости. (См. http://en.wikipedia.org/wiki/Dynamic_scope#Dynamic_scoping)

Как я могу сделать то же самое в Python? Кажется, что язык не поддерживает это напрямую, если это правда, что было бы хорошим способом эмулировать это?

Answer 1

Я чувствую, что справедливость справедливо в своих рассуждениях здесь.

С другой стороны - я не могу удержаться от реализации доказательства концепции еще одной парадигмы программирования, «неестественной» для Python - я просто люблю это делать. : -)

Итак, я создал класс, атрибуты объектов которого отбираются так, как вам нужно (и могут создаваться динамически). Как я уже сказал, это просто подтверждение состояния концепции - но я думаю, что в большинстве обычных ошибок (например, при попытке доступа к переменной в области, в которой она вообще не определена) должны возникать ошибки, даже если они не являются правильными (IndexError например, из-за переполнения стека вместо AttributeError)

import inspect


class DynamicVars(object):
    def __init__(self):
        object.__setattr__(self, "variables", {})

    def normalize(self, stackframe):
        return [hash(tpl[0]) for tpl in stackframe[1:]]

    def __setattr__(self, attr, value):
        stack = self.normalize(inspect.stack())
        d = {"value": value, "stack": stack}
        if not attr in self.variables:
            self.variables[attr] = []
            self.variables[attr].append(d)
        else:
            our_value = self.variables[attr]
            if our_value[-1]["stack"] == stack:
                our_value[-1]["value"] = value
            elif len(stack) <= len(our_value):
                while our_value and stack !=  our_value["stack"]:
                    our_value.pop()
                our_value.append(d)
            else: #len(stack) > len(our_value):
                our_value.append(d)
    def __getattr__(self, attr):
        if not attr in self.variables:
            raise AttributeError
        stack = self.normalize(inspect.stack())
        while self.variables[attr]:
            our_stack = self.variables[attr][-1]["stack"]
            if our_stack == stack[-len(our_stack):]:
                break
            self.variables[attr].pop()
        else:
            raise AttributeError
        return self.variables[attr][-1]["value"]


# for testing:
def c():
    D = DynamicVars()
    D.c = "old"
    print D.c
    def a():
        print D.c
    a()
    def b():
        D.c = "new"
        a()
    b()
    a()
    def c():
        D.c = "newest"
        a()
        b()
        a()
    c()
    a()

c()

Answer 2

Вот кое-что, что работает немного как специальные переменные Лиспа, но немного лучше вписывается в Python.

_stack = []

class _EnvBlock(object):
    def __init__(self, kwargs):
        self.kwargs = kwargs
    def __enter__(self):
        _stack.append(self.kwargs)
    def __exit__(self, t, v, tb):
        _stack.pop()

class _Env(object):
    def __getattr__(self, name):
        for scope in reversed(_stack):
            if name in scope:
                return scope[name]
        raise AttributeError("no such variable in environment")
    def let(self, **kwargs):
        return _EnvBlock(kwargs)
    def __setattr__(self, name, value):
        raise AttributeError("env variables can only be set using `with env.let()`")

env = _Env()

Вы можете использовать это так:

with env.let(bufsize=8192, encoding="ascii"):
    print env.bufsize  # prints 8192
    a()  # call a function that uses env.bufsize or env.encoding

Эффекты env.let сохраняются в течение блока with.

Обратите внимание, что если вы используете потоки, вам определенно понадобится различный _stack для каждого потока. Вы можете использовать threading.local для реализации этого.

Answer 3

Идиома Python, соответствующая «особым» или динамически изменяемым переменным Lisp, - «локальное хранилище потока».

Вот хорошее обсуждение: Что такое «локальное хранилище потоков» в Python и зачем оно мне нужно?

Если вы хотите полностью эмулировать специальные переменные Lisp, включая оператор let, вы можете использовать менеджер контекста:

from __future__ import with_statement # if Python 2.5
from contextlib import contextmanager
import threading

dyn = threading.local()

@contextmanager
def dyn_vars(**new):
    old = {}
    for name, value in new.items():
        old[name] = getattr(dyn, name, None)
        setattr(dyn, name, value)
    yield
    for name, value in old.items():
        setattr(dyn, name, value)

Пример (явно глупый, но показывает реентерабельную особенность):

def greet_self():
    print 'Hi', dyn.who_am_I

def greet_selves():
    with dyn_vars(who_am_I='Evil Twin'):
        greet_self()
    greet_self()

with dyn_vars(who_am_I='Tobia'):
    greet_selves()

Answer 4

Динамическое определение объема считается вредным.

Не используйте его; не подражай.

Если вам нужно эмулировать его, определите модуль dynamic_scope для эмуляции этого поведения и импортируйте модуль во все исходные файлы. Этот модуль должен иметь методы begin, которые вызываются в первой строке ваших функций, использующих динамические области, end, get и set. Методы get и set должны реализовывать поиск цепочки вызовов для имен переменных, где цепочка вызовов реализована с помощью begin и end. Затем выполните рефакторинг своего кода, чтобы исключить динамические области.