闭包 闭包的介绍 我们前面已经学过了函数,我们知道当函数调用完,函数内定义的变量都销毁了,但是我们有时候需要保存函数内的这个变量,每次在这个变量的基础上完成一些列的操作,比如: 每次在这个变量的基础上和其它数字进行求和计算,那怎么办呢?
我们就可以通过咱们今天学习的闭包来解决这个需求。
闭包的定义 : 在函数嵌套的前提下,内部函数使用了外部函数的变量,并且外部函数返回了内部函数,我们把这个使用外部函数变量的内部函数称为闭包。
闭包的构成条件 通过闭包的定义,我们可以得知闭包的形成条件:
在函数嵌套(函数里面再定义函数)的前提下
内部函数使用了外部函数的变量(还包括外部函数的参数)
外部函数返回了内部函数
简单闭包的示例代码 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def func_out (num1) : def func_inner (num2) : result = num1 + num2 print("结果是:" , result) return func_inner f = func_out(1 ) f(2 ) f(3 )
运行结果:
闭包执行结果的说明:
通过上面的输出结果可以看出闭包保存了外部函数内的变量num1,每次执行闭包都是在num1 = 1 基础上进行计算。
闭包的作用
闭包可以保存外部函数内的变量,不会随着外部函数调用完而销毁。
注意点:
由于闭包引用了外部函数的变量,则外部函数的变量没有及时释放,消耗内存。
小结
当返回的内部函数使用了外部函数的变量就形成了闭包
闭包可以对外部函数的变量进行保存
实现闭包的标准格式:
1 2 3 4 5 6 7 8 9 def test1 (a) : b = 10 def test2 () : print(a, b) return test2
闭包的使用 案例 需求: 根据配置信息使用闭包实现不同人的对话信息,例如对话:
张三: 到北京了吗? 李四: 已经到了,放心吧。
实现步骤说明
定义外部函数接收不同的配置信息参数,参数是人名
定义内部函数接收对话信息参数
在内部函数里面把配置信息和对话信息进行拼接输出
功能代码的实现 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 def config_name (name) : def say_info (info) : print(name + ": " + info) return say_info tom = config_name("Tom" ) tom("你好!" ) tom("你好, 在吗?" ) jerry = config_name("jerry" ) jerry("不在, 不和玩!" )
运行结果:
1 2 3 Tom: 你好! Tom: 你好, 在吗? jerry: 不在, 不和玩!
闭包案例说明:
闭包还可以提高代码的可重用性,不需要再手动定义额外的功能函数。
小结
闭包不仅可以保存外部函数的变量还可以提高代码的可重用行。
修改闭包内使用的外部变量 修改闭包内使用的外部变量 修改闭包内使用的外部变量的错误示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 def func_out (num1) : def func_inner (num2) : num1 = 10 result = num1 + num2 print("结果是:" , result) print(num1) func_inner(1 ) print(num1) return func_inner f = func_out(1 ) f(2 )
修改闭包内使用的外部变量的错误示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 def func_out (num1) : def func_out (num1) : def func_inner (num2) : nonlocal num1 num1 = 10 result = num1 + num2 print("结果是:" , result) print(num1) func_inner(1 ) print(num1) return func_inner f = func_out(1 ) f(2 )
小结
修改闭包内使用的外部函数变量使用 nonlocal 关键字来完成。
装饰器 装饰器的定义 就是给已有函数增加额外功能的函数,它本质上就是一个闭包函数 。
装饰器的功能特点:
不修改已有函数的源代码
不修改已有函数的调用方式
给已有函数增加额外的功能
装饰器的示例代码 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 def check (fn) : def inner () : print("请先登录...." ) fn() return innerdef comment () : print("发表评论" ) comment = check(comment) comment()
代码说明:
闭包函数有且只有一个参数,必须是函数类型,这样定义的函数才是装饰器。
写代码要遵循开放封闭原则,它规定已经实现的功能代码不允许被修改,但可以被扩展。
执行结果:
装饰器的语法糖写法 如果有多个函数都需要添加登录验证的功能,每次都需要编写func = check(func)
这样代码对已有函数进行装饰,这种做法还是比较麻烦。
Python给提供了一个装饰函数更加简单的写法,那就是语法糖,语法糖的书写格式是: @装饰器名字,通过语法糖的方式也可以完成对已有函数的装饰
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def check (fn) : print("装饰器函数执行了" ) def inner () : print("请先登录...." ) fn() return inner@check def comment () : print("发表评论" ) comment()
说明:
@check
等价于 comment = check(comment)
装饰器的执行时间是加载模块时立即执行。
执行结果:
小结
装饰器的语法糖用法: @装饰器名称,同样可以完成对已有函数的装饰操作。
装饰器的使用 装饰器的使用场景
函数执行时间的统计
输出日志信息
装饰器实现已有函数执行时间的统计 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 import timedef get_time (func) : def inner () : begin = time.time() func() end = time.time() print("函数执行花费%f" % (end-begin)) return inner@get_time def func1 () : for i in range(100000 ): print(i) func1()
执行结果:
1 2 3 4 5 6 7 ...99995 99996 99997 99998 99999 函数执行花费0.329066
小结 通过上面的示例代码可以得知装饰器的作用:
在不改变已有函数源代码及调用方式的前提下,对已有函数进行功能的扩展。
通用装饰器的使用 装饰带有参数的函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 def logging (fn) : def inner (num1, num2) : print("--正在努力计算--" ) fn(num1, num2) return inner@logging def sum_num (a, b) : result = a + b print(result) sum_num(1 , 2 )
运行结果:
装饰带有返回值的函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 def logging (fn) : def inner (num1, num2) : print("--正在努力计算--" ) result = fn(num1, num2) return result return inner@logging def sum_num (a, b) : result = a + b return result result = sum_num(1 , 2 ) print(result)
运行结果:
装饰带有不定长参数的函数 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 def logging (fn) : def inner (*args, **kwargs) : print("--正在努力计算--" ) fn(*args, **kwargs) return inner@logging def sum_num (*args, **kwargs) : result = 0 for value in args: result += value for value in kwargs.values(): result += value print(result) sum_num(1 , 2 , a=10 )
运行结果:
通用装饰器 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 def logging (fn) : def inner (*args, **kwargs) : print("--正在努力计算--" ) result = fn(*args, **kwargs) return result return inner@logging def sum_num (*args, **kwargs) : result = 0 for value in args: result += value for value in kwargs.values(): result += value return result@logging def subtraction (a, b) : result = a - b print(result) result = sum_num(1 , 2 , a=10 ) print(result) subtraction(4 , 2 )
运行结果:
1 2 3 4 --正在努力计算--13 --正在努力计算--2
小结
1 2 3 4 5 6 7 8 def logging (fn) : def inner (*args, **kwargs) : print("--正在努力计算--" ) result = fn(*args, **kwargs) return result return inner
多个装饰器的使用 多个装饰器的使用示例代码 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 def make_div (func) : """对被装饰的函数的返回值 div标签""" def inner (*args, **kwargs) : return "<div>" + func() + "</div>" return innerdef make_p (func) : """对被装饰的函数的返回值 p标签""" def inner (*args, **kwargs) : return "<p>" + func() + "</p>" return inner@make_div @make_p def content () : return "人生苦短" result = content() print(result)
代码说明:
多个装饰器的装饰过程是: 离函数最近的装饰器先装饰,然后外面的装饰器再进行装饰,由内到外的装饰过程
小结
多个装饰器可以对函数进行多个功能的装饰,装饰顺序是由内到外的进行装饰
带有参数的装饰器 有参数的装饰器介绍 带有参数的装饰器就是使用装饰器装饰函数的时候可以传入指定参数,语法格式: @装饰器(参数,…)
错误写法:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 def decorator (fn, flag) : def inner (num1, num2) : if flag == "+" : print("--正在努力加法计算--" ) elif flag == "-" : print("--正在努力减法计算--" ) result = fn(num1, num2) return result return inner@decorator('+') def add (a, b) : result = a + b return result result = add(1 , 3 ) print(result)
执行结果:
1 2 3 4 Traceback (most recent call last): File "/home/python/Desktop/test/hho.py" , line 12 , in <module> @decorator('+') TypeError: decorator() missing 1 required positional argument: 'flag'
代码说明:
正确写法: 在装饰器外面再包裹上一个函数,让最外面的函数接收参数,返回的是装饰器,因为@符号后面必须是装饰器实例。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 def logging (flag) : def decorator (fn) : def inner (num1, num2) : if flag == "+" : print("--正在努力加法计算--" ) elif flag == "-" : print("--正在努力减法计算--" ) result = fn(num1, num2) return result return inner return decorator@logging("+") def add (a, b) : result = a + b return result@logging("-") def sub (a, b) : result = a - b return result result = add(1 , 2 ) print(result) result = sub(1 , 2 ) print(result)
小结
使用带有参数的装饰器,其实是在装饰器外面又包裹了一个函数,使用该函数接收参数,返回是装饰器,因为 @
符号需要配合装饰器实例使用。
类装饰器的使用 类装饰器的介绍 装饰器还有一种特殊的用法就是类装饰器,就是通过定义一个类来装饰函数。
类装饰器示例代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Check (object) : def __init__ (self, fn) : self.__fn = fn def __call__ (self, *args, **kwargs) : print("请先登陆..." ) self.__fn()@Check def comment () : print("发表评论" ) comment()
代码说明:
说明:
@Check 等价于 comment = Check(comment), 所以需要提供一个init 方法,并多增加一个fn参数。
要想类的实例对象能够像函数一样调用,需要在类里面使用call 方法,把类的实例变成可调用对象(callable),也就是说可以像调用函数一样进行调用。
在call 方法里进行对fn函数的装饰,可以添加额外的功能。
执行结果:
2. 小结
想要让类的实例对象能够像函数一样进行调用,需要在类里面使用call 方法,把类的实例变成可调用对象(callable)
类装饰器装饰函数功能在call 方法里面进行添加