闭包函数和装饰器

已于 2022-03-28 17:04:48 修改
阅读量443 收藏 5
点赞数 3
分类专栏： Python 文章标签： python
于 2020-06-08 20:50:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45523107/article/details/106628415
版权

1.闭包函数：

1.1 什么是闭包？

在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包

1.2 闭包的构成
  1. 在函数嵌套（函数里面再定义函数）的前提下
  2. 内部函数使用了外部函数的变量（还包括外部函数的参数）
  3. 外部函数返回了内部函数

定义：内层函数对外层函数非全局变量的引用，就叫做闭包函数。

​ 1.闭包会一直存在内存当中,不会因为函数执行结束而被释放。

在这里插入图片描述

1.3 闭包的作用
1. 保护数据安全、保护数据干净性

闭包的目的：要接受被装饰的函数和被装饰函数需要的参数

1.4 闭包基本模型：
def wrapper():
    name = 'xiongsheng'
    def inner():
        print(name)
    inner()
wrapper()
======================
xiongsheng

判断是否为闭包函数：

可以通过print(函数名.__closure__ )看是否有<cell xxxx xxx >类似信息打印,如果有就说明该函数为闭包函数。
name = 'xiongsheng'
def wrapper():
    def inner():
        print(name)
    inner()
    print(inner.__closure__)  # None   说明该函数不是闭包函数
wrapper()

===========================
None　　　　　　　　　　　　　


name = 'xiongsheng'
def wrapper(x):
    x = name
    def inner():
        print(x)
    inner()
    print(inner.__closure__)  # <cell at 0x0000000000130C48: str object at 0x0000000001E8A260>  有类似的打印信息说明该函数为闭包函数
wrapper(name)

=================================================
xiongsheng
(<cell at 0x02B77490: str object at 0x00FF73A0>,)
1.5 应用场景：
获取网页内容
from urllib.request import urlopen
def zhua(url):
    #url='www.baidu.com'
    def get():
        return  urlopen(url).read()
    return get
f=zhua('www.baidu.com')
f()
1.6 闭包的使用
# 外部函数
def config_name(name):
    # 内部函数
    def inner(info):
        print(name + ": " + info)

    return inner


tom = config_name("Tom")  # 创建tom闭包实例对象
jerry = config_name("jerry")  # 创建jerry闭包实例对象

print(id(tom))
print(id(jerry))  # 内存地址不同， 相当于创建了2个不同的闭包，

tom("你好! jerry")
tom("你好, 在吗?")  # 如果执行tom闭包，因为已经保存了name参数，那么以后在输入的时候都是，tom说：xxx
jerry("不在, 不和你玩!")

在这里插入图片描述

1.7 修改闭包内使用的外部变量
# 1.函数嵌套
def func_out():  # 外部函数的定义
    num = 10  # 定义一个变量

    def inner():  # 内部函数的定义
        nonlocal num  # 在闭包内部修改外部函数的变量
        num = 40
        result = num + 10  # 2.内部函数必须使用外部函数的变量
        print(result)

    print("修改前的外部变量：", num)
    inner()
    print("修改后的外部变量：", num)
    # print("打印结果：", result)
    # 外部函数返回内部函数的地址
    # 3. 外部函数要返回内部函数，这个使用了外部函数变量的内部函数称为闭包
    return inner  # 注意：没有括号，加上括号，就是函数调用


# 获取闭包的对象
# 这个func_new 就是闭包
# func_new函数执行的结果等于inner函数执行的结果
func_new = func_out()
# 执行闭包
func_new()

在这里插入图片描述

总结：一个函数内部如果需要某个名字关系,有两种方法:
　　1、通过传参的方式
　　2、通过闭包的方式,在该函数外层包一层作用域(即再定义一个函数),将需要的名字关系包在外部函数中

2. 装饰器：

2.1 装饰器的定义

定义：给已有函数增加额外功能的函数，它本质上就是一个闭包函数

装饰器的功能特点:

1.不修改已有函数的源代码
2.不修改已有函数的调用方式
3.给已有函数增加额外的功能

**功能：**在遵循原则的前提,为被装饰对象添加上新功能。

2.2 装饰器的基本模型
def wrapper(f):
    def inner(*args,**kwargs):
        """被装饰函数执行之前的操作"""

        ret = f(*args,**kwargs)
        """被装饰函数执行之后的操作"""
        return ret
    return inner
2.3 装饰器的示例代码
# 添加一个登录验证的功能
def check(fn):
    def inner():
        print("请先登录....")
        fn()
    return inner


def comment():
    print("发表评论")

# 使用装饰器来装饰函数
comment = check(comment)
comment()

# 装饰器的基本雏形
# def decorator(fn): # fn:目标函数.
#     def inner():
#         '''执行函数之前'''
#         fn() # 执行被装饰的函数
#         '''执行函数之后'''
#     return inner

在这里插入图片描述

