Python 闭包与装饰器（上篇）

# hello_closure.py ​ bar = "Hello!"  # 自由变量 bar ​ print("1. hello_closure module bar: %s" % bar) ​ def foo():     global bar  # 参见名字搜索规则 LEGB     print("3. hello_closure module bar: %s" % bar)  # 开始引用外部的自由变量     bar = bar + " Closure!"     print("4. hello_closure module bar: %s" % bar) ​ ​ if __name__ == "__main__":     print("2. hello_closure module bar: %s" % bar)     foo()     print("5. hello_closure module bar: %s" % bar)     foo()     print("6. hello_closure module bar: %s" % bar)     bar = "Hello!"     print("7. hello_closure module bar: %s" % bar) ​ 1. hello_closure module bar: Hello! 2. hello_closure module bar: Hello! 3. hello_closure module bar: Hello! 4. hello_closure module bar: Hello! Closure! 5. hello_closure module bar: Hello! Closure! 3. hello_closure module bar: Hello! Closure! 4. hello_closure module bar: Hello! Closure! Closure! 6. hello_closure module bar: Hello! Closure! Closure! 7. hello_closure module bar: Hello!

# test.py - 该模块与 hello_closure.py 同级 ​ from hello_closure import foo ​ bar = "Hi!" ​ # 以下三次 foo 函数调用属于同一个闭包实例 print("1. test module bar: %s" % bar) foo() print("2. test module bar: %s" % bar) foo() print("3. test module bar: %s" % bar) foo() ​ 1. hello_closure module bar: Hello! 1. test module bar: Hi! 3. hello_closure module bar: Hello! 4. hello_closure module bar: Hello! Closure! 2. test module bar: Hi! 3. hello_closure module bar: Hello! Closure! 4. hello_closure module bar: Hello! Closure! Closure! 3. test module bar: Hi! 3. hello_closure module bar: Hello! Closure! Closure! 4. hello_closure module bar: Hello! Closure! Closure! Closure!

# some_closures.py ​ def create_closure_bar():     foo = "Hello!"     def bar():         print(foo)     foo = foo + " Closure!"  # 对于读操作，根据 Python 的 LEGB 规则从变量名称关联的目标对象进行读取，对于写操作，默认始终从 L(ocals) 中查找目标对象     return bar ​ ​ # 如果非要实现等同之前示例的闭包，则 Python 3 中可以写成下方这样 # def create_closure_bar(): #     foo = "Hello!"  # 局部变量 foo #     def bar(): #         nonlocal foo  # 声明 foo 变量为非 L(ocals) 变量。nonlocal 关键字用来在函数或其他作用域中使用外层（非全局）变量，也即 nonlocal 只能绑定局部变量 #         foo = foo + " Closure!" #         print(foo) #     return bar ​ ​ # 如果非要实现等同之前示例的闭包，则 Python 2/3 中可以写成下方这样 # def create_closure_bar(): #     foo = ["Hello!"]  # 容器变量 foo，其元素 "Hello!" 存储在堆上 #     def bar(): #         foo[0] = foo[0] + " Closure!"  # foo[0] 指向 "Hello!" 的引用，而不是 "Hello!" 这个目标对象，因此，可以进行写操作 #         print(foo[0]) #     return bar ​ ​ if __name__ == "__main__":     bar = create_closure_bar()  # 此时可以保证变量 foo 和闭包函数 bar 的生命周期一致，创建闭包函数 bar     bar()  # 调用闭包函数（相当于在前文 test 模块中调用 bar）     bar()  # 由于 LEGB 规则仅限于读取操作，因此这里 foo 变量的值与上一次调用一致。也即每次调用，都是单独的闭包实例 ​ Hello! Closure! Hello! Closure!

# examples.py ​ # example 1 def make():     x = [1, 2]     return lambda: print(x) ​ a = make() a() ​ [1, 2]

# example 2 def make():     x = 100     def test():          print(x)     return test  f = make() f()   100

