Python装饰器详解

文章目录

  • 装饰器
    • 一、 基础准备
      • 1、 可调用对象
      • 2、 嵌套函数
        • 2.1.1 封装
        • 2.1.2 贯彻 DRY 原则
        • 2.1.3 闭包
      • 3、 描述器
        • 3.1 简介
        • 3.2 使用描述器
    • 二、 函数装饰器
      • 1、 无参装饰器
      • 2、 有参装饰器
    • 三、 类装饰器
      • 1、 查找对象属性
      • 2、 `__call__`实现类装饰器
      • 3、 将类装饰器添加到成员函数
      • 4、 带参数的类装饰器
    • 四、 装饰器修饰协程

装饰器

一、 基础准备

1、 可调用对象

在Python中,除了用户定义的函数,调用运算符(即 ())还可以应用到其他对象上。如果想判断对象能否调用,可以使用内置的 callable() 函数。Python 数据模型文档列出了以下 7 种可调用对象:

  1. 用户定义的函数

    使用def语句或lambda表达式创建

  2. 内置函数

    使用C语言(CPython)实现的函数,如:len()

  3. 内置方法

    使用C语言实现的方法,如:dict.get(key)

  4. 方法

    在类的定义体的函数

  5. 调用类是会运行类的__new__()方法创建一个实例,然后运行__init__()方法,初始化实例。最后把实例返回给调用方。因为Python没有new运算符,所以调用类相当于调用函数。(通常,调用类会创建那个类的实例,不过覆盖 __new__ 方法的话,也可能出现其他行为。)

  6. 类的实例

    如果类定义了__call__方法,那么它的实例可以作为函数调用

  7. 生成器函数

    使用yield关键字的函数或方法。调用生成器函数返回的是生成器对象

实例:把类的实例变成可调用对象

class Callable:
    def __call__(self, *args, **kwargs):
        return "类的实例对象被调用"


call = Callable()
print(call())
print(callable(call))

其相当于C语言里面的函数调用运算符的重载

2、 嵌套函数

嵌套函数是在另一个函数中定义的函数

使用场景:

  • 封装 - 数据隐藏
  • 贯彻 DRY原则
  • 闭包

2.1.1 封装

可以使用内层函数来保护它们不受函数外部变化的影响,也就是说把它们的作用域转换为局部作用域

def outer(n):
    count = 0  # 统计内层函数的调用次数

    def inner():
        print("内层函数被调用")
        nonlocal count
        count += 1  # 闭包处理

    return count

在全局作用域下,尝试去访问count变量会报错,访问内层函数也会报错

实例,递归函数的高级实现

def multi(n):
    if not isinstance(n, int):
        # 如果数字不是整型
        raise TypeError("n must be Integer")
    if n < 0:
        # 如果输入的数据小于0
        raise ValueError("n must be zero or positive")

    def inner_multi(n):
        # 内层函数嵌套求乘积
        if n <= 1:
            return 1
        return n * inner_multi(n - 1)

    return inner_multi(n)


print(multi(3))

当传入的数据不符合求乘积的规则时,报错

2.1.2 贯彻 DRY 原则

DRY 原则:

  • 是指在程序设计以及计算中避免重复代码,因为这样会降低灵活性、简洁性,并且有可能导致代码之间的矛盾
  • 其更多的是一种架构设计思想,在软件开发过程中的万事万物均可能重复,大到标准、框架、开发流程;中到组件、接口;小到功能、代码均纯存在自我重复。而 DRY 提倡的就是在软件开发过程中应消除所有这些自我重复

比如,函数装饰器的使用

2.1.3 闭包

闭包的介绍:

  • 在一个内部函数中,对外部作用域的变量进行引用,(并且一般外部函数的返回值为内部函数),那么内部函数就被认为是闭包

闭包的作用:

  1. 当闭包执行完后,仍然能够保持住当前的运行环境
  2. 闭包可以根据外部作用域的局部变量来得到不同的结果

Python装饰器的本质是返回一个函数地址,然后发生函数调用

比如

def print_():
    print("你好")
    def inner():
        print("hello")
    return inner  # 将内层函数的地址返回
def main(print_):
    # 将函数作为参数传输
    inner = print_()
    print(inner)  # 其为内层函数的地址
    inner()  # 调用内层函数
