python闭包

python闭包

闭包的条件

1.闭包函数必须返回一个函数对象

2.闭包函数内部的函数必须引用外部的函数的变量，(一般不能引用全局的变量)，里面函数的返回值可有可无

闭包格式

def 外层函数(参数):
    def 内层函数():
        print("内层函数执行", 参数)

    return 内层函数


内层函数的引用 = 外层函数("传入参数")
内层函数的引用()

__closure__查看闭包引用的外部函数作用域的值

首先是一个元组

def zx():
    a=1
    b=2
    def inner(z):
        print(a+b+z)
    return inner

wl = zx()
print(wl.__closure__.__class__)
print(wl.__closure__)

for i in wl.__closure__:
    print(i.cell_contents)
    
<class 'tuple'>
(<cell at 0x0000015AB9DDACA8: int object at 0x000000006AED6DE0>, <cell at 0x0000015AC8FC14F8: int object at 0x000000006AED6E00>)
1
2

Process finished with exit code 0

注意

1.内部函数如果不引用外部函数的值，那么__closure__一直为None

2.如果主函数没有返回子函数，那么没有__closure__属性

闭包的意义

1.返回的函数对象，不仅仅是一个函数对象，这个对象外部还包裹着一层作用域，可以在这层作用域中放入想要的参数，这样就可以使函数对象无论什么时候优先使用这层作用域中的值，有屏蔽全局作用域的作用

2.外部无法访问嵌套函数内部的变量，只能靠函数返回的对象，在能访问这些变量

闭包案例

从例子中可以看出，函数无法保存for产生的临时变量，最后都指向最后一个，如果有需求要保存临时变量怎么解决呢？这个时候就需要用到闭包了

lis = []
for i in range(3):
    def zx(a):
        return a+i
    lis.append(zx)

for f in lis:
    print(f(2))
    
4
4
4

使用闭包,就可以保存for产生的临时变量，保存到函数的局部作用域中

lis = []
for i in range(3):
    def zx(i):
        def inner(a):
            return a+i
        return inner
    lis.append(zx(i))

for f in lis:
    print(f(2))
    
2
3
4

闭包的应用

1.装饰器

def login_auth(func):
    def inner(*args,**kwargs):
        #业务逻辑
        res = func(*args,**kwargs)
        return res
    return inner

2.爬虫

import requests

def outter(url):
    def get():
        response = requests.get(url)
        print(f"done: {url}")
    return get

baidu=outter('https://www.baidu.com')
python = outter('https://www.python.org')

baidu()

3.闭包可以保存运行环境

def zx(a):
    def inner():
        print(a)
    return inner

wl = zx(10)
a=100
wl()

10

闭包的实际案例

def who(name):
    def do(what):
        print(name,'说:',what)
    return do

zx = who('zx')
wl = who('wl')

zx('吃饭去啊')
wl('好啊')

zx 说: 吃饭去啊
wl 说: 好啊

参考链接

https://blog.csdn.net/sc_lilei/article/details/80464645

python闭包

原文：https://www.cnblogs.com/zx125/p/11844290.html