如何在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

动态范围界定被认为是有害的。

请勿使用它;不要模仿它。

如果您需要模拟它，请定义一个dynamic_scope模块来模拟此行为并将模块导入到所有源文件中。该模块应具有方法begin，它在函数的第一行中使用动态范围end,get和set。 get和set方法应实现查找呼叫链的变量名称，其中调用链由begin和end实施。然后重构您的代码以消除动态范围。

Answer 3

这里的一些作品有点像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 

最后的with块的持续时间的env.let影响。

请注意，如果你使用线程，你肯定会想为每个线程使用不同的_stack。你可以使用threading.local来实现。

Answer 4

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

这里是一个很好的讨论：What is "thread local storage" in Python, and why do I need it?

如果你想完全效仿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()