我一直在阅读很多关于闭包的文章，我想我理解它们，但在不给自己和其他人蒙上阴影的情况下，我希望有人能尽可能简洁明了地解释闭包。我正在寻找一个简单的解释，可以帮助我理解我想在哪里以及为什么要使用它们。
问问题
15054 次
13 回答
103
对象是附加了方法的数据，闭包是附加了数据的函数。
def make_counter():
i = 0
def counter(): # counter() is a closure
nonlocal i
i += 1
return i
return counter
c1 = make_counter()
c2 = make_counter()
print (c1(), c1(), c2(), c2())
# -> 1 2 1 2
于 2008-09-26T19:28:32.573 回答
46
很简单：一个从包含范围引用变量的函数，可能在控制流离开该范围之后。最后一点非常有用：
>>> def makeConstantAdder(x):
... constant = x
... def adder(y):
... return y + constant
... return adder
...
>>> f = makeConstantAdder(12)
>>> f(3)
15
>>> g = makeConstantAdder(4)
>>> g(3)
7
请注意，12 和 4 分别在 f 和 g 中“消失”了，这个特性使 f 和 g 成为正确的闭包。
于 2008-08-17T19:32:33.160 回答
17
老实说，我非常了解闭包，只是我一直不清楚究竟什么是“闭包”以及什么是“闭包”。我建议您放弃寻找术语选择背后的任何逻辑。
无论如何，这是我的解释：
def foo():
x = 3
def bar():
print x
x = 5
return bar
bar = foo()
bar() # print 5
这里的一个关键思想是，从 foo 返回的函数对象保留了到本地 var 'x' 的钩子，即使 'x' 已经超出范围并且应该已失效。这个钩子是针对 var 本身的，而不仅仅是 var 当时的值，所以当 bar 被调用时，它会打印 5，而不是 3。
还要清楚 Python 2.x 的封闭性有限：我无法修改 'bar' 内的 'x' 因为编写 'x = bla' 会在 bar 中声明一个本地 'x'，而不是分配给 foo 的 'x' . 这是 Python 的 assignment=declaration 的副作用。为了解决这个问题，Python 3.0 引入了 nonlocal 关键字：
def foo():
x = 3
def bar():
print x
def ack():
nonlocal x
x = 7
x = 5
return (bar, ack)
bar, ack = foo()
ack() # modify x of the call to foo
bar() # print 7
于 2008-08-23T07:43:18.127 回答
15
我喜欢这个粗略、简洁的定义：
可以引用不再活动的环境的功能。
我会补充
闭包允许您将变量绑定到函数中，而无需将它们作为参数传递。
接受参数的装饰器是闭包的常见用途。闭包是这种“函数工厂”的常见实现机制。当策略在运行时被数据修改时，我经常选择在策略模式中使用闭包。
在允许匿名块定义的语言中——例如，Ruby、C#——闭包可用于实现（相当于）新颖的新控制结构。缺少匿名块是Python 中闭包的限制之一。
于 2008-08-17T20:25:18.687 回答
7
我从未听说过在解释闭包是什么的相同上下文中使用事务，并且这里实际上没有任何事务语义。
它被称为闭包，因为它“关闭”了外部变量（常量）——即，它不仅仅是一个函数，而是创建函数的环境的封闭。
在下面的例子中，在改变 x 之后调用闭包 g 也会改变 g 中 x 的值，因为 g 在 x 上闭合：
x = 0
def f():
def g():
return x * 2
return g
closure = f()
print(closure()) # 0
x = 2
print(closure()) # 4
于 2008-08-17T20:20:20.333 回答
3
这是闭包的典型用例 - GUI 元素的回调（这将是子类化按钮类的替代方法）。例如，您可以构造一个函数，该函数将响应按钮按下而被调用，并“关闭”父范围内处理单击所需的相关变量。这样，您可以从同一个初始化函数连接相当复杂的接口，将所有依赖项构建到闭包中。
于 2009-01-23T16:13:53.473 回答
2
在 Python 中，闭包是一个函数的实例，它具有不变地绑定到它的变量。
事实上，数据模型在其对函数__closure__属性的描述中解释了这一点：
无或包含函数自由变量绑定的单元格元组。只读
为了证明这一点：
def enclosure(foo):
def closure(bar):
print(foo, bar)
return closure
closure_instance = enclosure('foo')
显然，我们知道我们现在有一个从变量 name 指向的函数closure_instance。从表面上看，如果我们用一个对象来调用它bar，它应该打印字符串，'foo'以及任何字符串表示形式bar。
实际上，字符串 'foo'绑定到函数的实例，我们可以直接在这里读取它，通过访问属性cell_contents元组中第一个（也是唯一一个）单元格的__closure__属性：
>>> closure_instance.__closure__[0].cell_contents
'foo'
顺便说一句，C API 文档中描述了单元对象：
我们可以演示闭包的用法，注意它'foo'卡在函数中并且不会改变：
>>> closure_instance('bar')
foo bar
>>> closure_instance('baz')
foo baz
>>> closure_instance('quux')
foo quux
没有什么可以改变它：
>>> closure_instance.__closure__ = None
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: readonly attribute
偏函数
给出的示例使用闭包作为部分函数，但如果这是我们唯一的目标，同样的目标可以通过functools.partial
>>> from __future__ import print_function # use this if you're in Python 2.
>>> partial_function = functools.partial(print, 'foo')
>>> partial_function('bar')
foo bar
>>> partial_function('baz')
foo baz
>>> partial_function('quux')
foo quux
还有更复杂的闭包不适合偏函数示例，我将在时间允许的情况下进一步演示它们。
于 2014-07-18T03:33:13.887 回答
2
# A Closure is a function object that remembers values in enclosing scopes even if they are not present in memory.
# Defining a closure
# This is an outer function.
def outer_function(message):
# This is an inner nested function.
def inner_function():
print(message)
return inner_function
# Now lets call the outer function and return value bound to name 'temp'
temp = outer_function("Hello")
# On calling temp, 'message' will be still be remembered although we had finished executing outer_function()
temp()
# Technique by which some data('message') that remembers values in enclosing scopes
# even if they are not present in memory is called closures
# Output: Hello
闭包满足的标准是：
- 我们必须有嵌套函数。
- 嵌套函数必须引用封闭函数中定义的值。
- 封闭函数必须返回嵌套函数。
# Example 2
def make_multiplier_of(n): # Outer function
def multiplier(x): # Inner nested function
return x * n
return multiplier
# Multiplier of 3
times3 = make_multiplier_of(3)
# Multiplier of 5
times5 = make_multiplier_of(5)
print(times5(3)) # 15
print(times3(2)) # 6
于 2017-12-26T16:41:29.813 回答
1
这是 Python3 闭包的示例
def closure(x):
def counter():
nonlocal x
x += 1
return x
return counter;
counter1 = closure(100);
counter2 = closure(200);
print("i from closure 1 " + str(counter1()))
print("i from closure 1 " + str(counter1()))
print("i from closure 2 " + str(counter2()))
print("i from closure 1 " + str(counter1()))
print("i from closure 1 " + str(counter1()))
print("i from closure 1 " + str(counter1()))
print("i from closure 2 " + str(counter2()))
# result
i from closure 1 101
i from closure 1 102
i from closure 2 201
i from closure 1 103
i from closure 1 104
i from closure 1 105
i from closure 2 202
于 2015-09-22T20:16:22.093 回答
0
对我来说，“闭包”是能够记住它们创建的环境的功能。此功能允许您在闭包中使用变量或方法，以其他方式，您将无法使用它们，因为它们不再存在或由于范围而超出范围。让我们看一下 ruby 中的这段代码：
def makefunction (x)
def multiply (a,b)
puts a*b
end
return lambda {|n| multiply(n,x)} # => returning a closure
end
func = makefunction(2) # => we capture the closure
func.call(6) # => Result equal "12"
即使“乘法”方法和“x”变量不再存在，它也可以工作。都是因为要记住的闭包能力。
于 2013-09-20T13:39:53.483 回答
0
我们都在 python中使用过装饰器。它们是展示 Python 中的闭包函数的好例子。
class Test():
def decorator(func):
def wrapper(*args):
b = args[1] + 5
return func(b)
return wrapper
@decorator
def foo(val):
print val + 2
obj = Test()
obj.foo(5)
这里的最终值为 12
在这里，wrapper 函数能够访问 func 对象，因为 wrapper 是“词法闭包”，它可以访问它的父属性。这就是为什么它能够访问 func 对象。
于 2018-04-17T19:00:31.750 回答
0
我想分享我的例子和关于闭包的解释。我做了一个 python 例子，和两个图来演示堆栈状态。
def maker(a, b, n):
margin_top = 2
padding = 4
def message(msg):
print('\n’ * margin_top, a * n,
' ‘ * padding, msg, ' ‘ * padding, b * n)
return message
f = maker('*', '#', 5)
g = maker('', '♥’, 3)
…
f('hello')
g(‘good bye!')
此代码的输出如下：
***** hello #####
good bye! ♥♥♥
这里有两个图来显示堆栈和附加到函数对象的闭包。
通过参数或非局部变量调用函数时，代码需要margin_top、padding以及a、b、n等局部变量绑定。为了保证函数代码能够正常工作，早就消失的 maker 函数的栈帧应该是可访问的，它与 'message 的函数对象一起备份在闭包中。
于 2018-05-12T04:17:47.993 回答
-2
我见过的关于闭包的最好解释是解释机制。它是这样的：
将您的程序堆栈想象成一棵退化树，其中每个节点只有一个子节点，而单个叶节点是您当前执行过程的上下文。
现在放宽每个节点只能有一个孩子的约束。
如果你这样做，你可以有一个构造（'yield'），它可以从一个过程返回而不丢弃本地上下文（即当你返回时它不会将它从堆栈中弹出）。下一次调用该过程时，该调用会拾取旧的堆栈（树）帧并从中断处继续执行。
于 2008-09-18T17:10:42.087 回答