以下闭包函数在 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
它有效。我无法解释为什么会这样。谁能解释一下?
最佳答案
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()
的调用是隐式的(但生成器不能像我的示例那样是无限的)。
关于javascript - Python 闭包 vs javascript 闭包,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/18502095/