为什么python的嵌套函数不叫闭包?

我在Python中见过并使用过嵌套函数，它们与闭包的定义相匹配。那么为什么它们被称为“嵌套函数”而不是“闭包”呢?

嵌套函数不是闭包，因为它们不被外部使用吗?

更新:我正在阅读关于闭包的文章，它让我想到了关于Python的这个概念。我搜索了下面评论中有人提到的文章，但我不能完全理解文章中的解释，所以我才问这个问题。

当前回答

这里提供了一种通过代码对象识别函数是否是闭包的方法。

正如在其他回答中已经提到的，并不是每个嵌套函数都是闭包。给定一个复合函数(表示整个动作)，它的中间状态可以是闭包或嵌套函数。闭包是一种由其(非空的)封闭范围(自由变量空间)“参数化”的函数。注意，复合函数可以由这两种类型组成。

(Python的)内部类型代码对象表示编译后的函数体。它的属性co_cellvars和co_freevars可用于“查看”函数的闭包/作用域。正如文件中提到的

Co_freevars:自由变量名的元组(通过函数的闭包引用) Co_cellvars:单元格变量名的元组(由包含作用域引用)。

一旦函数被读取，通过递归调用返回一个局部函数，它带有自己的__closure__(因此是cell_contents)和一个来自它的clousre和作用域的自由变量列表。

让我们介绍一些支持函数

# the "lookarounds"
def free_vars_from_closure_of(f):
    print(f.__name__, 'free vars from its closure',  f.__code__.co_cellvars)

def free_vars_in_scopes_of(f):
    print(f.__name__, 'free vars in its scope    ', f.__code__.co_freevars)

# read cells values
def cell_content(f):
    if f.__closure__ is not None:
        if len(f.__closure__) == 1: # otherwise problem with join
            c = f.__closure__[0].cell_contents
        else:
            c = ','.join(str(c.cell_contents) for c in f.__closure__)
    else:
        c = None

    print(f'cells of {f.__name__}: {c}')

这里有一个例子，来自另一个用更系统的方式重写的答案

def f1(x1):
    def f2(x2):
        a = 'free' # <- better choose different identifier to avoid confusion
        def f3(x3):
            return '%s %s %s %s' %  (x1, x2, a, x3)
        return f3
    return f2

# partial functions
p1 = f1('I')
p2 = p1('am')

# lookaround
for p in (f1, p1, p2):
    free_vars_in_scopes_of(p)
    free_vars_from_closure_of(p)
    cell_content(p)

输出

f1 free vars in its scope     ()         # <- because it's the most outer function
f1 free vars from its closure ('x1',)
cells of f1: None
f2 free vars in its scope     ('x1',)
f2 free vars from its closure ('a', 'x2')
cells of f2: I
f3 free vars in its scope     ('a', 'x1', 'x2')
f3 free vars from its closure ()        # <- because it's the most inner function
cells of f3: free, I, am

对应的lambda:

def g1(x1):
    return lambda x2, a='free': lambda x3: '%s %s %s %s' %  (x1, x2, a, x3)

从自由变量/范围的角度来看是等价的。唯一微小的区别是code对象的某些属性的一些值: Co_varnames, co_consts, co_code, co_lnotab, co_stacksize…当然还有__name__属性。

一个混合的例子，闭包和不立即:

# example: counter
def h1():             # <- not a closure
    c = 0
    def h2(c=c):      # <- not a closure
        def h3(x):    # <- closure
            def h4(): # <- closure
                nonlocal c
                c += 1
                print(c)
            return h4
        return h3
    return h2

# partial functions
p1 = h1()
p2 = p1()
p3 = p2('X')

p1() # do nothing
p2('X') # do nothing
p2('X') # do nothing
p3() # +=1
p3() # +=1
p3() # +=1

# lookaround
for p in (h1, p1, p2, p3):
    free_vars_in_scopes_of(p)
    #free_vars_from_closure_of(p)
    cell_content(p)

