Python进阶方法-Decorator装饰器

最新推荐文章于 2024-03-04 15:55:42 发布
最新推荐文章于 2024-03-04 15:55:42 发布
阅读量400 收藏
点赞数
文章标签： python 开发语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aobulaien001/article/details/132773432
版权

前言

在Python中，decorator（装饰器）是一种特殊的函数，主要用于修改或增强其他函数的功能。它可以在不修改原函数代码的情况下，通过在原函数的定义之前使用@语法糖来对其进行修饰。

Decorator装饰器的作用

Decorator的作用有以下几个方面：

1. 添加额外的功能：通过在原函数周围包裹一层装饰器函数，可以在原函数执行前后执行一些额外的代码，比如日志记录、性能分析、异常处理等。

2. 修改函数的行为：装饰器可以对原函数的输入参数进行验证、修改返回值、缓存结果等，从而改变函数的行为。

3. 分离关注点：通过使用装饰器，可以将与函数功能无关的代码（如日志记录、权限验证）与函数本身的实现分离开来，提高代码的可读性和可维护性。

4. 动态创建函数：装饰器可以在运行时动态创建函数，根据不同的条件返回不同的函数，实现动态的函数生成。

需要注意的是，装饰器只是对函数进行修饰，不会改变函数的原始定义。同时，装饰器可以堆叠使用，多个装饰器可以依次修饰同一个函数，形成装饰器链。

1、常规方法装饰功能

给方法执行时，添加额外的功能：输出方法运行的时长。

现在有2个方法：
import time  # 导入time模块  
  
  
def index():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是index函数------------')  
  
  
def home():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是home函数------------')
方法实现：

将目标方法包装到另外一个方法中进行统一处理

