Question

“函数对象”是指一个类的对象，它在某种意义上是可调用的，可以在语言中作为函数来处理。例如，在python中：

class FunctionFactory:
    def __init__ (self, function_state):
        self.function_state = function_state
    def __call__ (self):
        self.function_state += 1
        return self.function_state

>>>> function = FunctionFactory (5)
>>>> function ()
6
>>>> function ()
7

我的问题是 - 将FunctionFactory和函数的使用视为闭包吗？

Answer 1

闭包是一种功能，可以记住定义它的环境，并且可以访问周围范围内的变量。函数对象是一个可以像函数一样调用的对象，但它实际上可能不是函数。函数对象不是闭包：

class FunctionObject(object):
    def __call__(self):
        return foo

def f():
    foo = 3
    FunctionObject()() # raises UnboundLocalError

FunctionObject无权访问创建它的范围。但是，函数对象的__call__方法可能是闭包：

def f():
    foo = 3
    class FunctionObject(object):
        def __call__(self):
            return foo
    return FunctionObject()
print f()() # prints 3, since __call__ has access to the scope where it was defined,
            # though it doesn't have access to the scope where the FunctionObject
            # was created

Answer 2

...将FunctionFactory和函数的使用视为闭包吗？

本身不是，因为它不涉及范围。虽然它确实模仿了闭包的能力。

def ClosureFactory(val):
  value = val
  def closure():
    nonlocal value # 3.x only; use a mutable object in 2.x instead
    value += 1
    return value
  return closure

3>> closure = ClosureFactory(5)
3>> closure()
6
3>> closure()
7

Answer 3

闭包是一段代码，它关闭它所定义的环境，捕获其变量。在大多数现代语言中，函数是闭包，但它不一定如此，你可以想象不是函数对象的闭包（例如Ruby块，它们根本就不是对象）。

这是关闭的必要测试：

def bar():
    x = 1
    def foo():
        print x
    return foo

x = 2
bar()()

如果打印1，foo是一个闭包。如果它打印2，则不是。

有人可以向我解释一下Function Object和Closure之间的区别

3 个答案: