python - 如何在 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()

2020 年更新- 另一个类似的问题出现了，我制作了一个不需要特殊命名空间对象的 hack（但它求助于使用 cPython 的内部事物，例如将 locals() 更新为实际变量：https ://stackoverflow.com/a /61015579/108205（适用于 Python 3.8）

Answer 2

这有点像 Lisp 的特殊变量，但更适合 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

last的效果env.let在方块的持续时间内with。

请注意，如果您使用线程，您肯定会希望_stack每个线程都使用不同的线程。您可以使用threading.local来实现它。

Answer 3

对应于 Lisp“特殊”或动态范围变量的 Python 习语是“线程本地存储”。

这是一个很好的讨论：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。getand方法应该实现在set调用链中查找变量名的调用链，其中调用链是由beginand实现的end。然后重构您的代码以消除动态范围。