输出

1 X
2 X
3 X
h1 free vars in its scope     ()
cells of h1: None
h2 free vars in its scope     ()
cells of h2: None
h3 free vars in its scope     ('c',)
cells of h3: 3
h4 free vars in its scope     ('c', 'x')
cells of h4: 3,X

H1和h2都不是闭包，因为它们在作用域内没有单元格和自由变量。 H3和H3是闭包，共享(在本例中)相同的单元格和c的自由变量。h4有一个带有自己单元格的自由变量x。

最后的考虑:

__closure__属性和__code__。Co_freevars可用于检查自由变量的值和名称(标识符) nonlocal和__code__之间的反类比(在广义上)。Co_cellvars:非局部作用于外部函数__code__。Co_cellvars改为内部函数

2022-08-04 00:28:19

其他回答

这个问题aaronasterling已经回答过了

然而，有些人可能对变量在底层是如何存储的感兴趣。

在开始之前:

闭包是从其封闭环境中继承变量的函数。当你将一个回调函数作为参数传递给另一个将要执行I/O操作的函数时，这个回调函数将在以后被调用，并且这个函数将——几乎神奇地——记住声明它的上下文，以及该上下文中所有可用的变量。

如果一个函数不使用自由变量，它就不能形成闭包。如果存在另一个使用自由变量的内部关卡——所有之前的关卡都会保存词汇环境(例如最后的例子) python中的函数属性func_closure < 3。3. python >中的__closure__X保存自由变量。 python中的每个函数都有闭包属性，但如果没有自由变量，则该属性为空。

示例:闭包属性，但内部没有内容，因为没有自由变量。

>>> def foo():
...     def fii():
...         pass
...     return fii
...
>>> f = foo()
>>> f.func_closure
>>> 'func_closure' in dir(f)
True
>>>

注意:自由变量必须创建一个闭包。

我将使用与上面相同的片段来解释:

>>> def make_printer(msg):
...     def printer():
...         print msg
...     return printer
...
>>> printer = make_printer('Foo!')
>>> printer()  #Output: Foo!

所有的Python函数都有一个闭包属性，所以让我们检查一下与闭包函数相关的封闭变量。

下面是函数打印机的func_closure属性

>>> 'func_closure' in dir(printer)
True
>>> printer.func_closure
(<cell at 0x108154c90: str object at 0x108151de0>,)
>>>

闭包属性返回一个单元格对象元组，其中包含在封闭范围内定义的变量的详细信息。

func_closure中的第一个元素，可以是None，也可以是包含函数自由变量绑定的单元格元组，并且是只读的。

>>> dir(printer.func_closure[0])
['__class__', '__cmp__', '__delattr__', '__doc__', '__format__', '__getattribute__',
 '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
 '__setattr__',  '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']
>>>

在上面的输出中，你可以看到cell_contents，让我们看看它存储了什么:

>>> printer.func_closure[0].cell_contents
'Foo!'    
>>> type(printer.func_closure[0].cell_contents)
<type 'str'>
>>>

因此，当我们调用函数printer()时，它访问存储在cell_contents中的值。这就是我们如何得到输出为'Foo!'

我将再次使用上面的片段进行一些更改:

 >>> def make_printer(msg):
 ...     def printer():
 ...         pass
 ...     return printer
 ...
 >>> printer = make_printer('Foo!')
 >>> printer.func_closure
 >>>

在上面的代码片段中，我没有在printer函数中打印msg，因此它不会创建任何自由变量。由于没有自由变量，闭包内将没有内容。这正是我们在上面看到的。

现在我将解释另一个不同的片段，以清除所有的自由变量与闭包:

