javascript - Python 闭包 vs javascript 闭包

Question

以下闭包函数在 javascript 中运行良好。

function generateNextNumber(startNumber) {
    var current = startNumber;
    return function(){
        return current += 1;
    }
}

var getNextNumber = generateNextNumber(10);
for (var i = 0; i < 10; i++) {
    console.log(getNextNumber());
}

我试着用 Python 做同样的事情

def generateNextNumber(startNumber):
    current = startNumber
    def tempFunction():
        current += 1
        return current
    return tempFunction

getNextNumber = generateNextNumber(10)
for i in range(10):
    print (getNextNumber())

出现以下错误

Traceback (most recent call last):
  File "/home/thefourtheye/Desktop/Test1.py", line 10, in <module>
    print (getNextNumber())
  File "/home/thefourtheye/Desktop/Test1.py", line 4, in tempFunction
    current += 1
UnboundLocalError: local variable 'current' referenced before assignment

当我在 tempFunction 中打印 vars() 和 locals() 时，它们确认 current 是目前。

({'current': 10}, {'current': 10})

但是当我把程序修改成这样的时候

def generateNextNumber(startNumber):
    current = {"Number" : startNumber}
    def tempFunction():
        current["Number"] += 1
        return current["Number"]
    return tempFunction

它有效。我无法解释为什么会这样。谁能解释一下？

Answer 1

Python 假定函数中的所有变量都是局部变量。这是为了避免意外使用同名全局变量或在封闭范围内使用。在某些重要方面，这种差异是由于在 Python 中局部变量声明是自动/隐式的，而在 JavaScript 中则不是(您必须使用 var)。解决方案:

使用全局声明

def generateNextNumber(startNumber):
    global current
    current= startNumber
    def tempFunction():
        global current
        current += 1
        return current 
    return tempFunction

在某些情况下有效，但在您的情况下，只有一个 tempFunction 实例可以同时处于事件状态。

使用函数属性

def generateNextNumber(startNumber):
    def tempFunction():
        tempFunction.current += 1
        return tempFunction.current
    tempFunction.current= startNumber
    return tempFunction

利用函数是对象(因此可以具有属性)这一事实，它们在声明时被实例化，并且它们对于封闭函数(或模块，在这种情况下它们实际上是全局的)而言是局部的。这也有效，因为名称 tempFunction 首次在其自己的定义中使用“成员访问”. 运算符，因此不假定为本地。 “调用”() 和“元素访问”[] 运算符会发生类似情况。后一种情况解释了您的代码为何有效。

强制假定名称是非本地的

def generateNextNumber(startNumber):
    current= type("OnTheFly",(),{})()
    current.value= startNumber
    def tempFunction():
        current.value += 1
        return current.value
    return tempFunction

这在上一节中已经解释过了。通过使用成员访问运算符 . 我们说“current 已经存在”，因此它在封闭范围内被搜索。在这种特殊情况下，我们使用 type 函数创建一个类，并立即创建它的一个实例(使用第二组括号)。除了一般对象，我们还可以使用列表或字典。第二种情况是一种非常常见的解决方案。

使用函数对象

def generateNextNumber(startNumber):
    class TempFunction:
        def __call__(self):
            self.current += 1
            return self.current
    tempFunction= TempFunction()
    tempFunction.current= startNumber
    return tempFunction

任何其类具有call 方法的对象都是函数，因此可以使用函数调用运算符() 进行调用。这与前两个案例极为相关。

使用非本地声明

def generateNextNumber(startNumber):
    current= startNumber
    def tempFunction():
        nonlocal current
        current += 1
        return current
    return tempFunction

以同样的方式，global 意味着......好吧，全局，nonlocal 意味着“在紧接的前一个范围内”。在 Python 3 和更高版本的 Python 2 中有效。

使用生成器

def generateNextNumber(current):
    while True :
        current+= 1
        yield current

这可能是最“Pythonic”的方式来处理不是非局部变量访问的一般问题，而是您用来解释它的具体情况。不提就说不完了。不过，您需要稍作更改才能调用它:

getNextNumber = generateNextNumber(10)
for i in range(10):
    print (getNextNumber.next())

当驱动 for 时，对 next() 的调用是隐式的(但生成器不能像我的示例那样是无限的)。