Python—闭包

闭包

什么是闭包

闭是封闭（函数中的函数），包是包含（该内部函数对外部函数作用域而非全局作用域变量的引用）

闭包：

• 内部函数对外部函数作用域里的变量的引用

• 函数内的属性，都是有生命周期，都是在函数执行期间

• 闭包内的闭包函数私有化了变量，完成了数据的封装，类似面向对象

demo：

def foo():
    print('in foo()')
    def bar():
        print('in bar()')
# 1.直接运行内部函数报错
# bar()

# 2.考虑先运行外部函数，再运行内部函数，依然会报错
# foo()
# bar()

由于作用域的问题，函数内的属性，都是有生命周期的，只有在函数执行期间再考虑在这段代码，只有在调用foo()时，内部的print()及bar()才能存活

现在我们为了让foo()内的bar()存活，就是调用bar()，我们该怎么做？

把bar()函数返回给函数

def foo():
    print('in foo()')
    def bar():
        print('in bar()')
    return bar
var=foo()
var()

in foo()
in bar()

前面说，内部函数对外部函数作用域变量的引用—>如果是变量呢

def foo():
    a=66
    print(a)
    print('in foo()')
    def bar(num):
        print('in bar()')
        print(a+num)
    def bar1(num1):
        print('in bar()')
        print(a-num1)
    return bar,bar1
    # bar(22) bar1(22)

var,var1=foo()
var(22)
var1(22)

66
in foo()
in bar()
88
in bar()
44

li=[1,2,3,4]
def foo(obj):
    print('foo',obj)
    def bar():
        obj[0]+=1
        print('bar',obj)
    return bar
# 程序在运行时，foo()函数返回给了内部定义的bar()函数
var=foo(li)
var()
var()

foo [1, 2, 3, 4]
bar [2, 2, 3, 4]        
bar [3, 2, 3, 4]        # 把上次的运行作为输入运行代码

利用闭包实现棋子移动

def outer():
    # 在外部函数中定义一个保存坐标的列表
    position=[0,0]
    # 定义一个内部函数，参数为移动方式和步长
    # 移动方式为列表[x,y]x，y分别只能取-1,0,1三个值，表示反向，不动，正向
    def inner(direction,step):
        # 计算坐标值
        position[0]=position[0]+direction[0]*step
        position[1] = position[1] + direction[1] * step
        # 返回移动后的坐标
        return position
    # 返回内部函数
    return inner
# 获取内部函数
move=outer()
# 移动
print(move([1,0],10))
print(move([0,1],10))
print(move([-1,0],10))

[10, 0]
[10, 10]
[0, 10]