main(print_)

函数可以当做其他函数的参数进行传入,同时如果返回值是函数,则返回该函数的内存地址

3、 描述器

3.1 简介

描述器是一个Python对象,只要其具有__get__(), __set__(), __delete__()方法中任意一个方法的对象就叫做描述器。一个对象在访问描述器时,如果该属性是一个描述器,则默认属性回调规则会被__set__(), __get__(), __delete__()方法所覆盖

作用:

  • python内部自带的staticmethod, classmethod, property, super等都是描述器,在很多Python库中也都有描述器的身影,使用描述器能让你有更高的概率写出优美的代码、更简洁的API,并且会加深对Python理解

3.2 使用描述器

class Des:

    def __get__(self, instance, owner):
        print('returned from des obj')  
        return self.value  # 访问实例属性触发

    def __set__(self, instance, value):
        print('set in des obj')
        self.value = value  # 设置对象属性的值时

    def __delete__(self, instance):
        print('delete in des obj')
        del self.value  # 删除对象时触发


class Foo:
    d = Des()


f = Foo()
f.d = 10
print(f.d)
del f.d

关于描述器的更多内容,请查看官方文档,这里只要求了解

二、 函数装饰器

使用函数作为装饰器

1、 无参装饰器

语法:

@函数名
def test():
    pass

实例:

def decorate(func):  # 将函数传入其中
    print("函数传入")
    print(func.__name__)

    def inner(*args, **kwargs):
        print("函数开始运行")
        func(*args, **kwargs)  # 如果此函数有返回值,则要给内层函数添加返回值
        print("函数运行结束")

    return inner  # 将内层函数,返回给外层函数


@decorate
def test():
    print("你好李华")


test()
print(test.__name__)  # 发现函数名称变为了inner
"""
# 如果不使用装饰器的话
test = decorate(test)  # 接收内层函数
test()  # 调用内层函数
"""

注意:

  • __name__:属性获取函数的名称
  • __doc__:属性获取函数里面的注释

装饰器语法实现在运行时,将待装饰的函数重定向到装饰后的函数,装饰后的原函数__name__属性发生改变

那么,如何使得函数属性name的问题呢?

from functools import wraps

def decorate(func):
    print("函数传入")

    @wraps(func)  # 再次使用一个装饰器,使得函数名称不会改变
    def inner(*args, **kwargs):
        print("函数开始运行")
        func(*args, **kwargs)
        print("函数运行结束")

    return inner


@decorate
def test():
    print("你好李华")


test()
print(test.__name__)  

2、 有参装饰器

from functools import wraps


def decorate_outer(name):
    print(name)

    def decorate(func):
        print("函数传入")

        @wraps(func)  # 再次使用一个装饰器,使得函数名称不会改变
        def inner(*args, **kwargs):
            print("函数开始运行")
            func(*args, **kwargs)
            print("函数运行结束")

        return inner

    return decorate


@decorate_outer("你好呀")
def test():
    print("你好李华")


test()

通过使用三层函数嵌套来实现,最外层函数接收的参数为装饰器自带的参数,次外层函数接收的参数是使用装饰器的函数

当装饰器给类使用时,实现步骤也是一样:

from functools import wraps


def decorate(cls):
    print("类传入")

    @wraps(cls)  # 再次使用一个装饰器,使得类名称不会改变
    def inner(*args, **kwargs):
        print("类开始创建")
        print(cls.__name__)
        c = cls(*args, **kwargs)  # 创建类
        print("类创建结束")
        return c  # 将创建的类返回

    return inner


@decorate
class A:
    def print_print(self):
        print("李华好呀")


a = A()
a.print_print()
# 相当于
# A = decorate(A)
# a = A()

三、 类装饰器

1、 查找对象属性

class A:
    def __init__(self, name):
        self.name = name

    def test(self):
        print("test")


a = A("李华")
print(dir(a))  # 获取对象属性或者实例属性
print(a.__dict__)  # 存储对象属性(类和类的实例均为对象)的一个字典,其键为属性名,值为属性的值

属性查找顺序:

  1. 判断是不是系统是自动产生的属性
  2. 在对象实例属性的字典(a.dict)中查找
  3. 在对象属性的字典(A.dict)中查找
  4. 在对象的父类中的字典(dict)中查找