mport time  # 导入time模块  
  
  
def index():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是index函数------------')  
  
  
def home():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是home函数------------')  
  
  
def get_time(function_name):  
    start_time = time.time()  # 获取运行函数前的时间  
    function_name()  # 调用函数  
    end_time = time.time()  # 获取运行结束后的时间  
    print("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  # 输出时间差  
    print("------------------------------------------------")  
  
  
get_time(index)  
get_time(home)
控制台输出结果：
------------这里是index函数------------  
index 执行耗时：1.004432201385498  
------------------------------------------------  
------------这里是home函数------------  
home 执行耗时：1.0124742984771729  
------------------------------------------------

2、初级装饰器用法

新建测试文件：
import time  # 导入time模块  
  
# 装饰对象  
def index():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是index函数------------')  
  
  
def home():  
    time.sleep(1)  # 让程序休眠1秒钟  
    print('------------这里是home函数------------')  
  
  
# 装饰器  
def outer(function_name):  
    def inner():  
        # 获取运行函数前的时间  
        start_time = time.time()  
        # 调用名为function_name函数  
        function_name()  
        # 获取函数运行结束后的时间  
        end_time = time.time()  
        # 输出时间差  
        print("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        print("------------------------------------------------")  
  
    # 返回内部函数名  
    return inner  
  
  
# 让index()变成inner()  
index = outer(index)  
index()  
  
# 让home()变成inner()  
home = outer(home)  
home()
控制台输出结果：

这个时候函数只需要调用它自己就能输出运行时间了，相当于给函数内部添加了一段代码一样。

------------这里是index函数------------  
index 执行耗时：1.0032925605773926  
------------------------------------------------  
------------这里是home函数------------  
home 执行耗时：1.0116212368011475  
------------------------------------------------

3、装饰有传参要求的方法

给装饰器加上可变长形参就可以接受任何方法需要的参数。

新建测试文件：
import time  # 导入time模块  
  
"""  
方法传参：*args, **kwargs  
"""  
  
def index(a):  # 有参数  
    time.sleep(1)  
    print('------------这里是index函数,接受的参数是：{}'.format(a))  
  
  
def home():  # 无参数  
    time.sleep(1)  
    print('------------这里是home函数------------')  
  
  
# 装饰器  
def outer(function_name):  
    def inner(*args, **kwargs):  # 添加可变长形参  
        start_time = time.time()  
        function_name(*args, **kwargs)  # 传参  
        end_time = time.time()  
        # 输出时间差  
        print("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        print("------------------------------------------------")  
  
    return inner  
  
  
index = outer(index)  
index(555)  
  
home = outer(home)  
home()
控制台输出结果：
------------这里是index函数,接受的参数是：555  
index 执行耗时：1.0144884586334229  
------------------------------------------------  
------------这里是home函数------------  
home 执行耗时：1.0140643119812012  
------------------------------------------------

4、装饰有返回信息的方法

如果函数有返回值，则在装饰器内部函数加一个return返回值就行了。

新建测试文件：
import time  # 导入time模块  
  
"""  
方法传参：*args, **kwargs  
方法return  
"""  
  
  
def index(a):  # 有参数  
    time.sleep(1)  
    print('------------这里是index函数,接受的参数是：{}'.format(a))  
    return a * 2  # 有返回值  
  
  
def home():  # 无参数  
    time.sleep(1)  
    print('------------这里是home函数------------')  
  
  
def outer(function_name):  
    def inner(*args, **kwargs):  # 添加可变长形参  
        start_time = time.time()  
        # 将函数返回值赋值给res  
        res = function_name(*args, **kwargs)  # 传参  
        end_time = time.time()  
        # 输出时间差  
        print("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        print("{} 方法返回信息：{}".format(function_name.__name__, res))  
          
        """返回函数的返回值"""  
        return res  
  
    return inner  
  
  
index = outer(index)  
print(index(555))  
  
home = outer(home)  
home()
控制台输出结果：
------------这里是index函数,接受的参数是：555  
index 执行耗时：1.0148656368255615  
index 方法返回信息：1110  
1110  
------------这里是home函数------------  
home 执行耗时：1.0151972770690918  
home 方法返回信息：None

5、装饰器模板&语法糖用法

编写装饰器其实有一套固定的代码 不需要做任何理解

"""编写装饰器其实有一套固定的代码 不需要做任何理解"""  
  
def decorator_func(function_name):  # func_name用于接收被装饰的对象(函数)  
    def inner(*args, **kwargs):  
        print('执行被装饰函数之前 可以做的额外操作')  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        print('执行被装饰函数之后 可以做的额外操作')  
        return res  # 返回真正函数的返回值  
  
    return inner

python给了一个方法，用@+装饰器名称放在装饰对象的上方

新建测试文件：

其中 from api_test_demo._07_log.log_demo_10 import MyLogger 代码文件参考以往的文章《Pytest测试框架中的日志记录功能详解》中第10讲。

  
"""  
装饰器模板&语法糖  
"""  
import time  
from api_test_demo._07_log.log_demo_10 import MyLogger  
  
logger = MyLogger(log_filename_default='./log_dir/decorator_demo_05_{}.log').my_logger()  
  
  
def decorator_func(function_name):  # func_name用于接收被装饰的对象(函数)  
    def inner(*args, **kwargs):  
        logger.info('-----------这里是 {} 函数------------'.format(function_name.__name__))  
        start_time = time.time()  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        end_time = time.time()  
        logger.info("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res))  
        return res  # 返回真正函数的返回值  
  
    return inner  
  
  
'''  
语法糖内部原理：  
  
使用的时候最好紧跟在被装饰对象的上方  
语法糖会自动将下面紧挨着的函数名传给@后面的函数调用  
'''  
  
  
@decorator_func  
def index(a):  # 有参数  
    time.sleep(1)  
    return a * 2  # 有返回值  
  
  
index(888)
控制台输出结果：

文件中记录结果：

6、装饰器修复功能

在Python中，使用@wraps装饰器是为了解决装饰器函数修改原函数属性的问题。

当我们使用装饰器修饰一个函数时，原函数的一些属性（如__name__、__doc__等）会被装饰器函数的属性所替代，这可能会导致一些问题，比如在调试或文档生成时无法正确显示原函数的信息。

@wraps装饰器是functools模块中的一个函数，它提供了一个简单的方式来解决这个问题。它会将装饰器函数的属性复制到原函数上，保持原函数的属性不变。

使用@wraps装饰器的语法如下：

from functools import wraps  
  
def decorator(func):  
    @wraps(func)  
    def wrapper(*args, **kwargs):  
        # 装饰器函数的逻辑  
        pass  
    return wrapper
新建测试文件（未添加@wraps装饰器）：
  
"""  
装饰器修复 wraps  
"""  
import time  
from functools import wraps  
  
from api_test_demo._07_log.log_demo_10 import MyLogger  
  
logger = MyLogger(log_filename_default='./log_dir/decorator_demo_06_{}.log').my_logger()  
  
  
def decorator_func(function_name):  # func_name用于接收被装饰的对象(函数)  
    def inner(*args, **kwargs):  
        logger.info('-----------这里是 {} 函数------------'.format(function_name.__name__))  
        start_time = time.time()  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        end_time = time.time()  
        logger.info("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res))  
        return res  # 返回真正函数的返回值  
  
    return inner  
  
  
@decorator_func  
def index(a):  # 有参数  
    time.sleep(1)  
    return a * 2  # 有返回值  
  
  
print(index)
控制台输出结果：

可以看出，这时的index是属于inner中的方法

<function decorator_func.<locals>.inner at 0x000001467F3F70D0>
新建测试文件（添加@wraps装饰器）：
"""  
装饰器修复 wraps  
"""  
import time  
from functools import wraps  
  
from api_test_demo._07_log.log_demo_10 import MyLogger  
  
logger = MyLogger(log_filename_default='./log_dir/decorator_demo_06_{}.log').my_logger()  
  
  
def decorator_func(function_name):  # func_name用于接收被装饰的对象(函数)  
    @wraps(function_name)  # 修复  
    def inner(*args, **kwargs):  
        logger.info('-----------这里是 {} 函数------------'.format(function_name.__name__))  
        start_time = time.time()  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        end_time = time.time()  
        logger.info("{} 执行耗时：{}".format(function_name.__name__, end_time - start_time))  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res))  
        return res  # 返回真正函数的返回值  
  
    return inner  
  
  
@decorator_func  
def index(a):  # 有参数  
    time.sleep(1)  
    return a * 2  # 有返回值  
  
  
print(index)
控制台输出结果：

现在可以看到，index还是原来的index方法

<function index at 0x0000019D8FDF70D0>

7、多个装饰器

新建测试文件：

"""  
装饰多个装饰器  
"""  
import time  
from functools import wraps  
  
from api_test_demo._07_log.log_demo_10 import MyLogger  
  
logger = MyLogger(log_filename_default='./log_dir/decorator_demo_07_{}.log').my_logger()  
  
  
# 装饰器01  
def decorator_func_01(function_name):  
    @wraps(function_name)  
    def decorator(*args, **kwargs):  
        logger.info('-----------执行了：decorator_func_01------------')  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res * 1))  
        return res  # 返回真正函数的返回值  
  
    return decorator  
  
  
# 装饰器02  
def decorator_func_02(function_name):  
    @wraps(function_name)  
    def decorator(*args, **kwargs):  
        logger.info('-----------执行了：decorator_func_02------------')  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res * 2))  
        return res  # 返回真正函数的返回值  
  
    return decorator  
  
  