代码说明:

1.闭包函数有且只有一个参数，必须是函数类型，这样定义的函数才是装饰器。
2.写代码要遵循开放封闭原则，它规定已经实现的功能代码不允许被修改，但可以被扩展。
2.4 装饰器的语法糖写法

语法糖的书写格式是: @装饰器名字，通过语法糖的方式也可以完成对已有函数的装饰
在这里插入图片描述
说明:

@check 等价于 comment = check(comment)
装饰器的执行时间是加载模块时立即执行。

总结
装饰器本质上就是一个闭包函数，它可以对已有函数进行额外的功能扩展。
装饰器的语法格式:

# 装饰器
 def decorator(fn): # fn:被装饰的目标函数.
     def inner():
         '''执行函数之前'''
         fn() # 执行被装饰的目标函数
         '''执行函数之后'''
     return inner
2.5 通用装饰器的使用

1.装饰带有参数的函数

# 添加输出日志的功能
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)

2.装饰带有返回值的函数

# 添加输出日志的功能
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)

3.装饰带有不定长参数的函数

# 添加输出日志的功能
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)

4.通用装饰器

# 添加输出日志的功能
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)

6.通用装饰器的语法格式:

# 通用装饰器
def logging(fn):
  def inner(*args, **kwargs):
      print("--正在努力计算--")
      result = fn(*args, **kwargs)
      return result

  return inner
2.6 多个装饰器的使用
def make_div(func):
    """对被装饰的函数的返回值 div标签"""
    def inner():
        return "<div>" + func() + "</div>"
    return inner


def make_p(func):
    """对被装饰的函数的返回值 p标签"""
    def inner():
        return "<p>" + func() + "</p>"
    return inner


# 装饰过程: 1 content = make_p(content) 2 content = make_div(content)
# content = make_div(make_p(content))
@make_div
@make_p
def content():
    return "人生苦短"

result = content()

print(result)

在这里插入图片描述
代码说明:

多个装饰器的装饰过程是: 离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程
小结
多个装饰器可以对函数进行多个功能的装饰，装饰顺序是由内到外的进行装饰

2.7 带有参数的装饰器

在装饰器外面再包裹上一个函数，让最外面的函数接收参数，返回的是装饰器，因为@符号后面必须是装饰器实例。

# 添加输出日志的功能
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)

在这里插入图片描述

2.8 类装饰器的使用
class Check(object):
    def __init__(self, fn):
        # 初始化操作在此完成
        self.__fn = fn

    # 实现__call__方法，表示对象是一个可调用对象，可以像调用函数一样进行调用。
    def __call__(self, *args, **kwargs):
        # 添加装饰功能
        print("请先登陆...")
        self.__fn()


@Check
def comment():
    print("发表评论")


if __name__ == '__main__':
    comment()

在这里插入图片描述
代码说明:

@Check 等价于 comment = Check(comment), 所以需要提供一个init方法，并多增加一个fn参数。
要想类的实例对象能够像函数一样调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用。
在call方法里进行对fn函数的装饰，可以添加额外的功能。

小结
想要让类的实例对象能够像函数一样进行调用，需要在类里面使用call方法，把类的实例变成可调用对象(callable)
类装饰器装饰函数功能在call方法里面进行添加

