在Python 2.x中的非本地關鍵字

Question

我想在Python 2.6中實現一個閉包，我需要訪問一個非本地變量，但它似乎像這個關鍵字在python 2.x中不可用。在這些版本的python中，應該如何訪問非本地變量？

Answer 1

內函數可以讀 2.x中的非局部變量，只是不是rebind他們。這很煩人，但你可以解決它。只需創建一個字典，並將數據作爲元素存儲在其中。 不會禁止內部函數非本地變量引用的對象。

從維基百科使用例如：

def outer(): 
    d = {'y' : 0} 
    def inner(): 
     d['y'] += 1 
     return d['y'] 
    return inner 

f = outer() 
print(f(), f(), f()) #prints 1 2 3 

Answer 2

我認爲，這裏的關鍵是你所說的「訪問」。應該沒有問題與讀取可變封閉範圍之外，例如，

x = 3 
def outer(): 
    def inner(): 
     print x 
    inner() 
outer() 

應該按預期工作（打印3）。然而，覆蓋x的值不起作用，例如，

x = 3 
def outer(): 
    def inner(): 
     x = 5 
    inner() 
outer() 
print x 

仍然會打印3.從我的PEP-3104這種認識是什麼外地關鍵字應該涵蓋。正如PEP提到的，你可以使用一個類來完成同樣的事情（有點雜亂）：

class Namespace(object): pass 
ns = Namespace() 
ns.x = 3 
def outer(): 
    def inner(): 
     ns.x = 5 
    inner() 
outer() 
print ns.x 

Answer 3

在Python的作用域規則疣 - 分配使得局部變量它直接包含的功能範圍。對於全局變量，您可以使用global關鍵字來解決此問題。

解決方法是引入一個對象，該對象在兩個作用域之間共享，其中包含可變變量，但它本身是通過未分配的變量引用的。

def outer(v): 
    def inner(container = [v]): 
     container[0] += 1 
     return container[0] 
    return inner 

另一種是一些範圍兩輪牛車：

def outer(v): 
    def inner(varname = 'v', scope = locals()): 
     scope[varname] += 1 
     return scope[varname] 
    return inner 

您可能能夠找出一些掛羊頭賣狗肉，以獲取參數的名稱outer，然後把它作爲varname的，但不依賴在名稱outer上，您需要使用Y組合器。

Answer 4

還有就是要實現在Python 2非本地變量的另一種方式，萬一有什麼問題的答案在這裏是不受歡迎無論出於何種原因：

def outer(): 
    outer.y = 0 
    def inner(): 
     outer.y += 1 
     return outer.y 
    return inner 

f = outer() 
print(f(), f(), f()) #prints 1 2 3 

它是多餘的賦值語句中使用函數的名稱的變量，但它看起來比將變量放在字典中更簡單和更清晰。從一個電話到另一個電話，這個價值就會被記住，就像Chris B.的答案一樣。

Answer 5

以下解決方案受answer by Elias Zamaria啓發，但與該答案相反，它正確地處理外部函數的多個調用。 「變量」inner.y位於當前呼叫outer的本地。只有它不是一個變量，因爲這是被禁止的，而是一個對象屬性（該對象本身就是函數inner）。這非常難看（注意只有在定義了inner函數後才能創建該屬性），但似乎有效。

def outer(): 
    def inner(): 
     inner.y += 1 
     return inner.y 
    inner.y = 0 
    return inner 

f = outer() 
g = outer() 
print(f(), f(), g(), f(), g()) #prints (1, 2, 1, 3, 2) 

Answer 6

使用全局變量

def outer(): 
    global y # import1 
    y = 0 
    def inner(): 
     global y # import2 - requires import1 
     y += 1 
     return y 
    return inner 

f = outer() 
print(f(), f(), f()) #prints 1 2 3 

就個人而言，我不喜歡這個全局變量。但是，我的建議是基於https://stackoverflow.com/a/19877437/1083704答案

def report(): 
     class Rank: 
      def __init__(self): 
       report.ranks += 1 
     rank = Rank() 
report.ranks = 0 
report() 

其中用戶需要聲明一個全局變量ranks，每次你需要調用report時間。我的改進消除了從用戶初始化函數變量的需要。

Answer 7

另一種方式來做到這一點（雖然它太冗長）：

import ctypes 

def outer(): 
    y = 0 
    def inner(): 
     ctypes.pythonapi.PyCell_Set(id(inner.func_closure[0]), id(y + 1)) 
     return y 
    return inner 

x = outer() 
x() 
>> 1 
x() 
>> 2 
y = outer() 
y() 
>> 1 
x() 
>> 3 

Answer 8

這裏的東西被建議阿洛伊斯Mahdal在comment作出關於另一answer啓發：

class Nonlocals(object): 
    """ Helper class to implement nonlocal names in Python 2.x """ 
    def __init__(self, **kwargs): 
     self.__dict__.update(kwargs) 

def outer(): 
    nonlocals = Nonlocals(y=0) 
    def inner(): 
     nonlocals.y += 1 
     return nonlocals.y 
    return inner 

f = outer() 
print(f(), f(), f()) # -> (1 2 3) 

Answer 9

擴展馬蒂諾優雅的解決方案以上，我得到一個實用的，不太優雅的用例：

class nonlocals(object): 
""" Helper to implement nonlocal names in Python 2.x. 
Usage example: 
def outer(): 
    nl = nonlocals(n=0, m=1) 
    def inner(): 
     nl.n += 1 
    inner() # will increment nl.n 

or... 
    sums = nonlocals({ k:v for k,v in locals().iteritems() if k.startswith('tot_') }) 
""" 
def __init__(self, **kwargs): 
    self.__dict__.update(kwargs) 

def __init__(self, a_dict): 
    self.__dict__.update(a_dict) 

Answer 10

而不是字典，非本地類雜亂。修改@ ChrisB的example：

def outer(): 
    class context: 
     y = 0 
    def inner(): 
     context.y += 1 
     return context.y 
    return inner 

然後

f = outer() 
assert f() == 1 
assert f() == 2 
assert f() == 3 

每個外（）調用創建一個單獨的上下文。所以它避免了@Nathaniel's beware。

g = outer() 
assert g() == 1 
assert g() == 2 

assert f() == 4