闭包
由于闭包这个概念比较难以理解，尤其是初学者来说，相对难以掌握，所以我们通过示例去理解学习闭包。
给大家提个需求，然后用函数去实现：完成一个计算不断增加的系列值的平均值的需求。
例如：整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。
比如大众推出了一款新车：小白轿车。
第一天价格为：100000元，平均收盘价：100000元
第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元
第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元
series = []
def make_averager(new_value):
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000))
print(make_averager(110000))
print(make_averager(120000))从上面的例子可以看出，基本上完成了我们的要求，但是这个代码相对来说是不安全的，因为你的这个series列表是一个全局变量，只要是全局作用域的任何地方，都可能对这个列表进行改变。
series = []
def make_averager(new_value):
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000))
print(make_averager(110000))
series.append(666) # 如果对数据进行相应改变，那么你的平均收盘价就会出现很大的问题。
print(make_averager(120000))那么怎么办呢？有人说，你把他放在函数中不就行了，这样不就是局部变量了么？数据不就相对安全了么？
def make_averager(new_value):
series = []
series.append(new_value)
total = sum(series)
return total / len(series)
print(make_averager(100000)) # 100000.0
print(make_averager(110000)) # 110000.0
print(make_averager(120000)) # 120000.0这样计算的结果是不正确的,那是因为执行函数，会开启一个临时的名称空间，随着函数的结束而消失，所以你每次执行函数的时候，都是重新创建这个列表，那么这怎么做呢？这种情况下，就需要用到我们讲的闭包了，我们用闭包的思想改一下这个代码。
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
print(avg(100000))
print(avg(110000))
print(avg(120000))大家仔细看一下这个代码，我是在函数中嵌套了一个函数。那么avg 这个变量接收的实际是averager函数名，也就是其对应的内存地址，我执行了三次avg 也就是执行了三次averager这个函数。那么此时你们有什么问题？
肯定有学生就会问，那么我的make_averager这个函数只是执行了一次，为什么series这个列表没有消失？反而还可以被调用三次呢？这个就是最关键的地方，也是闭包的精华所在。我给大家说一下这个原理，以图为证：
上面被红色方框框起来的区域就是闭包，被蓝色圈起来的那个变量应该是make_averager()函数的局部变量，它应该是随着make_averager()函数的执行结束之后而消失。但是他没有，是因为此区域形成了闭包，series变量就变成了一个叫自由变量的东西，averager函数的作用域会延伸到包含自由变量series的绑定。也就是说，每次我调用avg对应的averager函数 时，都可以引用到这个自用变量series，这个就是闭包。
闭包的定义：
1. 闭包是嵌套在函数中的函数。
2. 闭包必须是内层函数对外层函数的变量（非全局变量）的引用。
如何判断判断闭包？举例让同学回答：
# 例一：
def wrapper():
a = 1
def inner():
print(a)
return inner
ret = wrapper()
# 例二：
a = 2
def wrapper():
def inner():
print(a)
return inner
ret = wrapper()
# 例三：
def wrapper(a,b):
def inner():
print(a)
print(b)
return inner
a = 2
b = 3
ret = wrapper(a,b)以上三个例子，最难判断的是第三个，其实第三个也是闭包，如果我们每次去研究代码判断其是不是闭包，有一些不科学，或者过于麻烦了，那么有一些函数的属性是可以获取到此函数是否拥有自由变量的，如果此函数拥有自由变量，那么就可以侧面证明其是否是闭包函数了（了解）：
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars) # ('series',)
当然还有一些参数，仅供了解：
# 函数名.__code__.co_varnames 查看函数的局部变量
print(avg.__code__.co_varnames) # ('new_value', 'total')
# 函数名.__closure__ 获取具体的自由变量对象，也就是cell对象。
# (<cell at 0x0000020070CB7618: int object at 0x000000005CA08090>,)
# cell_contents 自由变量具体的值
print(avg.__closure__[0].cell_contents) # []闭包的作用：保存局部信息不被销毁，保证数据的安全性。
闭包的应用：
- 可以保存一些非全局变量但是不易被销毁、改变的数据。
- 装饰器。
闭包的解释:
闭包是存在嵌套函数当中的 内层对外层非全局变量的的引用 ,称之为自由变量 它不会随着函数的结束而消失,一直保存在内存,最终的目的是保证数据的安全
装饰器
开放封闭原则
软件面世时,不可能吧所有的功能都设计好,当前的未来一两年功能给你上线,定期更新迭代.对于软件之前写的源代码一般都不会修改,对函数里面的代码以及函数的调用方式.
开放原则: 在源码不改变的情况下,增加一些额外的功能
封闭原则: 不要改变源代码
python中装饰器: 完美诠释的开放封闭原则
装饰器 就是个函数 : 他要装饰一个函数,在不改变原函数以及调用方式的前提下,给其增加一个额外的功能
装饰器初识
# 1 李业，在一家xx科技有限公司工作，主管安排了一个任务，
# 写一个代码测试怼怼哥写的函数的执行效率。
# import time
# def index():
# time.sleep(2)
# print('欢迎访问博客园首页')
# print(time.time())
# start_time = time.time()
# index()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# 2. 主管让你测试小邓，李大象,重复代码太多。
#
# def func1():
# time.sleep(2)
# print('欢迎访问日记首页')
#
#
# def func2():
# time.sleep(1)
# print('欢迎访问评论首页')
# start_time = time.time()
# func1()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
#
# start_time = time.time()
# func2()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# 3. 整合到函数中
# def func1():
# time.sleep(2)
# print('欢迎访问日记首页')
#
#
# def func2():
# time.sleep(1)
# print('欢迎访问评论首页')
# def test_time(x):
# start_time = time.time()
# x()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# test_time(func1)
# test_time(func2)
# 4. 怼怼哥这个函数在实际项目中被500执行，主管要求：在被执行此函数时，
# 同时要测试一下被执行函数的效率。
# def index():
# time.sleep(2)
# print('欢迎访问博客园首页')
#
# # index()
# def test_time(x):
# start_time = time.time()
# x()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
#
# test_time(index)
# 版本4的问题： 开放原则满足了，封闭原则：不改变原函数的源码，以及调用方式。
# 违反了封闭原则：改变了函数的调用方式。
# 版本5： 不能改变原函数的调用方式（闭包）：
# def index():
# time.sleep(2)
# print('欢迎访问博客园首页')
#
# # index()
#
# # def func1():
# # time.sleep(2)
# # print('欢迎访问日记首页')
#
# def test_time(x): # x = index
# def inner():
# start_time = time.time()
# x()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# return inner
#
# index = test_time(index)
# index()
# 语法糖 @加上装饰器函数的名
# def f():
# print(666)
#
#
# f = '太白'
# print(f)
# def test_time(x): # x = index
# def inner():
# start_time = time.time()
# x()
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# return inner
#
#
# # @test_time # index = test_time(index)
# def index():
# time.sleep(2)
# print('欢迎访问博客园首页')
# index = test_time(index)
# index()
# def func1():
# time.sleep(2)
# print('欢迎访问日记首页')
# @test_time
# def func2():
# time.sleep(1)
# print('欢迎访问评论首页')
# func2 = test_time(func2)
# func3 = test_time(func3)
# func2()
'''100行代码'''
# index()
'''10行代码'''
# index()
'''50行代码'''
# index()
# 版本6：被装饰函数有返回值
# def test_time(x): # x = index
# def inner():
# start_time = time.time()
# ret = x()
# # print(F'ret: {ret}')
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# return ret
# return inner
#
#
# @test_time # index = test_time(index)
# def index():
# time.sleep(0.5)
# print('欢迎访问博客园首页')
# return True
#
# print(index()) # inner()
# 你应该是让True返回给index()这样才完美了，但是现在index是inner，所以你要是完全不改变原函数的使用，
# 你print(index()) ---> True
# 版本7： 被装饰函数带参数，无论加不加装饰器，你的实参'太白金星'应该传给形参n,。
# 但版本6不能实现传参，index('太白金星') == inner('太白金星')
#
# def test_time(x): # x = index
# def inner(*args,**kwargs):
# # 函数的定义：* ** 聚合。
# # args = ('苹果')
# #args = (1, 3)
# start_time = time.time()
# ret = x(*args,**kwargs)
# # 函数的执行：* ** 打散。
# # ret = x(*('苹果')) ==x('苹果',)
# # ret = x(*(1, 3)) ==x(1,3)
# # print(F'ret: {ret}')
# end_time = time.time()
# print(f'此函数的执行效率{end_time-start_time}')
# return ret
# return inner
#
#
# # @test_time # index = test_time(index)
# def index(n):
# time.sleep(0.5)
# print(f'欢迎{n}访问博客园首页')
# return True
#
# # @test_time # index = test_time(index)
# def func2(a,b):
# time.sleep(0.5)
# print(f'最终结果：{a+b}')
# return a + b
#
#
# print(index('苹果')) # inner('苹果')
# print(func2(1,3)) # == inner(1,3)
# def warpper(f):
# def inner(*args,**kwargs):
# '''被装饰函数之前的操作'''
# # print(666)
# ret = f(*args,**kwargs)
# '''被装饰函数之后的操作'''
# # print('执行完毕了')
# return ret
# return inner
#
# @warpper
# def func():
# print(111)
# #
# func()
# func()
# func()
# func()
# func()
# 装饰器的应用：在不改变原函数的源码以及调用方式前提下，为其增加额外的功能。
# 登陆认证，打印日志等。带参数装饰器
def wrapper(f):
def inner(*args,**kwargs):
if f.__name__ == 'qq':
ret = f(*args,**kwargs)
return ret
else:
return inner
def wrapper(f):
def inner(*args, **kwargs):
ret = f(*args, **kwargs)
return ret
return inner
def wrapper_out(n,*args,sex='男',):
def wrapper(f): # f
def inner(*args,**kwargs):
ret = f(*args,**kwargs) # func1()
return ret
return inner
return wrapper
def func1():
print('in func1')
func = wrapper_out(1) # wrapper函数名
ly = func(func1) # wrapper(func1) = inner
ly() # inner()
def wrapper_out(n):
def wrapper(f):
def inner(*args,**kwargs):
# if n == 'qq':
# username = input('请输入用户名：').strip()
# password = input('请输入密码：').strip()
# with open('qq',encoding='utf-8') as f1:
# for line in f1:
# user,pwd = line.strip().split('|')
# if username == user and password == pwd:
# print('登陆成功')
# ret = f(*args,**kwargs)
# return ret
# return False
# elif n == 'tiktok':
# username = input('请输入用户名：').strip()
# password = input('请输入密码：').strip()
# with open('tiktok', encoding='utf-8') as f1:
# for line in f1:
# user, pwd = line.strip().split('|')
# if username == user and password == pwd:
# print('登陆成功')
# ret = f(*args, **kwargs)
# return ret
# return False
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
with open(n,encoding='utf-8') as f1:
for line in f1:
user,pwd = line.strip().split('|')
if username == user and password == pwd:
print('登陆成功')
ret = f(*args,**kwargs)
return ret
return False
return inner
return wrapper
"""
# @wrapper_out('qq')
# def qq():
# print('成功访问qq')
# qq()
# 看到带参数的装饰器分两步执行：
'''
@wrapper_out('腾讯')
1. 执行wrapper_out('腾讯') 这个函数，把相应的参数'腾讯' 传给 n,并且得到返回值 wrapper函数名。
2. 将@与wrapper结合，得到我们之前熟悉的标准版的装饰器按照装饰器的执行流程执行。
'''
"""
@wrapper_out('qq')
def qq():
print('成功访问qq')
@wrapper_out('tiktok')
def tiktok():
print('成功访问抖音')
qq()
tiktok()
开发思路：增强耦合性多个装饰器装饰一个函数
def wrapper1(func1): # func1 = f原函数
def inner1():
print('wrapper1 ,before func') # 2
func1()
print('wrapper1 ,after func') # 4
return inner1
def wrapper2(func2): # func2 == inner1
def inner2():
print('wrapper2 ,before func') # 1
func2() # inner1
print('wrapper2 ,after func') # 5
return inner2
@wrapper2 # f = wrapper2(f) 里面的f == inner1 外面的f == inner2
@wrapper1 # f = wrapper1(f) 里面的f == func1 外面的 f == inner1
def f():
print('in f') # 3
f() # inner2()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