xiongsheng666
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【Python】闭包与装饰器
flylr^的博客
05-11 1757
python中的闭包与装饰器
装饰器和闭包函数
weixin_51412013的博客
06-04 215
闭包函数与装饰器
九、闭包和装饰器
mChenys的博客
07-03 238
在 Python 中，当我们在一个嵌套函数内部定义一个同名的变量时，默认情况下，Python 会将这个变量视为一个新的本地变量，而不是引用外部的变量。这样做的原因是，通过这种多层的嵌套结构，我们可以在外层函数中接受装饰器的参数，并将这些参数传递给内层的装饰器函数。在这种情况下，我们需要定义一个装饰器函数，它接受任意个数和类型的参数，并返回一个内部函数，该内部函数代替原始函数的执行。如果我们需要在装饰器中使用参数，那么我们需要在装饰器函数的外层定义一个接受参数的函数，然后在内层定义真正的装饰器函数。
装饰器与闭包
qq_33578950的博客
04-06 455
闭包是指一个函数能够访问并操作在其外部作用域定义的变量。在 Python 中，函数内部可以访问外部函数中的变量，这种嵌套函数的结构称为闭包。本文列举了一些装饰器的案例，以及闭包的应用场景。
python闭包和装饰器
qq_43745578的博客
01-17 1217
python闭包和装饰器
闭包和装饰器
湾区小学生的博客
11-29 149
【Jupyter notebook点击有奖】 1、闭包 什么是闭包：内部函数对外部函数作用域里的非全局变量的引用，称【内部函数】为闭包。 闭包三要素：1、嵌套函数；2、变量引用；3、返回内部函数 def fun(n): def fun_in(m): print("sum = ",n+m)#内部函数对外部函数的变量的引用（n） return n,m ...
简析Python的闭包和装饰器
09-21
Python中的闭包和装饰器是两种非常重要的编程概念，它们在函数式编程和面向对象编程中都有广泛应用。本文将深入探讨这两个主题，帮助你更好地理解和利用它们。 首先，我们来看看**装饰器**。装饰器是一种特殊类型的...
深入理解python中的闭包和装饰器
09-21
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性，特别是涉及到作用域和函数的嵌套。 闭包（Closure）在Python中是指一个内部函数引用了外部函数的局部变量，即使外部函数已经执行完毕，...
函数装饰器和闭包1
08-03
函数装饰器和闭包是Python中强大的工具，它们提供了扩展和优化代码的途径。通过理解和熟练运用这些概念，可以编写出更加灵活和高效的代码，提高程序的可维护性和可读性。装饰器与闭包结合使用，可以帮助我们实现诸如...
Python闭包和装饰器用法实例详解
09-19
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性来实现更高级别的抽象和功能增强。 闭包（Closure）是Python中一个核心的概念，它源自函数的局部作用域和引用。当一个内部函数引用了外部...
python进阶之闭包装饰器
MSJ3917的博客
12-29 855
闭包装饰器:对旧功能/代码,在最小源代码改造情况下进行功能升级.装饰器也叫[语法糖]比如:例如我们需要对数据库的操作,额外增加事务的处理.就可以用到装饰器来解决.例子:# 定义装饰器，用来对旧代码升级/加强print("代码加强【开启事务】")# 调用原始函数print("代码加强【关闭事务】")print("对数据库的增删改查操作")crud()注意: 使用装饰器，我们对原始的crud()方法内部没有做任何的改变。
闭包函数以及装饰器
山海的博客
08-24 103
闭包函数
闭包与装饰器
m0_69128892的博客
06-08 462
目录​​​​​​​1.闭包1.3 闭包的优缺点 2.装饰器2.4 装饰器的优缺点3.闭包装饰器区别闭包的本质就是函数的嵌套，函数内部再定义函数闭包的定义：内外函数嵌套，内部函数引用外部函数作用域下的非全局变量，外函数返回内函数对象创建一个闭包必须满足以下几点:必须有一个内嵌函数内嵌函数必须引用外部函数中的变量外部函数的返回值必须是内嵌函数闭包有两种不同的方式，第一种是“返回一个函数名称”，第二种是在函数内部就“直接调用”1.1 返回一个函数名称： 1.2 直接调用： 1.3 闭包的优缺点 优
Python学习----闭包和装饰器
m0_48639280的博客
12-10 712
在函数嵌套调用的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数的内部函数称为闭包。闭包构成条件：1、在函数嵌套的前提下2、内部函数使用了外部函数的变量（还包括外部函数的参数）3、外部函数返回了内部函数结论：闭包可以对外部函数的变量进行保存。
Js中闭包的几种写法
gaodda的博客
11-23 3913
1.定义 闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。 2.实例 实例1 function init () { let name = 'gaodda' // name 是一个被 init 创建的局部变量 function sho...
闭包的基本概念及闭包的三种写法
我的专栏
02-03 3506
class ViewController: UIViewController { override func viewDidLoad() { super.viewDidLoad() /* 闭包 类似于 block block是C语言的, 类似于匿名函数 闭包是定义函数的, Swift中函数就是一种特殊的闭包
闭包知识点
weixin_57156683的博客
07-27 179
闭包
闭包和装饰器 python
最新发布
05-24
好的，以下是关于闭包和装饰器的介绍： 闭包（Closure）是 Python 中的一个重要概念，它是一个能够访问另一个函数作用域的变量和状态的函数。在 Python 中，闭包通常是通过函数返回另一个函数的模式实现的。闭包使得函数可以引用其他函数的作用域中的变量，并且可以在需要时重新创建这些变量。 装饰器（Decorator）是 Python 中的一个功能强大的工具，它是一个能够修改或增强其他函数或类的特殊类型的函数。装饰器通常用于添加功能，例如记录日志、计时、缓存等。装饰器通过将一个函数作为参数传递给它自己，并在其内部定义该函数的增强版本来实现。 使用装饰器，可以将功能封装为可重用的组件，并轻松地将其应用于其他函数或类。这使得代码更加模块化和可维护。此外，装饰器还可以通过将一些逻辑代码移动到外部文件或库中，提高代码的可读性和可维护性。 闭包和装饰器是 Python 语言中的两个关键概念，它们可以协同工作，实现更加灵活和强大的功能。装饰器通常用于在不需要更改原始函数逻辑的情况下增强功能，而闭包则允许创建可以访问原始函数变量的新函数或类。在实际应用中，这两种技术可以相互配合，实现更复杂的功能和更灵活的代码结构。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xiongsheng666

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值