只有在类的字典中找到属性,python才会去看看它有没有get等方法,对一个在实例的字典中找到的属性,python不会理会有没有get方法,而是直接返回属性本身

基于前面的使用函数作为装饰器的理解,将类作为装饰器时需要保证以下几点

  1. 类的实例是可调用的
  2. 类需要一个地方讲被装饰的函数传入到类的实例里

第一条可以通过__call__实现,第二条可以通过__init__实现

2、 __call__实现类装饰器

class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func

    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.func(*args, **kwargs)  # 如果有返回值,则要在最后面使用return返回
        print("函数运行结束")


@Decorate
def print_hello():
    print("hello")


print_hello()
print(print_hello.__name__)  # 发现报错
"""
相当于
print_hello = Decorate(print_hello)
print_hello()
"""

我们发现无法输出__name__,根据约定使用装饰器不能改变函数的__name__属性,因此我们还需要改进将类作为装饰器的使用方法

解决方法,添加一个wraps(func)(self)

from functools import wraps
class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func
        wraps(func)(self)  # 为属性增加一个__wrapped__作为类实例属性

    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.__wrapped__(*args, **kwargs)  # self.__wrapped__即为self.func
        print("函数运行结束")


@Decorate
def print_hello():
    print("hello")


print_hello()
print(print_hello.__name__)  # 返回的名字即为函数名

那么,我们以及会将此类作为装饰器正确使用了,似乎定义了__call__方法就说明问题就解决了,那么真的是如此吗?

3、 将类装饰器添加到成员函数

如果直接添加到成员函数中,会直接报错

那么,但类装饰器应用于成员函数时,类成员函数变成什么样呢?

import types
from functools import wraps

class Decorate:
    def __init__(self, func):
        print("函数正在传入")
        self.func = func
        wraps(func)(self)  # 为属性增加一个__wrapped__作为类实例属性

    def __call__(self, *args, **kwargs):
        print("函数开始运行")
        self.__wrapped__(*args, **kwargs)  # self.__wrapped__即为self.func
        print("函数运行结束")

    def __get__(self, instance, cls):
        """:param: instance: 即为调用装饰器的实例对象
                    cls: 即为类对象"""
        # print(instance, cls, self)
        if instance is None:
            return self
        else:
            return types.MethodType(self, instance)  # 将A实例对象添加给self里面

class A:

    @Decorate
    def test(self):
        print('hello')


a = A()
a.test()

这里需要添加__get__魔法方法,将装饰器的self对象的指向,添加A的实例对象

魔法方法具体使用,在官方文档中有详细描述:【https://docs.python.org/zh-cn/3/reference/datamodel.html】

4、 带参数的类装饰器

带参数和不带参数的类装饰器有很大不同。

__init__:不再接收被装饰函数,而是接收传入参数

__call__:接收被装饰的函数,实现装饰逻辑

from functools import wraps


class logger(object):
    def __init__(self, level='INFO'):
        self.level = level

    def __call__(self, func):  # 接受函数
        @wraps(func)
        def wrapper(*args, **kwargs):
            print("[{level}]: the function {func}() is running...".format(level=self.level, func=func.__name__))
            func(*args, **kwargs)

        return wrapper  # 返回函数


@logger(level='WARNING')
def say(something):
    print("say {}!".format(something))


say("hello")
print(say.__name__)

四、 装饰器修饰协程

使用异步装饰器装饰协程比较写法比较简单,调用外部函数是要使用await挂起

同时,内层函数必须转换为协程函数

import asyncio
from functools import wraps
from time import time


def decorate(func):
    print("协程函数传入")

    @wraps(func)
    async def inner(*args, **kwargs):
        # 将装饰器转换成协程函数
        print("开始运行函数")
        ret = await func(*args, **kwargs)
        print("函数运行完成")
        return ret

    return inner


@decorate
async def print_(a):
    await asyncio.sleep(2)
    return a


async def main():
    tasks = [asyncio.create_task(print_(i)) for i in range(10)]
    done, padding = await asyncio.wait(tasks)
    for i in list(done):
        print(i.result())  # 获取返回值

start = time()
asyncio.run(main())
print(f"用时{time() - start}")

你可能感兴趣的:(python,python,装饰器模式,后端)