Python中的闭包_python 闭包

一、定义

如果一个函数定义在另一个函数内部，而内部函数使用了外部函数的变量，则称这个内部函数为闭包。也就是说，当某个函数被当成对象返回时，夹带了外部变量，就形成了一个闭包。

def make_printer(msg):
    def printer():
        print(msg)
    return printer
 
if __name__ == '__main__':
    printer1 = make_printer('fool')
    printer2 = make_printer('stupid')
    printer1()
    printer2()
'
运行
运行

  

二、特点

1、内部函数引用了外部函数的变量，这些变量不会在函数调用结束后被销毁。

2、外部函数返回内部函数的引用，这些外部函数的局部变量就可以被内部函数访问和修改。

三、意义

闭包存在的意义就是它夹带了外部变量（私货），如果它不夹带私货，它和普通的函数就没有任何区别。同一个的函数夹带了不同的私货，就实现了不同的功能。

def tag(tag_name):
    def add_tag(content):
        print('<{0}>{1}</{0}>'.format(tag_name, content))
    return add_tag
 
content = 'hello'
 
if __name__ == '__main__':
    add_tag = tag('a')
    add_tag(content)
    add_tag = tag('b')
    add_tag(content)
'
运行
运行

 四、闭包应用场景

1、Python中的装饰器Decorator

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

装饰器：在不改变原有函数代码的情况下，增加额外的功能，比如日志记录，性能分析等。装饰器的详解参考 Python中的装饰器

初级装饰器通用写法：

'''
def wrapper(func1):
    return func2
# 调用方式一，直接包裹
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') 是一个闭包，它接受一个函数，并返回一个函数
 
if __name__ == '__main__':
    # print(hello())  # <b>Hello Toby!</b>
    print(hello('world'))  # <b>Hello world!</b>
'
运行
运行

 

2、缓存函数

使用memorize装饰器将计算结果缓存起来，以避免重复计算。 

def memoize(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
    return wrapper
 
def fibonacci(n):
    if n in (0, 1):
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
if __name__ == '__main__':
    print(fibonacci(10))
'
运行
运行

在这个例子中，我们定义了一个memoize装饰器函数，它可以缓存被装饰函数的结果。 

3、延迟执行

闭包可以用来实现延迟执行，也就是在函数被调用时才进行计算。这可以提高程序的性能，特别是在计算复杂的表达式时。 

def delayed_sum(a, b):
    def sum():
        return a + b
    return sum
 
if __name__ == '__main__':
    result = delayed_sum(1, 2)
    print(result())  # 3
'
运行
运行

当我们调用delayed_sum函数时，它不会计算a和b的和，而是返回一个sum函数。当我们调用sum函数时，它才会计算a和b的和并返回结果。 

4、实现类似于私有变量的功能

def counter():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner
 
if __name__ == '__main__':
    c1 = counter()
    c2 = counter()
    print(c1())
    print(c1())
    print(c2())
    print(c2())
'
运行
运行

  

由于 Python 中没有直接定义私有变量的语法，我们使用了一个内部函数（inner）来访问外部函数（counter）中的变量（count）。 

五、闭包的原理

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

def make_printer(msg1, msg2):
    def printer():
        print(msg1, msg2)
    return printer
 
printer = make_printer('Foo', 'Bar')  # 形成闭包
 
print(printer.__closure__)  # 返回cell元组
 
print(printer.__closure__[0].cell_contents)  # 第一个外部变量
 
print(printer.__closure__[1].cell_contents)  # 第二个外部变量
'
运行
运行