# 装饰器03  
def decorator_func_03(function_name):  
    @wraps(function_name)  
    def decorator(*args, **kwargs):  
        logger.info('-----------执行了：decorator_func_03------------')  
        res = function_name(*args, **kwargs)  # 执行真正的被装饰函数  
        logger.info("{} 方法返回信息：{}".format(function_name.__name__, res * 3))  
        return res  # 返回真正函数的返回值  
  
    return decorator  
  
  
@decorator_func_01  
@decorator_func_02  
@decorator_func_03  
def index(a):  
    time.sleep(1)  
    return a  
  
  
index(999)
控制台输出结果：

当连用多个语法糖的时候，优先执行靠近装饰对象的语法糖，并且直到最远的语法糖才会赋值给装饰对象的函数名。

也就是说，在上述代码中，优先执行@decorator_func_03，将decorator_func_03装饰到index中，但此时不会赋值给index函数名，执行到@decorator_func_01时，这时就会执行赋值语句，也就是index = decorator_func_03(index)。

8、装饰器传参功能

可以通过在装饰器外层再嵌套一个函数进行参数传递。

新建测试文件：
  
"""  
带参数的装饰器  
"""  
  
from functools import wraps  
  
from api_test_demo._07_log.log_demo_10 import MyLogger  
  
