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