Python进阶装饰器(Decorator)

Posted ZSYL

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python进阶装饰器(Decorator)相关的知识,希望对你有一定的参考价值。

装饰器

学习目标

  • 能够知道定义装饰器的语法格式

1. 装饰器的定义

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

装饰器的功能特点:

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

2. 装饰器的示例代码

# 添加一个登录验证的功能
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

代码说明:

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

执行结果:

请先登录....
发表评论

3. 装饰器的语法糖写法

如果有多个函数都需要添加登录验证的功能,每次都需要编写func = check(func)这样代码对已有函数进行装饰,这种做法还是比较麻烦。

Python给提供了一个装饰函数更加简单的写法,那就是语法糖,语法糖的书写格式是: @装饰器名字,通过语法糖的方式也可以完成对已有函数的装饰

# 添加一个登录验证的功能
def check(fn):
    print("装饰器函数执行了")
    def inner():
        print("请先登录....")
        fn()
    return inner

# 使用语法糖方式来装饰函数
@check
def comment():
    print("发表评论")

comment()

说明:

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

执行结果:

请先登录....
发表评论
# 学习装饰器目的: 对已有函数进行额外的功能扩展, 装饰器本质上一个闭包函数,也就是说他也是一个函数嵌套

# 装饰器的特点:
# 1. 不修改已有函数的源代码
# 2. 不修改已有函数的调用方式
# 3. 给以后函数添加额外的功能

# 定义装饰器
def decorator(func):  # 如果闭包函数的参数有且只有一个并且是函数类型,那么这个闭包函数称为装饰器
    print("装饰器执行了")
    def inner():
        # 在内部函数里面对已有函数进行装饰
        print("已添加登陆验证")
        func()
    return inner


# 装饰器的语法糖写法: @装饰器名称,装饰器的语法糖就是在装饰以后函数的时候写法更加简单
@decorator  # comment = decorator(comment) 装饰器语法糖对该代码进行了封装  comment=inner
def comment():
    print("发表评论")

# 已添加登陆验证
# 发表评论

# # 调用装饰器对已有函数进行装饰  , comment=inner
# comment = decorator(comment)

# 调用方式不变
comment()  # 在这个代码执行前,装饰器已经执行了

# 装饰器的执行时机: 当当前模块加载完成以后,装饰器会立即执行,对已有函数进行装饰

4. 小结

  • 装饰器本质上就是一个闭包函数,它可以对已有函数进行额外的功能扩展。

  • 装饰器的语法格式:有且仅有一个参数,且为函数类型

# 装饰器
def decorator(fn): # fn:被装饰的目标函数.

     def inner():

         '''执行函数之前'''

         fn() # 执行被装饰的目标函数

         '''执行函数之后'''

     return inner
  • 装饰器的语法糖用法: @装饰器名称,同样可以完成对已有函数的装饰操作。
  • 装饰器的执行时机: 当当前模块加载完成以后,装饰器会立即执行,对已有函数进行装饰
  • 学习装饰器目的: 对已有函数进行额外的功能扩展, 装饰器本质上一个闭包函数,也就是说他也是一个函数嵌套

装饰器的使用

  • 能够说出装饰器的作用

1. 装饰器的使用场景

  1. 函数执行时间的统计
  2. 输出日志信息

2. 装饰器实现已有函数执行时间的统计

import time

# 装饰器函数
def 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()

执行结果:

...
99995
99996
99997
99998
99999
函数执行花费0.329066
import time

# 定义装饰器
def decorator(func):
    def inner():
        # 内部函数对已有函数进行装饰
        # 获取时间距离1970-1-1:0:0:1的时间差
        begin = time.time()
        func()
        end = time.time()

        result = end - begin
        print("函数执行完成耗时:", result)

    return inner


@decorator  # work = decorator(work), work = inner
def work():
    for i in range(10000):
        print(i)

work()  # work = inner

2. 小结

通过上面的示例代码可以得知装饰器的作用:

  • 在不改变已有函数源代码及调用方式的前提下,对已有函数进行功能的扩展。

通用装饰器的使用

1. 装饰带有参数的函数

def decorator(func):
    # 使用装饰器装饰已有函数的时候,内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(a, b):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")
        func(a, b)

    return inner


# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(num1, num2):
    result = num1 + num2
    print("结果为:", result)

add_num(1, 2)

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

def decorator(func):
    # 使用装饰器装饰已有函数的时候,内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(a, b):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")
        num = func(a, b)
        return num

    return inner


# 用装饰器语法糖方式装饰带有参数的函数
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(num1, num2):
    result = num1 + num2
    return result

result = add_num(1, 2)
print("结果为:", result)

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

