一、定义
如果一个函数定义在另一个函数内部,而内部函数使用了外部函数的变量,则称这个内部函数为闭包。也就是说,当某个函数被当成对象返回时,夹带了外部变量,就形成了一个闭包。
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) # 第二个外部变量