# example 3 def make():     x = [1, 2]     print(hex(id(x)))     return lambda: print(x)  f = make()  print(f.__closure__)  # 闭包所引用的环境变量（自由变量），它被保存在函数对象的 __closure__ 属性中  f()  print(f.__code__.co_freevars)  # ('x',) 当前函数引用外部自由变量列表 print(make.__code__.co_cellvars)  # ('x',) 被内部闭包函数引用的变量列表   0x1f635713a88 (<cell at 0x000001F635721558: list object at 0x000001F635713A88>,) [1, 2] ('x',) ('x',)

# example 4 def make(x):     return lambda: print(x)  a = make([1, 2]) b = make(100)  print(a is b)  # False 每次返回新的函数对象实例  print(a.__closure__) print(b.__closure__)  print(a.__closure__[0].cell_contents)  # cell_contents 属性返回闭包中的自由变量   False (<cell at 0x000001F6357215E8: list object at 0x000001F6357282C8>,) (<cell at 0x000001F635721A08: int object at 0x00007FF977197D60>,) [1, 2]

# example 5 多个闭包共享同一自由变量。实质上和我们之前一个闭包的不同实例共享一个自由变量并更改了该自由变量值的例子是类似的 def queue():     data = []          push = lambda x: data.append(x)     pop = lambda: data.pop(0) if data else None          return push, pop  push, pop = queue()  # push 与 pop 共享自由变量 data  print(push.__closure__ == pop.__closure__)  # True  值相等 print(push.__closure__) print(pop.__closure__)  for i in range(10, 13):     push(i)  while True:     x = pop()     if not x:         break     print(x)   True (<cell at 0x000001F635619408: list object at 0x000001F635725108>,) (<cell at 0x000001F635619408: list object at 0x000001F635725108>,) 10 11 12

# example 6 自引用 1 def make(x):     def test():         test.x = x  # 引用自己，效果相当于 this，并增加属性 x         print(test.x)     return test  a, b = make(1234), make([1, 2]) print(a.__closure__)  # 自由变量中包括闭包本身和属性 x print(b.__closure__)  # 自由变量中包括闭包本身和属性 x  a() b() print(hasattr(a, "x"))  # True   (<cell at 0x000001F6357212B8: function object at 0x000001F63572CC18>, <cell at 0x000001F635721B58: int object at 0x000001F63573E270>) (<cell at 0x000001F6357217C8: function object at 0x000001F63572C3A8>, <cell at 0x000001F635721408: list object at 0x000001F635728908>) 1234 [1, 2] True

# example 7 延迟绑定 def make(n):     x = []          for i in range(n):         x.append(lambda: print(i))     return x  a, b, c = make(3) a(), b(), c()  # 2 2 2 x 列表 x 中的闭包在执行中均保存变量 i 的引用，当 make 执行结束，i 等于 2，执行闭包时，打印引用变量 i 的值 2  print(a.__closure__)  # 存储的是 cell 对象，该对象内部引用了函数关联的自由变量（而不是直接存储自由变量） print(b.__closure__) print(c.__closure__)   2 2 2 (<cell at 0x000001F635619A38: int object at 0x00007FF977197120>,) (<cell at 0x000001F635619A38: int object at 0x00007FF977197120>,) (<cell at 0x000001F635619A38: int object at 0x00007FF977197120>,)

# example 8 使用复制解决延迟绑定问题  广义上的闭包，非 Python 闭包 def make(n):     x = []          for i in range(n):         x.append(lambda o=i: print(0))     return x  a, b, c = make(3) a(), b(), c()  # 0 1 2 匿名函数的参数 o 是私有变量，也即变量 o 是不共享的。其复制执行时当前 i 引用的整数对象的引用  print(a.__closure__)  # None print(b.__closure__)  # None print(c.__closure__)  # None   0 1 2 None None None

# example 9 自引用 2  在其他模块导入 make 时，可形成广义上的闭包，非 Python 闭包 x = "hello" def make():     make.x = x  # 引用自己，效果相当于 this，并增加属性 x     print(make.x)  make() print(make.__closure__)  # None   hello None

# example 10 自引用 3  在其他模块导入 make 时，非广义上的闭包，也非 Python 闭包。 def make(x):     make.x = x  # 引用自己，效果相当于 this，并增加属性 x     print(make.x)  make("closure") print(make.__closure__)  # None   closure None