>>> def outer(x):
...     def intermediate(y):
...         free = 'free'
...         def inner(z):
...             return '%s %s %s %s' %  (x, y, free, z)
...         return inner
...     return intermediate
...
>>> outer('I')('am')('variable')
'I am free variable'
>>>
>>> inter = outer('I')
>>> inter.func_closure
(<cell at 0x10c989130: str object at 0x10c831b98>,)
>>> inter.func_closure[0].cell_contents
'I'
>>> inn = inter('am')

我们看到func_closure属性是一个闭包单元格的元组，我们可以显式引用它们和它们的内容，一个单元格有属性cell_contents

>>> inn.func_closure
(<cell at 0x10c9807c0: str object at 0x10c9b0990>, 
 <cell at 0x10c980f68: str object at   0x10c9eaf30>, 
 <cell at 0x10c989130: str object at 0x10c831b98>)
>>> for i in inn.func_closure:
...     print i.cell_contents
...
free
am 
I
>>>

这里当我们调用inn时，它会引用所有保存的自由变量，所以我们得到I是自由变量

>>> inn('variable')
'I am free variable'
>>>

2014-01-03 06:41:20

《计算机程序的结构和解释》(SICP)的读者:闭包有两种不相关的含义(CS VS Math)，后一种含义见维基百科(Wikipedia):

在20世纪80年代，Sussman和Abelson还将闭包一词用于另一个不相关的含义:将数据添加到数据结构中以同时能够添加嵌套数据结构的操作符的属性。该术语的这种用法来自数学用法，而不是先前在计算机科学中的用法。作者认为这种术语上的重叠是“不幸的”。

https://en.wikipedia.org/wiki/Closure_ (computer_programming) # History_and_etymology

第二个(数学)含义也在Python的SICP中使用，参见例如元组的讨论

我们能够将元组用作其他元组的元素，这为我们的编程语言提供了一种新的组合方式。我们把元组以这种方式嵌套的能力称为元组数据类型的闭包属性。通常，如果组合结果本身可以使用相同的方法组合，则组合数据值的方法满足闭包性质。

2.3 Python中的| SICP序列

2022-03-11 07:15:48

我想提供另一个简单的比较python和JS的例子，如果这有助于使事情更清楚。

JS:

function make () {
  var cl = 1;
  function gett () {
    console.log(cl);
  }
  function sett (val) {
    cl = val;
  }
  return [gett, sett]
}

和执行:

a = make(); g = a[0]; s = a[1];
s(2); g(); // 2
s(3); g(); // 3

Python:

def make (): 
  cl = 1
  def gett ():
    print(cl);
  def sett (val):
    cl = val
  return gett, sett

和执行:

g, s = make()
g() #1
s(2); g() #1
s(3); g() #1

原因:正如上面许多人所说，在python中，如果内部作用域对同名变量赋值，则会在内部作用域中创建一个新的引用。JS则不是这样，除非你显式地用var关键字声明一个。

2017-06-30 11:45:46

闭包发生在函数从已完成执行的封闭作用域访问局部变量时。

def make_printer(msg):
    def printer():
        print(msg)
    return printer

printer = make_printer('Foo!')
printer()

当调用make_printer时，一个新的帧被放在堆栈上，其中打印机函数的编译代码作为一个常量，msg的值作为一个局部值。然后它创建并返回函数。因为函数printer引用了msg变量，所以在make_printer函数返回后，msg变量仍保持活动状态。

如果你的嵌套函数没有

对于封闭作用域的本地访问变量，当它们在该范围外执行时这样做，

那么它们就不是闭包了。

下面是一个嵌套函数的例子，它不是闭包。

def make_printer(msg):
    def printer(msg=msg):
        print(msg)
    return printer

printer = make_printer("Foo!")
printer()  #Output: Foo!

在这里，我们将值绑定到参数的默认值。这发生在创建函数printer时，因此在make_printer返回后，不需要维护对printer外部的msg值的引用。在这个上下文中，MSG只是函数打印机的一个普通局部变量。

2010-10-26 03:20:12