Python中的闭包

当某个函数被当成对象返回时，夹带了外部变量，就形成了一个闭包。

def make_printer(msg):
   def printer():
       print（msg）  # 夹带私货（外部变量）
   return printer  # 返回的是函数，带私货的函数
printer = make_printer('Foo!')
printer()

同一个的函数夹带了不同的私货，就实现了不同的功能。

def tag(tag_name):
    def add_tag(content):
        return "<{0}>{1}</{0}>".format(tag_name, content)

    return add_tag


content = 'Hello'

add_tag = tag('a')
print(add_tag(content))
# <a>Hello</a>

add_tag = tag('b')
print(add_tag(content))
# <b>Hello</b>

Python中的装饰器Decorator，假如你需要写一个带参数的装饰器，那么一般都会生成闭包。

# how to define
def wrapper(func1):  # 必须接受一个且仅一个函数作为参数
   return func1  # 返回一个且仅一个callable对象，一般为函数

# how to use
def target_func(args):# 目标函数
   pass

# 调用方式一，直接包裹
result = wrapper(target_func)(args)

# 调用方式二，使用@语法，等同于方式一
@wrapper
def target_func(args):
   pass

result = target_func()

装饰器如果带参数呢？那么就需要在原来的装饰器上再包一层，用于接收这些参数。这些参数（私货）传递到内层的装饰器里后，闭包就形成了。所以说当装饰器需要自定义参数时，一般都会形成闭包。（类装饰器例外）

def html_tags(tag_name):
   def wrapper_(func):
       def wrapper(*args, **kwargs):
           content = func(*args, **kwargs)
           return "<{tag}>{content}</{tag}>".format(tag=tag_name, content=content)
       return wrapper
   return wrapper_

@html_tags('b')
def hello(name='Toby'):
   return'Hello {}!'.format(name)

# 不用@的写法如下
# hello = html_tag('b')(hello)
# html_tag('b') 是一个闭包，它接受一个函数，并返回一个函数

print(hello())  # <b>Hello Toby!</b>
print(hello('world'))  # <b>Hello world!</b>

其实闭包函数相对与普通函数会多出一个__closure__的属性，里面定义了一个元组用于存放所有的cell对象，每个cell对象一一保存了这个闭包中所有的外部变量。

>>> def make_printer(msg1, msg2):
        def printer():
            print(msg1, msg2)
        return printer
>>> printer = make_printer('Foo', 'Bar')  # 形成闭包

>>> printer.__closure__   # 返回cell元组
(<cell at 0x03A10930: str object at 0x039DA218>, <cell at 0x03A10910: str object at 0x039DA488>)

>>> printer.__closure__[0].cell_contents  # 第一个外部变量
'Foo'
>>> printer.__closure__[1].cell_contents  # 第二个外部变量
'Bar'