Python对闭包的支持很弱。要理解我的意思，请参考以下使用JavaScript闭包的计数器示例:

function initCounter(){
    var x = 0;
    function counter  () {
        x += 1;
        console.log(x);
    };
    return counter;
}

count = initCounter();

count(); //Prints 1
count(); //Prints 2
count(); //Prints 3

闭包非常优雅，因为它赋予了这样编写的函数拥有“内部内存”的能力。从Python 2.7开始，这是不可能的。如果你尝试

def initCounter():
    x = 0;
    def counter ():
        x += 1 ##Error, x not defined
        print x
    return counter

count = initCounter();

count(); ##Error
count();
count();

你会得到一个错误，说x没有定义。但如果其他人已经证明你可以打印它，那怎么可能呢?这是因为Python是如何管理函数变量作用域的。内部函数可以读取外部函数的变量，但不能写入它们。

这真是太遗憾了。但是只有只读闭包，你至少可以实现函数装饰器模式，Python为此提供了语法糖。

更新

正如前面所指出的，有很多方法可以处理python的作用域限制，我将介绍一些方法。

1. 使用global关键字(一般不推荐)。

2. 在Python 3中。X，使用nonlocal关键字(建议使用@unutbu和@leewz)

3.定义一个简单的可修改类Object

class Object(object):
    pass

并在initCounter中创建一个Object范围来存储变量

def initCounter ():
    scope = Object()
    scope.x = 0
    def counter():
        scope.x += 1
        print scope.x

    return counter

由于作用域实际上只是一个引用，对其字段所采取的操作并不真正修改作用域本身，因此不会出现错误。

4. @unutbu指出的另一种方法是将每个变量定义为一个数组(x =[0])，并修改它的第一个元素(x[0] += 1)。同样没有出现错误，因为x本身没有被修改。

5. 正如@raxacoricofallapatorius所建议的，你可以让x成为counter的一个属性

def initCounter ():

    def counter():
        counter.x += 1
        print counter.x

    counter.x = 0
    return counter

人们对什么是终结感到困惑。闭包不是内部函数。封闭的意义是封闭的行为。内部函数封闭在一个非局部变量上，这个变量叫做自由变量。

def counter_in(initial_value=0):
    # initial_value is the free variable
    def inc(increment=1):
        nonlocal initial_value
        initial_value += increment
        print(initial_value)
    return inc

当你调用counter_in()时，它将返回inc函数，该函数有一个自由变量initial_value。所以我们创建了一个CLOSURE。人们称inc为闭包函数，我认为这让人困惑，人们认为"内部函数是闭包"在现实中inc并不是一个闭包，因为它是闭包的一部分，为了方便起见，他们称它为闭包函数。

  myClosingOverFunc=counter_in(2)

返回inc函数，该函数在自由变量initial_value上关闭。当你调用myClosingOverFunc

 myClosingOverFunc() 

它会输出2。

当python看到一个闭包系统存在时，它会创建一个名为CELL的新obj。这将只存储自由变量的名称，在本例中为initial_value。这个Cell obj将指向另一个存储initial_value值的对象。

在我们的例子中，外层函数和内部函数中的initial_value将指向这个单元格对象，而这个单元格对象将指向initial_value的值。

  variable initial_value =====>> CELL ==========>> value of initial_value

所以当你调用counter_in时，它的作用域消失了，但这无关紧要。因为变量initial_value直接引用CELL对象。它间接引用initial_value的值。这就是为什么即使外部函数的作用域消失了，内部函数仍然可以访问自由变量

假设我想写一个函数，它接受一个函数作为参数，并返回这个函数被调用的次数。

def counter(fn):
    # since cnt is a free var, python will create a cell and this cell will point to the value of cnt
    # every time cnt changes, cell will be pointing to the new value
    cnt = 0

    def inner(*args, **kwargs):
        # we cannot modidy cnt with out nonlocal
        nonlocal cnt
        cnt += 1
        print(f'{fn.__name__} has been called {cnt} times')
        # we are calling fn indirectly via the closue inner
        return fn(*args, **kwargs)
    return inner
      

在这个例子中，cnt是我们的自由变量，inner + cnt创建CLOSURE。当python看到这个时，它将创建一个CELL Obj, cnt将总是直接引用这个CELL Obj，而CELL将引用内存中存储cnt值的另一个Obj。最初问= 0。

 cnt   ======>>>>  CELL  =============>  0