# 该装饰器还可以成为是通用的装饰器
def decorator(func):
    # 使用装饰器装饰已有函数的时候,内部函数的类型和要装饰的已有函数的类型保持一致
    def inner(*args, **kwargs):
        # 在内部函数对已有函数进行装饰
        print("正在努力执行加法计算")

        # *args: 把元组里面的每一个元素,按照位置参数的方式进行传参
        # **kwargs: 把字典里面的每一个键值对,按照关键字的方式进行传参
        # 这里对元组和字典进行拆包,仅限于结合不定长参数的函数使用
        num = func(*args, **kwargs)
        return num

    return inner

@decorator  # show= decorator(show) show = inner
def show():
    return "哈哈"

result = show()
print(result)
@decorator  #  add_num= decorator(add_num), add_num=inner
def add_num(*args, **kwargs):
    result = 0

    # args: 元组类型
    # kwargs: 字典类型

    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    return result

result = add_num(1, 2)
print("结果为:", result)


if __name__ == '__main__':
    my = "a":1
    print(**my)
  • 使用装饰器装饰已有函数的时候,内部函数的类型和要装饰的已有函数的类型保持一致

多个装饰器的使用

1. 多个装饰器的使用示例代码

def make_div(func):
    print("make_div装饰器执行了")

    def inner():
        # 在内部函数对已有函数进行装饰
        result = "<div>" + func() + "</div>"
        return result

    return inner


# 定义装饰器
def make_p(func):
    print("make_p装饰器执行了")

    def inner():
        # 在内部函数对已有函数进行装饰
        result = "<p>" + func() + "</p>"
        return result

    return inner

# 多个装饰器的装饰过程: 由内到外的一个装饰过程,先执行内部的装饰器,在执行外部的装饰器
# 原理剖析: content = make_div(make_p(content))
# 分步拆解: content = make_p(content),内部装饰器装完成content=make_p.inner
#  content = make_div(make_p.inner)
@make_div
@make_p
def content():
    return "人生苦短,我用python!"

# <p>人生苦短,我用python!</p>
result = content()
print(result)
make_p装饰器执行了
make_div装饰器执行了
<div><p>人生苦短,我用python!</p></div>

带有参数的装饰器

1. 带有参数的装饰器介绍

带有参数的装饰器就是使用装饰器装饰函数的时候可以传入指定参数, 语法格式: @装饰器(参数,…)

错误写法:

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)

执行结果:

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'

代码说明:

  • 装饰器只能接收一个参数,并且还是函数类型。

正确写法:

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

def return_decorator(flag):
    # 装饰器, 装饰器只能接收一个参数并且是函数类型
    def decorator(func):
        def inner(a, b):
            if flag == "+":
                print("正在努力执行加法计算")
            elif flag == "-":
                print("正在努力执行减法计算")
            func(a, b)
        return inner
    # 当调用函数的时候可以返回一个装饰器decorator
    return decorator


# 加法计算
@return_decorator("+")  # decorator = return_decorator("+"), @decorator => add_num=decorator(add_num)
def add_num(a, b):
    result = a + b
    print(result)

add_num(1, 2)

# # 减法计算
# @return_decorator("-")
# def sub_num(a, b):
#     result = a - b
#     print(result)
#
# add_num(1, 2)
# sub_num(1, 4)

# 带有参数的装饰器,其实就是定义了一个函数,让函数接收参数,在函数内部返回的是一个装饰器
  • 带有参数的装饰器,其实就是定义了一个函数,让函数接收参数,在函数内部返回的是一个装饰器
  • 使用带有参数的装饰器,其实是在装饰器外面又包裹了一个函数,使用该函数接收参数,返回是装饰器,因为 @ 符号需要配合装饰器实例使用

类装饰器的使用

1. 类装饰器的介绍

装饰器还有一种特殊的用法就是类装饰器,就是通过定义一个类来装饰函数。

# # 类装饰器: 使用类装饰已有函数
class MyDecorator(object):
    def __init__(self, func):
        self.__func = func

    # 实现__call__这个方法,让对象变成可调用的对象,可调用的对象能够像函数使用
    def __call__(self, *args, **kwargs):
        # 对已有函数进行封装
        print("课已讲完")
        self.__func()


@MyDecorator  # @MyDecorator => show = MyDecorator(show)
def show():
    print("快要下学啦")

# 执行show  # 执行MyDecorator类创建实例对象 -> show() => 对象()
show()

# class AAA(object):
#     pass
#
# a = AAA()
# a()

# 扩展: 函数之所有能够调用是因为函数内部使用__call__
def mytest():
    print("哈哈")

print(dir(mytest))

说明:

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

加油!

感谢!

努力!

以上是关于Python进阶装饰器(Decorator)的主要内容,如果未能解决你的问题,请参考以下文章

python装饰器2:进阶

对Python中装饰器(Decorator)的理解与进阶

Python进阶之装饰器

python 装饰器

PYTHON-进阶-装饰器小结,转载

python-闭包和装饰器-02-装饰器(decorator)