====================(一)
#闭包:1.函数内嵌套函数 2.内部函数引用外部函数的变量 3.闭包(外部函数)返回值是内部函数, #函数也是一个类型(function) def test(number): def test_2(number_in): return number * number_in return test_2 rs = test(10) #此时局部变量应该在内存中被释放掉,但却没有被释放, #rs既是test2,由于内部函数引用了 s = rs(20) print(s) def sum(a,b): def numbers(x,y): return a*x+b*x+a*y+b*y return numbers num = sum(10,20) rs = num(30,40) print(rs) #闭包定义装饰器 #把一个函数作为一个参数 def wl(func): def inner(): return func() return inner #@wl 装饰器 返回一个内部函数inner #在装饰器下定义的f1函数实际上就是传递到装饰器的函数 from datetime import datetime def for_test(): start_time = datetime.now() for x in range(10000): c = x*x print(datetime.now()-start_time) # -*- coding:utf-8 -*- __author__ = 'rxf' def eat(): pass print(type(eat)) def test(number): # number 局部变量 def test2(number_in): # test2 内部函数 return number * number_in return test2 rs = test(10) s = rs(20) print(s) # 带两个参数的 def sum(a, b): def num(x): return a * x + b * x return num num = sum(10,20) print(num) rs = num(30) print(rs) # 利用闭包自定义装饰器 # func 把一个函数作为参数 def w1(func): def inner(): # 返回调用传递进来的函数执行的结果 return func() return inner # @w1 装饰器 返回一个内部函数inner # 装饰器的作用：在不更改原始函数的基础上，为函数添加一些额外功能 # 在装饰器下定义的f1函数实际上就是传递到装饰器的参数 @w1 def f1(): return 1234 rs = f1() print(rs) from datetime import datetime # 打印输出某个函数执行消耗的时间 def run_time(func): def test(): # 获取开始执行的时间 start_time = datetime.now() func() print(datetime.now() - start_time) return test @run_time def for_test(): for x in range(10000): c = x+x for_test() @run_time def for00_test(): for x in range(1000000): c = x*x for00_test() # 带参数的装饰器 def test(name): if name == '张三': def run(func): def sleep(): func() return sleep return run else: def error(func): def test(): print('塔拉黑哒') return test return error @test('三') def eat(): print('米西米西') eat()
=====================(二)
#coding:utf-8 # 闭包:1.函数内嵌套函数 2.内部函数引用外部函数的局部变量 3.外部函数的返回值是内部函数 # def eat(): # pass # <class 'function'> 函数的类型 # print(type(eat)) def test(number): # number 局部变量,生命周期 从声明开始往下,到代码块结束 def test_2(number_in): # 内部函数引用外部函数局部变量 return number * number_in # 返回一个函数对象 return test_2 # <function test.<locals>.test_2 at 0x00000000004837B8> test_2函数对象 # 执行test函数后返回的是一个函数对象,这个对象就是test_2 # 由于内部函数引用了外部函数的局部变量,导致外部函数执行完之后,局部变量没有及时释放,占用内存 rs = test(10) # 因为rs是一个函数对象,可以被执行,rs(20)相当执行了test_2这个函数,在test_2中引用了test中的局部变量number,并且test返回的就是test_2这函数,所以我们称test_2为闭包 s = rs(20) print(s) # 带两个参数的 def sum(a,b): def numbers(x,y): return a*x+b*x+a*y+b*y return numbers num = sum(10,20) rs = num(30,40) print(rs) # 利用闭包自定义装饰器 # func 把一个函数作为参数 def w1(func): def inner(): # 返回调用传递进来的函数执行的结果 return func() return inner # @w1 装饰器 返回一个内部函数inner # 装饰器的作用:在不更改原始函数的基础上,为函数添加一些额外功能 # 在装饰器下定义的f1函数实际上就是传递到装饰器的参数 @w1 def f1(): return 123456 rs = f1() print(rs) # 打印输出某个函数执行消耗的时间 from datetime import datetime def run_time(func): def test(): # 获取开始执行的时间 start_time = datetime.now() func() # 计算执行消耗的时间 print('执行{},消耗了{}时间'.format(func.__name__,datetime.now() - start_time) ) return test @run_time def for_test(): for x in range(10000): c = x+x for_test() @run_time def for1000000_tetst(): for x in range(1000000): c = x * x for1000000_tetst() # 带参数的装饰器 def test(name): if name == '张三': # 定义装饰器用到闭包 def run(func): def sleep(): func() return sleep return run else: def error(func): def run() print('你不是张三,没有权限吃饭') return error @test('李四') def eat(): print('只有张三才能吃饭') eat()
=============(三)
# 在不更改eat函数内部代码的情况下,添加吃饭执行了多长时间 from datetime import datetime # 封装成一个函数 # 该函数中需要执行被传递进来函数对象,并且在执行前获取时间,执行后减去执行前的时间 def run_time(func): def test(): start = datetime.now() func() print(datetime.now() - start) return test # 下面的装饰器 等同于这句话 eat = run_time(eat) @run_time def eat(): print('吃饭了') # 把eat函数对象传递到run_time函数中 # 当调用eat()函数时,实际上执行的闭包中的test()函数 eat() def premission(form_role): # 函数装饰器的开始 def role(func): def test(): if 3 > form_role: func() else: print('没有权限') return test return role # premission(2) 返回role函数对象 # 相当于写了@role # 装饰器执行完成之后相当于 sleep = role(sleep) @premission(5) def sleep(): print('睡觉了...') sleep() # 下面的写法等同于使用装饰器的写法 # 1.执行premission(2)返回role函数 # role = premission(2) # 2.执行role返回test函数,并赋值给sleep # sleep = role(sleep) # 3.执行sleep()就是执行test() # sleep()