> 科技资讯 > 谈一谈Python中的装饰器

谈一谈Python中的装饰器

科技资讯 投稿 5800℃ 0 评论

谈一谈Python中的装饰器

1、装饰器基础介绍

1.1 何为Python中的装饰器？

Python中装饰器的定义以及用途：

学过设计模式的朋友都知道，设计模式的结构型模式中也有一个叫装饰器模式，那这个和Python中的装饰器有什么不同呢？

设计模式中的装饰器的定义以及用途：

因此，Python中的装饰器和设计模式中的装饰器虽然名称相同，但是它们的实现方式和应用场景有很大的不同。

1.2 闭包

那什么叫做闭包呢？

看着上面的文字，是不是感觉有点抽象。我说一说我对闭包的理解

好像也有点抽象，我们来看一断代码，就能够理解上面的话了。

def my_decorator(:  # my_decorator 这个就叫做外部函数
    a = 1
    def inner(:  # inner 这个叫做内部函数
        print(a  # 内部函数引用到了外部函数中定义的变量
    return inner  # 外部函数的返回值是内部函数名

2、函数装饰器的实现

上面讲解了装饰器的定义、用途，还有闭包，那怎么去实现一个装饰器呢？不急，接下来我们一起来学习如何实现装饰器。

接下来，我们就一起实现一个装饰器，来计算函数的执行时间。Let‘s go!

2.1 不使用@实现装饰器

def process_time(func:
    def inner(*args, **kwargs:
        start_time = time.time(
        ret = func(*args, **kwargs
        end_time = time.time(
        print("函数的执行时间为:%d" % (end_time-start_time
        return ret
    return inner

接下来定义一个函数，使用比较来计算函数的执行时间。

import time


def process_time(func:
    def inner(*args, **kwargs:
        start_time = time.time(
        ret = func(*args, **kwargs
        end_time = time.time(
        print("函数的执行时间为:%d" % (end_time-start_time
        return ret
    return inner


def test(sleep_time:
    time.sleep(sleep_time


t1 = process_time(test
t1(1
print("------------"
t1(2

执行结果：

函数的执行时间为:1
------------
函数的执行时间为:2

通过上面的代码，我们观察到，我们并没有修改test函数的源代码，依旧给test函数添加上了统计函数执行时间的功能。

2.2 Python中使用语法糖的装饰器(推荐使用

import time


def process_time(func:
    def inner(*args, **kwargs:
        start_time = time.time(
        ret = func(*args, **kwargs
        end_time = time.time(
        print("函数的执行时间为:%d" % (end_time-start_time
        return ret
    return inner


@process_time
def test(sleep_time:
    time.sleep(sleep_time


test(1
print("------------"
test(2

执行结果：

函数的执行时间为:1
------------
函数的执行时间为:2

观察上面的代码变动，发现只有很少的部分修改了。

test函数上面添加了一行@process_time。

test函数的调用方式发生了改变。

提示：

当使用@装饰器时，Python解释器为我们做了什么？

Python 装饰器 @ 实际上是一种语法糖，它可以让我们在不改变原函数代码的情况下，对函数进行扩展或修改。当我们使用 @ 装饰器时，实际上是将被装饰函数作为参数传递给装饰器函数，然后将装饰器函数的返回值赋值给原函数名。因此，@ 装饰器并不会进行内存拷贝。

inner和test函数指向的是同一个内存地址。

import time


def process_time(func:

    print("func id --->", id(func

    def inner(*args, **kwargs:
        start_time = time.time(
        ret = func(*args, **kwargs
        end_time = time.time(
        print("函数的执行时间为:%d" % (end_time - start_time
        return ret

    print("inner id --->", id(inner
    return inner


@process_time
def test(sleep_time:
    print("test func id --->", id(test
    time.sleep(sleep_time


print("test id --->", id(test

执行结果：

func id ---> 4312377952
inner id ---> 4313983008
test id ---> 4313983008

使用语法糖时，Python解释器底层为我们做了这样的处理。

2.3 多个装饰器的执行顺序

def outer_1(func:
    print("coming outer_1"

    def inner_1(:
        print("coming inner_1"
        func(
    return inner_1


def outer_2(func:
    print("coming outer_2"

    def inner_2(:
        print("coming inner_2"
        func(

    return inner_2


def outer_3(func:
    print("coming outer_3"

    def inner_3(:
        print("coming inner_3"
        func(

    return inner_3


@outer_1
@outer_2
@outer_3
def test(:
    print("coming test"


test(

执行结果：

coming outer_3
coming outer_2
coming outer_1
coming inner_1
coming inner_2
coming inner_3
coming test

outer_3 -> outer_2 -> outer_1 -> inner_1 -> inner_2 -> inner_3 -> 被装饰函数

使用多个装饰器装饰函数时，
外部函数的执行顺序是从下到上的。
内部函数的执行顺序是从下往上的。

多个装饰器装饰函数时，Python解释器底层做了啥

def outer_1(func:
    print("coming outer_1, func id -->", id(func

    def inner_1(:
        print("coming inner_1"
        func(

    print("inner_1 id -->", id(inner_1
    return inner_1


def outer_2(func:
    print("coming outer_2, func id -->", id(func

    def inner_2(:
        print("coming inner_2"
        func(

    print("inner_2 id -->", id(inner_2
    return inner_2


def outer_3(func:
    print("coming outer_3, func id -->", id(func

    def inner_3(:
        print("coming inner_3"
        func(

    print("inner_3 id -->", id(inner_3
    return inner_3


@outer_1
@outer_2
@outer_3
def test(:
    print("coming test"


test(

执行结果：

coming outer_3, func id --> 4389102784
inner_3 id --> 4389102928
coming outer_2, func id --> 4389102928
inner_2 id --> 4389103072
coming outer_1, func id --> 4389103072
inner_1 id --> 4389103216
coming inner_1
coming inner_2
coming inner_3
coming test

2.4 带参数的装饰器

该如何实现带参数的装饰器呢，其实原理一样的，我们再定义一个外层函数，外层函数的返回值是内存函数的名称，即引用。

def is_process(flag:
    def outer_1(func:
        print("coming outer_1, func id -->", id(func

        def inner_1(:
            print("coming inner_1"
            if flag:
                func(

        print("inner_1 id -->", id(inner_1
        return inner_1
    return outer_1


@is_process(True
def test(:
    print("coming test"


test(

注意：

    我们装饰函数时，装饰器的写法不同了，变成了@is_process(True，这里是调用了is_process这个函数

3、函数装饰器的注意点(wraps函数

def outer_1(func:
    def inner_1(:
        print("inner_1, func __name__", func.__name__
        print("inner_1, func __doc__", func.__doc__
        func(

    return inner_1


@outer_1
def test(:
    """this is test"""
    print("outer_1, func __name__", test.__name__
    print("outer_1, func __doc__", test.__doc__


test(

函数执行结果：

inner_1, func __name__ test
inner_1, func __doc__ this is test
test, test __name__ inner_1
test, test __doc__ None

注意到没，在test函数体内打印函数的 __name__、__doc__ 属性，居然变成内部函数的了。

Python装饰器在装饰函数时，会将原函数的函数名、文档字符串、参数列表等属性复制到装饰器函数中，但是装饰器函数并不会复制原函数的所有属性。例如，原函数的name属性、doc属性、module属性等都不会被复制到装饰器函数中。

from functools import wraps


def outer_1(func:

    @wraps(func
    def inner_1(:
        print("inner_1, func __name__", func.__name__
        print("inner_1, func __doc__", func.__doc__
        func(

    return inner_1


@outer_1
def test(:
    """this is test"""
    print("test, test __name__", test.__name__
    print("test, test __doc__", test.__doc__


test(

执行结果：

inner_1, func __name__ test
inner_1, func __doc__ this is test
test, test __name__ test
test, test __doc__ this is test

4、类装饰器

上面我们都是使用的函数来实现装饰器的功能，那可不可以用类来实现装饰器的功能呢？我们知道函数实现装饰器的原理是外部函数的参数是被装饰的函数，外部函数返回内部函数的名称。内部函数中去执行被装饰的函数。

__call__方法时，这个类就成了可调用对象，实例化后可直接调用。

class ProcessTime:

    def __call__(self, *args, **kwargs:
        print("call"


p = ProcessTime(
p(

4.1 类装饰器的实现

import time


class ProcessTime:

    def __init__(self, func:

        print("coming ProcessTime __init__"
        self.func = func

    def __call__(self, *args, **kwargs:
        start_time = time.time(
        print("coming ProcessTime __call__, id(self.func -->", id(self.func
        ret = self.func(*args, **kwargs
        end_time = time.time(
        print("ProcessTime 函数的执行时间为:%d" % (end_time - start_time
        return ret


@ProcessTime
def test(sleep_time:
    time.sleep(sleep_time
    return "tet"


test(1

执行结果：

coming ProcessTime __init__
coming ProcessTime __call__, id(self.func --> 4488922160
ProcessTime 函数的执行时间为:1

通过上面的执行结果，我们可以得到，@ProcessTime的作用是 test = ProcessTime(test。又因为 ProcessTime定义了__call__方法，是可调用对象，所以可以像函数那样直接调用实例化ProcessTime后的对象。

ProcessTime类。得到的结果是一样的。

# @ProcessTime
def test(sleep_time:
    time.sleep(sleep_time
    return "tet"


test = ProcessTime(test
test(1

4.2 多个类装饰器的执行顺序

多个类装饰器的执行顺序是怎么样的呢，这里我们也通过代码来进行验证。

import time


class ProcessTime:

    def __init__(self, func:

        print("coming ProcessTime __init__", id(self
        self.func = func

    def __call__(self, *args, **kwargs:
        start_time = time.time(
        print("coming ProcessTime __call__, id(self.func -->", id(self.func
        ret = self.func(*args, **kwargs
        end_time = time.time(
        print("ProcessTime 函数的执行时间为:%d" % (end_time - start_time
        return ret


class ProcessTime2:

    def __init__(self, func:
        print("coming ProcessTime2 __init__", id(self
        self.func = func

    def __call__(self, *args, **kwargs:
        start_time = time.time(
        print("coming ProcessTime2 __call__, id(self.func -->", id(self.func
        ret = self.func(*args, **kwargs
        end_time = time.time(
        print("ProcessTime2 函数的执行时间为:%d" % (end_time - start_time
        return ret


@ProcessTime
@ProcessTime2
def test(sleep_time:
    time.sleep(sleep_time
    return "tet"


# test = ProcessTime2(test
# test = ProcessTime(test

t = test(1

执行结果：

coming ProcessTime2 __init__ 4472235104
coming ProcessTime __init__ 4473162672
coming ProcessTime __call__, id(self.func --> 4472235104
coming ProcessTime2 __call__, id(self.func --> 4471735344
ProcessTime2 函数的执行时间为:1
ProcessTime 函数的执行时间为:1

从上面的结果，我们得到，执行顺序是：

ProcessTime2 中的__init__ -> ProcessTime 中的__init__ -> ProcessTime 中的__call__ -> ProcessTime2 中的__call__

特别注意：

ProcessTime 中的__call__ 中的代码并不会执行完后再去执行 ProcessTime2 中的__call__，而是在调用 ret = self.func(*args, **kwargs 方法后，就回去执行 ProcessTime2 中的__call__的代码。

4.3 类装饰器存在的问题

import time
from functools import wraps


class ProcessTime:

    def __init__(self, func:

        print("coming ProcessTime __init__", id(self
        self.func = func

    def __call__(self, *args, **kwargs:
        start_time = time.time(
        print("coming ProcessTime __call__, id(self.func -->", id(self.func

        ret = self.func(*args, **kwargs
        end_time = time.time(
        print("ProcessTime 函数的执行时间为:%d" % (end_time - start_time
        return ret
        

@ProcessTime
def test(sleep_time:
    "tets"
    print("test.__doc__", test.__doc__
    # print(test.__name__  --> 报错，AttributeError: 'ProcessTime' object has no attribute '__name__'
    time.sleep(sleep_time
    return "tet"
  

t = test(1

那类装饰器该如何解决呢？

5、多个装饰器的执行顺序总结

其实，我觉得不用特别的去记多个装饰器的执行顺序是如何的，我们最重要的是理解到装饰器的执行逻辑是如何的。函数装饰器和类装饰器的初始化顺序都是一样的：从靠近被装饰的函数开始执行初始化操作。把这个核心原理理解到后，多个装饰器的执行顺序在使用的时候，就很容易得到了。

编程笔记 » 谈一谈Python中的装饰器

赞同 (30) or 分享 (0)
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