Python装饰器的使用详解

简介: Python装饰器,大致可分为:无参装饰器、带参装饰器。接下来我们一探究竟

装饰器

Python装饰器,大致可分为:无参装饰器、带参装饰器。接下来我们一探究竟

<br/>

多个装饰器一起使用

"""
装饰器的具体使用
"""

print("# -------------------- 多个装饰器一起使用 -------------------- #")


# 加粗
def make_bold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"

    return wrapped


# 斜体
def make_italic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"

    return wrapped


@make_bold
def test1():
    return "hello world-1"


@make_italic
def test2():
    return "hello world-2"


# 两个装饰器一起使用
@make_bold
@make_italic
def test3():
    return "hello world-3"


print(test1())
print(test2())
print(test3())

<br/>

运行结果:

# -------------------- 多个装饰器一起使用 -------------------- #
<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>

<br/>

可以发现装饰 test3 的结果是先变斜体,然后在加粗。首先程序是从上到下执行的,当遇到 @make_bold 时它会把下面的函数引用传递给 make_bold 函数,但下面的又是一个装饰器 @make_italic ,这个装饰器一样会把下面的函数 test3 传递给 make_italic 函数,先将make_italic 函数的返回值 wrapped 赋值给 test3,然后这个新的 test3 函数再传递给 make_bold。因此是先变斜体,然后再加粗。

可能理解起来会很绕,看看下面这段程序结果你就更明白了,最好是亲自去尝试一下,加强理解。

"""
装饰器的具体使用
"""

print("# -------------------- 多个装饰器一起使用 -------------------- #")


# 加粗
def make_bold(fn):
    print("make_bold called")
    print(fn.__name__)

    def wrapped():
        return "<b>" + fn() + "</b>"

    return wrapped


# 斜体
def make_italic(fn):
    print("make_italic called")
    print(fn.__name__)

    def wrapped():
        return "<i>" + fn() + "</i>"

    return wrapped


# 两个装饰器一起使用
@make_bold
@make_italic
def test3():
    return "hello world-3"


print(test3())

<br/>

运行结果:

# -------------------- 多个装饰器一起使用 -------------------- #
make_italic called
function name: test3
    
make_bold called
function name: wrapped
<b><i>hello world-3</i></b>

先传递 test3 函数,经过 @make_italic 装饰器后 test3 = wrapped,在传递 test3 函数,而此时test3 其实就是 wrapped。因此第二次 fn.__name__,打印是 wrapped

<br/>

各种装饰器示例

无参数的装饰器

print("# -------------------- 无参数装饰器 -------------------- #")
from time import ctime, sleep


