装饰器示例

合集 - python高级(31)

1.创建进程2023-07-232.Process类语法详解2023-07-233.进程间通信2023-07-234.进程池2023-07-235.进程间的锁和信号量2023-07-236.根据进程编号杀死指定进程os.kill2023-07-237.守护进程2023-07-238.线程2023-07-289.实现多线程多任务的步骤2023-07-2810.threading.Thread类详解2023-07-2811.守护线程&&threading.enumerate()2023-07-2812.python线程并行执行与java的线程并行执行的对比2023-07-2913.IO密集型任务与CPU密集型任务2023-07-2914.多线程共享全局变量的问题2023-07-2915.多线程共享资源之竞态条件2023-07-2916.互斥锁2023-07-2917.死锁2023-07-2918.线程池2023-07-2919.进程与线程的对比2023-07-2920.闭包2023-08-2621.闭包之nonlocal关键字的作用2023-08-2622.闭包之作用2023-08-2623.闭包之可能引起的问题2023-08-2624.弱引用2023-08-2625.装饰器2023-08-27

26.装饰器示例2023-08-27

27.property 属性2023-08-2728.with语句和上下文管理器详解、最佳实践、示例2023-08-2929.生成器2023-08-2930.深浅拷贝2023-08-3031.正则表达式2023-08-30

收起

1. 装饰器语法糖示例

注解形式：

# 1定义一个装饰器(装饰器的本质是闭包)
def check(fn):
    def inner():
        print("请先登陆")
        fn()

    return inner


# 2使用装饰器装饰函数（增加一个登陆功能）
# 解释器遇到@check 会立即执行 comment = check(comment)
@check
def comment():
    print("发表评论")


comment()

真实面目：

# 1. 定义一个装饰器(装饰器的本质是闭包)
def check(fn):
    def inner():
        print("登陆验证。。。")
        fn()

    return inner


# 需要被装饰的函数
def comment():
    print("发表评论")


# 2. 使用装饰器装饰函数（增加一个登陆功能）
comment = check(comment)  # comment函数就是被装饰器装饰后的函数

# 3. 执行装饰器函数
comment()

输出结果：

?

1 2	登陆验证。。。 发表评论

　　

一句话总结：利用闭包特点、不改变函数源码，为其执行前后添加功能。

2. 装饰有参数的函数

# 1. 定义装饰器
def logging(fn):  # fn = sum_num，如果只有1个参数，此参数的实参必须是被修饰函数
    def inner(a, b):  # 内部函数的参数列表，必须直接或间接包含被装饰的参数列表
        print("被装饰函数执行之前")
        fn(a, b)
        print("被装饰函数执行之后")

    return inner  # sum_num = inner


# 2. 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    print(result)


# 3. 执行被装饰函数验证
sum_num(1, 2)  # 输出结果是3

执行结果：

被装饰函数执行之前
3
被装饰函数执行之后

总结：

1. 装饰器就是闭包

2. 装饰器的外部函数的参数的实参必须是被装饰函数

3. 内部函数的参数直接或间接包含被装饰函数的列表

3. 装饰有返回值的函数

# 1. 定义装饰器
def logging(fn):  # fn = sum_num，如果只有1个参数，此参数的实参必须是被修饰函数
    def inner(a, b):
        print("被装饰函数执行之前")
        result = fn(a, b)  # 内部函数的参数列表，必须直接或间接包含被装饰的参数列表
        print(f"被装饰函数执行之后,结果为:{result}")
        return result

    return inner  # sum_num = inner


# 2. 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    return result


# 3. 执行被装饰函数验证
result = sum_num(1, 2)
print(result)

执行结果：

?

1 2 3

被装饰函数执行之前 被装饰函数执行之后,结果为:3 3

　　

总结：跟其他装饰器的使用，没有区别，要是有区别，就是内部函数必须有返回值，返回值为装饰函数的执行结果。

 4. 装饰带有不确定参数的函数

# 定义装饰器
def logging(fn):  # fn = sum_num
    def inner(*args, **kwargs):
        print("被装饰函数执行之前")
        fn(*args, **kwargs)
        print("被装饰函数执行之后")

    return inner  # sum_num = inner


# 使用装饰器装饰函数
@logging
def sum_num(*args, **kwargs):
    print(args, kwargs)


sum_num(1, 2, 3, age="18")

输出：

?

1 2 3

被装饰函数执行之前 (1, 2, 3) {'age': '18'} 被装饰函数执行之后

　　

# 定义装饰器
def logging(fn):  # fn = sum_num
    def inner(*args, **kwargs):
        print("被装饰函数执行之前")
        result = fn(*args, **kwargs)
        print("被装饰函数执行之后")
        return result

    return inner  # sum_num = inner

# 使用装饰器装饰函数
@logging
def sum_num(*args, **kwargs):
    print(args, kwargs)


sum_num(1, 2, 3, age="18")

5. 多个装饰器装饰一个函数

# 定义装饰器1
def check1(fn1):
    def inner1():
        print("登陆验证1")
        fn1()

    return inner1


# 定义装饰器2
def check2(fn2):
    def inner2():
        print("登陆验证2")
        fn2()

    return inner2

# 被装饰器的函数

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


comment()

输出：

?

1 2 3

登陆验证1 登陆验证2 发表评论

　　

6. 类装饰器

前提：需要掌握__init__、__call__ 2个内置函数。__init__函数用于类对象的初始化。当一个类的实例被像函数一样调用时，__call__ 方法会被调用。

# 定义一个类,实现__call__方法
class Check(object):
    def __call__(self, *args, **kwargs):
        print("我是call方法")

c = Check()
c()

当执行到“对象()”即c()时，会自动咨询__call__方法。输出：我是call方法

 

动态行为修改：在特定条件下，可以通过动态修改 __call__ 方法来改变类的实例的行为。

class DynamicBehavior:
    def __call__(self, *args, **kwargs):
        if 'override' in kwargs:
            print("动态修改行为")
        else:
            print("默认行为")


dyn = DynamicBehavior()
dyn()  # 输出：默认行为
dyn(override=True)  # 输出：动态修改行为

?

1 2	默认行为 动态修改行为

　　

类装饰器是一种特殊类型的装饰器，它使用类而不是函数来装饰其他函数或类。类装饰器可以通过定义 __call__ 方法来实现调用。

最佳实践：

1. 创建一个类装饰器时，需要确保它的 __init__ 方法接受被装饰的函数或类作为参数。
2. 在 __call__ 方法中实现装饰器逻辑，并返回一个新的函数或类。
3. 使用 @ 符号将类装饰器应用到要装饰的对象上。

# 1. 定义类装饰器
class MyDecorator:
    def __init__(self, decorated):  # 1. __init__必须有函数形参，实参是被装饰的函数
        self.decorated = decorated

    def __call__(self, *args, **kwargs):  # 2. 装饰逻辑写在__call__中
        # 在调用被装饰的函数之前执行一些操作
        print("Before function execution")

        # 调用被装饰的函数
        result = self.decorated(*args, **kwargs)

        # 在调用被装饰的函数之后执行一些操作
        print("After function execution")

        return result  # 如果被修饰函数有返回值就用此句，如果没有，省略此句


@MyDecorator
def my_function():
    print("Inside my_function")


my_function()

输出结果：

?

1 2 3

Before function execution Inside my_function After function execution