当你通过传递参数计数器(myFunc)()调用内部函数时，这将使cnt增加1。因此，我们的引用模式将发生如下变化:

 cnt   ======>>>>  CELL  =============>  1  #first counter(myFunc)()
 cnt   ======>>>>  CELL  =============>  2  #second counter(myFunc)()
 cnt   ======>>>>  CELL  =============>  3  #third counter(myFunc)()

这只是终结的一个例子。您可以通过传递另一个函数来创建闭包的多个实例

counter(differentFunc)()

这将创建一个与上面不同的CELL obj。我们刚刚创建了另一个闭包实例。

 cnt  ======>>  difCELL  ========>  1  #first counter(differentFunc)()
 cnt  ======>>  difCELL  ========>  2  #secon counter(differentFunc)()
 cnt  ======>>  difCELL  ========>  3  #third counter(differentFunc)()


  

Python 2没有闭包——它有类似闭包的变通方法。

已经给出的答案中有很多例子——将变量复制到内部函数，在内部函数上修改对象，等等。

在Python 3中，支持更加显式和简洁:

def closure():
    count = 0
    def inner():
        nonlocal count
        count += 1
        print(count)
    return inner

用法:

start = closure()
another = closure() # another instance, with a different stack

start() # prints 1
start() # prints 2

another() # print 1

start() # prints 3

nonlocal关键字将内部函数绑定到显式提到的外部变量，实际上将其封闭起来。因此更明确的是一个“闭包”。

我遇到了这样一种情况，需要一个单独但持久的名称空间。 我使用课堂。否则我不会。 隔离但持久的名称是闭包。

>>> class f2:
...     def __init__(self):
...         self.a = 0
...     def __call__(self, arg):
...         self.a += arg
...         return(self.a)
...
>>> f=f2()
>>> f(2)
2
>>> f(2)
4
>>> f(4)
8
>>> f(8)
16

# **OR**
>>> f=f2() # **re-initialize**
>>> f(f(f(f(2)))) # **nested**
16

# handy in list comprehensions to accumulate values
>>> [f(i) for f in [f2()] for i in [2,2,4,8]][-1] 
16

def nested1(num1): 
    print "nested1 has",num1
    def nested2(num2):
        print "nested2 has",num2,"and it can reach to",num1
        return num1+num2    #num1 referenced for reading here
    return nested2

给:

In [17]: my_func=nested1(8)
nested1 has 8

In [21]: my_func(5)
nested2 has 5 and it can reach to 8
Out[21]: 13

这是一个关于闭包是什么以及如何使用它的例子。

Python对闭包的支持很弱。要理解我的意思，请参考以下使用JavaScript闭包的计数器示例:

function initCounter(){
    var x = 0;
    function counter  () {
        x += 1;
        console.log(x);
    };
    return counter;
}

count = initCounter();

count(); //Prints 1
count(); //Prints 2
count(); //Prints 3

闭包非常优雅，因为它赋予了这样编写的函数拥有“内部内存”的能力。从Python 2.7开始，这是不可能的。如果你尝试

def initCounter():
    x = 0;
    def counter ():
        x += 1 ##Error, x not defined
        print x
    return counter

count = initCounter();

count(); ##Error
count();
count();

你会得到一个错误，说x没有定义。但如果其他人已经证明你可以打印它，那怎么可能呢?这是因为Python是如何管理函数变量作用域的。内部函数可以读取外部函数的变量，但不能写入它们。

这真是太遗憾了。但是只有只读闭包，你至少可以实现函数装饰器模式，Python为此提供了语法糖。

更新

正如前面所指出的，有很多方法可以处理python的作用域限制，我将介绍一些方法。

1. 使用global关键字(一般不推荐)。

2. 在Python 3中。X，使用nonlocal关键字(建议使用@unutbu和@leewz)

3.定义一个简单的可修改类Object

class Object(object):
    pass

并在initCounter中创建一个Object范围来存储变量

def initCounter ():
    scope = Object()
    scope.x = 0
    def counter():
        scope.x += 1
        print scope.x

    return counter

由于作用域实际上只是一个引用，对其字段所采取的操作并不真正修改作用域本身，因此不会出现错误。

4. @unutbu指出的另一种方法是将每个变量定义为一个数组(x =[0])，并修改它的第一个元素(x[0] += 1)。同样没有出现错误，因为x本身没有被修改。

5. 正如@raxacoricofallapatorius所建议的，你可以让x成为counter的一个属性

def initCounter ():

    def counter():
        counter.x += 1
        print counter.x

    counter.x = 0
    return counter