logger = MyLogger(log_filename_default='./log_dir/decorator_demo_08_{}.log').my_logger()  
  
  
# 最外层函数，可以接收参数给装饰器使用  
def decorator_func_outer(decorator_param):  
    # 装饰器  
    def decorator_func(func):  
        @wraps(func)  
        def decorator(*args, **kwargs):  
            logger.info('-----------执行了：decorator_func------------')  
  
            if 1 < decorator_param <= 99:  
                logger.info("do something with function: 1 < decorator_param <= 99")  
  
            if 99 < decorator_param <= 999:  
                logger.info("do something with function: 99 < decorator_param <= 999")  
  
            if decorator_param > 999:  
                logger.info("do something with function: decorator_param>999")  
  
            res = func(*args, **kwargs)  # 执行真正的被装饰函数  
            logger.info("{} 方法返回信息：{}".format(func.__name__, res))  
            return res * 2  # 返回真正函数的返回值  
  
        return decorator  
  
    # 这里返回装饰器的函数名  
    return decorator_func  
  
  
@decorator_func_outer(decorator_param=6)  
def index(a):  
    return a  
  
  
index(a=888)
控制台输出结果：

总结

Decorator是一种强大的Python语言特性，可以通过装饰器函数对其他函数进行修饰，从而实现功能增强、行为修改、关注点分离等效果。同时，使用@wraps装饰器可以保持原函数的属性不变，提高代码的可维护性和可读性。

---------------------------END---------------------------

题外话

在这里插入图片描述

感兴趣的小伙伴，赠送全套Python学习资料，包含面试题、简历资料等具体看下方。

👉CSDN大礼包🎁：全网最全《Python学习资料》免费赠送🆓！（安全链接，放心点击）

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

img
img

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！img

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

img

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

img

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

img

六、面试宝典

在这里插入图片描述

在这里插入图片描述

简历模板在这里插入图片描述

👉CSDN大礼包🎁：全网最全《Python学习资料》免费赠送🆓！（安全链接，放心点击）

若有侵权，请联系删除