# 打印当前运行时间
def cur_time(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        func()

    return wrapped_func


@cur_time
def foo():
    print("I am foo")


foo()
sleep(2)
foo()

<br/>

上面代码理解装饰器执行行为可理解成


# foo先作为参数赋值给func后,foo接收指向timefun返回的wrapped_func
foo = timefun(foo)

# 调用foo(),即等价调用wrapped_func()
foo()

# 内部函数wrapped_func被引用,所以外部函数的func变量(自由变量)并没有释放
# func里保存的是原foo函数对象

<br/>

运行结果:

# -------------------- 无参数装饰器 -------------------- #
foo called at Thu Apr 15 20:40:35 2021
I am foo
foo called at Thu Apr 15 20:40:37 2021
I am foo

<br/>

被装饰的函数有参数

print("# -------------------- 被装饰的函数有参数 -------------------- #")
from time import ctime, sleep


def cur_time(func):

    # 注意在这里接受函数参数
    def wrapped_func(a, b):
        print("%s called at %s" % (func.__name__, ctime()))
        print(a, b)
        func(a, b)

    return wrapped_func


@cur_time
def foo(a, b):
    print(a + b)


foo(3, 5)
sleep(2)
foo(2, 4)

<br/>

运行结果:

# -------------------- 被装饰的函数有参数 -------------------- #
foo called at Thu Apr 15 20:47:18 2021
3 5
8
foo called at Thu Apr 15 20:47:20 2021
2 4
6

<br/>

被装饰的函数有不定长参数

print("# -------------------- 被装饰的函数有不定长参数 -------------------- #")
from time import ctime, sleep


def cur_time(func):

    # 这里用*arg **kwargs来接受不定长参数
    def wrapped_func(*args, **kwargs):
        print("%s called at %s" % (func.__name__, ctime()))
        print("args:", args)
        print("kwargs:", kwargs)
        func(*args, **kwargs)

    return wrapped_func


@cur_time
def foo(a, b, c):
    print(a + b + c)


foo(1, 3, 5)
sleep(2)
foo(2, 4, c=6)

<br/>

运行结果:

# -------------------- 被装饰的函数有不定长参数 -------------------- #
foo called at Thu Apr 15 21:10:02 2021
args: (1, 3, 5)
kwargs: {}
9

foo called at Thu Apr 15 21:10:05 2021
args: (2, 4)
kwargs: {'c': 6}
12

foo(2, 4, c=6) 举例,2, 4 会以元组的形式传递给 argsc=6 这种键值对的则是以字典的形式传递给 kwargs ,需注意的是在函数参数定义的时候需在参数名前带上 *。参数名称可以自定义但 * 不能少,否则就不是不定参数函数。例如 *args 可以换成 *params*kwargs 可以换成 *kws。但我们最好不要改动。

<br/>

装饰器中的return

print("# -------------------- 装饰器的return -------------------- #")
from time import ctime, sleep


def cur_time(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        func()

    return wrapped_func


@cur_time
def foo():
    print("I am foo")


@cur_time
def get_info():
    return '----hei hei---'


foo()
sleep(2)
foo()

print(get_info())

<br/>

执行结果:

# -------------------- 装饰器的return -------------------- #
foo called at Thu Apr 15 21:27:52 2021
I am foo

foo called at Thu Apr 15 21:27:54 2021
I am foo

get_info called at Thu Apr 15 21:27:54 2021
None

<br/>

如果修改装饰器为如下

def cur_time(func):
    def wrapped_func():
        print("%s called at %s" % (func.__name__, ctime()))
        ret = func() # 先接收函数的返回值
        return ret   # 然后返回出去

    return wrapped_func

<br/>

则运行结果:

# -------------------- 装饰器的return -------------------- #
foo called at Thu Apr 15 21:32:43 2021
I am foo

foo called at Thu Apr 15 21:32:45 2021
I am foo

get_info called at Thu Apr 15 21:32:45 2021
----hei hei---

<br/>

说明:

一般情况下为了让装饰器更通用,可以有 return

<br/>

装饰器带参数

print("# -------------------- 装饰器带参数 -------------------- #")
from time import ctime, sleep


def time_arg(pre="hello"):

    def cur_time(func):
        def wrapped_func():
            print("%s called at %s %s" % (func.__name__, ctime(), pre))
            return func()

        return wrapped_func

    return cur_time


@time_arg("hui")
def foo():
    print("I am foo")


@time_arg("python")
def goo():
    print("I am goo")


foo()
sleep(2)
foo()

goo()
sleep(2)
goo()

<br/>

装饰过程如下

1. 先调用 time_arg("hui")

2. 将步骤1得到的返回值,即cur_time返回, 然后装饰器@time_arg('hui')就变成了@cur_time

3. 将 foo 传递给 cur_time

3. 将 cur_time(foo)的结果返回,即wrapped_func

4. 让foo = wrapped_fun,即foo现在指向wrapped_func

可以理解为

foo() == timef_arg("hui")(foo)()
goo() == timef_arg("python")(goo)()

<br/>

记住 xxx()xxx 调用,而 @decorate 则执行 decorate 函数,只不过会把 @ 下面被装饰的函数当做参数传递给 decorate 函数执行。

<br/>

类装饰器(扩展)

装饰器函数其实是这样一个接口约束,它必须接受一个 callable 对象作为参数,然后返回一个 callable 对象。在Python中一般 callable 对象都是函数,但也有例外。只要某个对象重写了 __call__() 方法,那么这个对象就是 callable 的。

  • callable 就是可被调用执行的对象
class Test():
    def __call__(self):
        print('call me!')

t = Test()
t()  # 输出 call me

<br/>

类装饰器demo

class Test(object):
    
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s" % func.__name__)
        self.__func = func
        
    def __call__(self):
        print("---装饰器中的功能---")
        self.__func()

@Test
def test():
    print("----test---")
test()

<br/>

说明:

1. 当用Test来装作装饰器对test函数进行装饰的时候,首先会创建Test的实例对象
    并且会把test这个函数名当做参数传递到__init__方法中
    即在__init__方法中的属性__func指向了test指向的函数

2. test指向了用Test创建出来的实例对象

3. 当在使用test()进行调用时,就相当于让这个对象(),因此会调用这个对象的__call__方法

4. 为了能够在__call__方法中调用原来test指向的函数体,
    所以在__init__方法中就需要一个实例属性来保存这个函数体的引用
    所以才有了self.__func = func这句代码,从而在调用__call__方法中能够调用到test之前的函数体

<br/>

运行结果如下:

---初始化---
func name is test
---装饰器中的功能---
----test---

<br/>

源代码

源代码已上传到 Gitee PythonKnowledge: Python知识宝库,欢迎大家来访。

✍ 码字不易,万水千山总是情,点赞再走行不行,还望各位大侠多多支持❤️

<br/>

公众号

新建文件夹X

大自然用数百亿年创造出我们现实世界,而程序员用几百年创造出一个完全不同的虚拟世界。我们用键盘敲出一砖一瓦,用大脑构建一切。人们把1000视为权威,我们反其道行之,捍卫1024的地位。我们不是键盘侠,我们只是平凡世界中不凡的缔造者 。
相关文章
|
12天前
|
存储 索引 Python
|
2天前
|
缓存 测试技术 数据安全/隐私保护
探索Python中的装饰器:简化代码,增强功能
【10月更文挑战第29天】本文通过深入浅出的方式,探讨了Python装饰器的概念、使用场景和实现方法。文章不仅介绍了装饰器的基本知识,还通过实例展示了如何利用装饰器优化代码结构,提高代码的可读性和重用性。适合初学者和有一定经验的开发者阅读,旨在帮助读者更好地理解和应用装饰器,提升编程效率。
|
2天前
|
测试技术 Python
深入浅出Python装饰器
【10月更文挑战第28天】本文将通过一个生动的比喻,带你走进Python装饰器的世界。就像给蛋糕加上精美的糖衣,让味道和外观更加诱人,Python装饰器同样为我们的代码增添魔力。我们将从基础概念出发,一步步深入到装饰器的实际应用,最后探讨如何避免常见的陷阱。准备好了吗?让我们一起揭开Python装饰器的神秘面纱!
9 3
|
9天前
|
开发者 Python
探索Python中的装饰器:简化代码,增强功能
【10月更文挑战第22天】在Python的世界里,装饰器是一个强大的工具,它能够让我们以简洁的方式修改函数的行为,增加额外的功能而不需要重写原有代码。本文将带你了解装饰器的基本概念,并通过实例展示如何一步步构建自己的装饰器,从而让你的代码更加高效、易于维护。
|
10天前
|
开发框架 Python
探索Python中的装饰器:简化代码,增强功能
【10月更文挑战第20天】在编程的海洋中,简洁与强大是航行的双桨。Python的装饰器,这一高级特性,恰似海风助力,让代码更优雅、功能更强大。本文将带你领略装饰器的奥秘,从基础概念到实际应用,一步步深入其内涵与意义。
|
7天前
|
测试技术 开发者 Python
深入浅出:Python中的装饰器解析与应用###
【10月更文挑战第22天】 本文将带你走进Python装饰器的世界,揭示其背后的魔法。我们将一起探索装饰器的定义、工作原理、常见用法以及如何自定义装饰器,让你的代码更加简洁高效。无论你是Python新手还是有一定经验的开发者,相信这篇文章都能为你带来新的启发和收获。 ###
8 1
|
7天前
|
设计模式 测试技术 开发者
Python中的装饰器深度解析
【10月更文挑战第24天】在Python的世界中,装饰器是那些能够为函数或类“添彩”的魔法工具。本文将带你深入理解装饰器的概念、工作原理以及如何自定义装饰器,让你的代码更加优雅和高效。
|
7天前
|
测试技术 数据安全/隐私保护 Python
探索Python中的装饰器:简化和增强你的函数
【10月更文挑战第24天】在Python编程的海洋中,装饰器是那把可以令你的代码更简洁、更强大的魔法棒。它们不仅能够扩展函数的功能,还能保持代码的整洁性。本文将带你深入了解装饰器的概念、实现方式以及如何通过它们来提升你的代码质量。让我们一起揭开装饰器的神秘面纱,学习如何用它们来打造更加优雅和高效的代码。
|
7天前
|
测试技术 开发者 Python
探索Python中的装饰器:从入门到实践
【10月更文挑战第24天】 在Python的世界里,装饰器是一个既神秘又强大的工具。它们就像是程序的“隐形斗篷”,能在不改变原有代码结构的情况下,增加新的功能。本篇文章将带你走进装饰器的世界,从基础概念出发,通过实际例子,逐步深入到装饰器的高级应用,让你的代码更加优雅和高效。无论你是初学者还是有一定经验的开发者,这篇文章都将为你打开一扇通往高效编程的大门。
|
8天前
|
程序员 Python
深入浅出Python装饰器
【10月更文挑战第22天】在编程的世界里,我们经常追求代码的优雅和可重用性。Python中的装饰器就是这样一个神奇的工具,它允许我们在不改变原有函数定义的情况下增加额外的功能。本文将通过浅显易懂的方式介绍装饰器的概念、用法及其背后的原理,带你一步步深入理解这个强大的特性。