aobulaien001
关注
python中的装饰器（Decorators）
gu305524073的博客
01-02 338
一、什么是python装饰器（Decorators） 定义：python的装饰器：装饰原有的函数，用于拓展原来函数功能的一种函数，在不更改原来函数代码的基础上，增加函数的功能。 格式：@ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。 二 、装饰器返回值及用处 装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处...
python进阶 之 python函数装饰器
张某某。的博客
03-25 427
本博客是学习 慕课网 廖雪峰老师 的 python进阶 的过程中所做的笔记。用以记录与参考。 装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。有助于让我们的代码更简短。 一、python中编写无参数装饰器 Python的decorator本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数...
Python装饰器学习笔记
weixin_30813225的博客
12-27 411
Python装饰器是Python语法的精髓，学会使用后能让代码更加简洁，代码更能复用，我们在写代码时有些功能会经常使用，比如读写文件，做短信验证校验等等，这些代码的功能实现大同小异，我们就可以使用装饰器来做到复用这类功能。 装饰器是什么？要理解Python的装饰器，首先我们先理解一下Python的函数对象。我们知道，在Python里一切都是对象，函数也不例外，函数是第一类对象（f...
Python深入05 装饰器
weixin_33750452的博客
02-16 155
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！   装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰...
python装饰器（Decorator）
最新发布
棠越的博客
03-04 4168
python装饰器（Decorator）
编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志
RonnyChan的博客
06-21 4516
注意：我们要借助Python的@语法，把decorator置于函数的定义处初步尝试:def log(func): def wrapper(*args, **kw): print 'begin call: %s' %func.__name__ return func(*args, **kw) print 'end call: %s' %func.__name__ return wrap...
Python进阶.pdf
04-11
- `@decorator`语法糖使得装饰器使用更加简洁。 - 装饰器可以接收参数，增加其灵活性，实现更复杂的逻辑。 7. **Global和Return**： - Python中全局变量在函数内部修改需要使用`global`关键字声明。 - `return`...
老生常谈Python进阶之装饰器
09-21
Python中的装饰器是一种强大的工具，它允许我们修改或增强函数的行为，而不直接修改函数的源代码。装饰器的本质是函数，它...掌握装饰器的使用是Python进阶学习的重要一环，它能帮助开发者编写出更加高效、优雅的代码。
进阶Python-高级代码
01-27
3. **装饰器（Decorator）**：装饰器是Python中的一个强大工具，可以用于修改或增强函数、类的行为，而无需更改原始代码。它们通过@符号进行调用，可以用于日志记录、性能测试、权限控制等场景。 4. **元编程...
Python中decorator
zhf的博客
07-20 567
@decorator可以实现函数功能的动态增加，但是，经过@decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？ 栗子1： 在没有decorator的情况下，打印函数名： def f1(x): pass print(f1.__name__) 结果为： f1 栗子2： 在有decorator的情况下，打印函数名： def log(f): ...
Python系列之装饰器(decorator)
ikxyang的博客
12-17 3378
Python系列之装饰器(decorator) Python装饰器的本质 Python的装饰器本质上是一个嵌套函数，它接受被装饰的函数(func)作为参数，并返回一个包装过的函数。这样我们可以在不改变被装饰函数的代码的情况下给被装饰函数或程序添加新的功能。Python的装饰器广泛应用于缓存、权限校验(如django中的@login_required和@permission_required装饰器)、性能测试(比如统计一段程序的运行时间)和插入日志等应用场景。有了装饰器，我们就可以抽离出大量与函数功能本身无关
Python 装饰器
weixin_33877885的博客
06-23 81
#一、装饰器的作用就是给已经实现的功能再扩展新的功能#二、无参数的 1 # def wohaoshuai1(func): 2 # print("wohaoshuai1") 3 # return func 4 # 5 # @wohaoshuai1 6 # def wohaoshuai2(): 7 # print("wohaoshuai2") ...
深入理解Python 装饰器（decorator）
热门推荐
04-17 1万+
返璞归真， 看山还是山 刚看到Python装饰器时， 觉得很神奇。简单实验下，发现也就那么回事。但是慢慢的看到越来越多的装饰器。很多时候又不了解到底是怎么回事了。最后还是决定好好研究下。先看看一些实例， 然后再来分析下原理 假设我们有如下的基本函数def do_something(): for i in range(1000000): pass print "pla
python decorator. decorator_python装饰器(decorator)
weixin_28925387的博客
02-02 171
最近在自学Python，在装饰器这里迷惑了我很久，有几个问题一直困惑着我。1.装饰器的语法原理；2.为什么要用装饰器；首先来看一下装饰器的原理。总而言之，装饰器就是函数或者类作为函数的返回值。将函数或者类作为装饰器的参数传递之后，装饰器对该函数或者类进行相应操作后再将其返回。这就是装饰器的基本原理。举个例子来讲，我们定义装饰器decorator，定义函数f。其过程便如下：f=decorator(f...
python 的函数Decorators
dao123mao的专栏
03-05 842
Decorators是python中比较难以理解的东西，当然如果你接触过java的annotation，会发现这个Decorators在语法上非常的相似，但是两者的设计动机却没什么共同点；这里讲的python中的decorators是对python中的function/method做装饰，这些修饰仅是当声明一个函数或者方法的时候，才会应用的额外调用。python中的decorator分为有
python 装饰器decorator
幻欢子
04-03 646
目录 一、基本介绍 二、Decorator 的本质 2.1、本质说明 2.2、多个decorator 2.3、带参数的decorator 2.4、用Decorator设置函数的调用参数 2.5、Decorator的副作用 三、decorator的应用示例 3.1、给函数调用做缓存 3.2、Profiler的例子 3.3、给函数打日志 一、基本介绍 Pytho...
Python语法：装饰器(decorator)
a10703060237的博客
06-20 674
python 装饰器的用法
Python中decorator的使用
weixin_30892037的博客
01-09 130
Python中的decorator用法很有意思，是一个类似decorator模式的典型的AOP特性。 例如我们原来有一个函数是这样的： def openurl(url): return urllib2.urlopen(url, timeout = 5).read() 如果我们想在进入这个函数和退出这个函数的时候打印日志，可以这样写： def openurl(url): ...
Python进阶之装饰器@decorator
adamlovejw的专栏
08-01 2968
什么是装饰器本文参照慕课网廖学峰老师的视频教程整理demo下载地址 ：https://github.com/adamin1990/pydecorator 定义了一个函数 想在运行时动态增加功能 又不想改动函数本身的代码 装饰器的作用可极大的简化代码，避免每个函数编写重复性代码 1. 打印日志 @log 2. 检测性能 @performance 3. 数据库事务 @transaction 4
Python进阶：闭包与装饰器详解
函数进阶-闭包装饰器" 在编程中，函数是代码组织的基本单元，而闭包和装饰器则是Python中高级函数概念的重要组成部分。在这篇文章中，我们将深入理解这两个概念。 ### 闭包 闭包是一种特殊的函数，它具有以下特点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值