源码时代python干货分享| python装饰的神奇魅力初体验

柔光的暖阳◎ 2023-05-30 08:45 35阅读 0赞

## 1.1.1 一个最简单的装饰行为 ##

装饰器的一个特点是：在执行原函数的基础上，增加内容。

咱们举个简单的例子：

我们可以把它用作日志打印器，在执行函数前，会有礼貌的告知你一下

“亲爱的coder，我要执行了”

在执行结束后，也会告知各位coder。

是不是很有趣？

那么，咱们如何执行原函数那？

✔把原函数的名字交给装饰函数，装饰函数就具备了执行老函数的能力。

旧函数，待装饰的函数
    def fun():
        print('我是老函数')
    
    def factory(old_fun):
        print('='*20)
        old_fun()
        print('='*20)
    
    factory(fun)

## 1.1.2 完善装饰行为 ##

上面的装饰行为还有哪些问题？

◇需要通过装饰工厂来调用原函数，原来调用这个功能的业务部门，将大面积修改代码；

那么如何改进这个问题那？

如何设计一个方式，在不改变原函数名称的情况下，调用时也执行装饰工厂那。

◇old\_name = factory(old\_name)

def fun(): 
    print("我是fun")
      def 
    factory(a):     
    def tmp():        
    print("="*10)         
    a()         
    print("="*10)     
    return tmp
       fun = factory(fun) 
    fun()

1.1.3python的装饰器语法糖

old\_name = factory(old\_name)这句话就是生成装饰器的核心语句。为了避免每次都写这样的无脑代码，python提供了一个便捷的写法，我们称之为语法糖。

语法糖的写法：

·找到要装饰的函数

·在上面写上@，然后跟装饰器函数的名称

1.1.4 总结

python的装饰器写法思路：

定义一个中介函数，该函数命名为装饰行为，接收一个可调用对象

def get\_timer(fn):

pass

2. 在中介函数内部实现装饰行为函数

def get\_timer(fn):

def wrapper():

... ... \# 装饰代码实现

3. 在中介函数最后返回装饰行为的函数名：

def get\_timer(fn):

def wrapper():

... ... \# 装饰代码实现

**return wrapper**

【注意】：返回的是函数名，而不是函数调用

4. 在需要被装饰的函数前，定义@装饰器名称

@get\_timer

def fun():

pass

**2. python**装饰器的几种形式

**2.1.** 无参数装饰器

Demo1: 增加函数什么时候运行的功能:

import time
    
    
    
    def time_fun(func):
    
        def my_time():
    
            print(f"{func.__name__} running at {time.ctime()}")
    
            func()
    
        return my_time
    
    
    
    @time_fun
    
    def fun1():
    
        print("+++++++++")
    
    
    
    fun1()
    
    time.sleep(2)
    
    fun1()

**2.2.** 被装饰函数有参数

*   *   *  装饰器的核心是内部函数的行为被重命名；
         *  内部函数的形式要满足原函数形式；

import time
    
    
    
    def time_fun(func):
    
        def my_time(arg1): # 内部函数里预留接口
    
            print(f"{func.__name__} running at {time.ctime()}")
    
            func(arg1) # 原函数传递参数
    
        return my_time
    
    
    
    @time_fun
    
    def fun1(arg1):
    
        print("+++++{}++++".format(arg1))
    
    
    
    fun1(10)
    
    time.sleep(2)
    
    fun1(10)

**2.3.** 被装饰函数有不定参数和返回值

原函数有返回值，内部装饰函数也接收返回值进行返回。

import time
    
    
    
    def time_fun(func):
    
        def my_time(*args, **kwargs):
    
            print(f"{func.__name__} running at {time.ctime()}")
    
            func(*args, **kwargs)
    
        return my_time
    
    
    
    @time_fun
    
    def fun1(arg1, arg2, name):
    
        print("+++++{},{},{}++++".format(arg1, arg2, name))
    
    
    
    fun1(10, 20, name='rocky')
    
    time.sleep(2)
    
    fun1(10, 20, name='jim')

**2.4.** 改变装饰器行为（给装饰器传参数）

在装饰器中，我们也有一种需求，根据传入的参数不同，装饰的行为方式也会不同，那么如何定义这种装饰器那。

首先再理解装饰器的语法：

@time_fun
    
    def fun1(arg1, arg2, name):
    
        print("+++++{},{},{}++++".format(arg1, arg2, name))
    
    原材料名称= 装饰器名称(原材料名称)
    
    @time_fun(“itsource”)
    
    def fun1(arg1, arg2, name):
    
        print("+++++{},{},{}++++".format(arg1, arg2, name))
    
    fun1 = time_fun(“itsource”)(fun1)
    
    这样来看，必须要保证time_fun(“itsource”)返回的内容恰好是标准的装饰器就可以满足了。
    
    import time
    
    
    
    def time_fun(flags):
    
        def time_arg(func):
    
            def my_time(*args, **kwargs):
    
                print(f"{func.__name__} running at {time.ctime()}")
    
                print("the flags is {}".format(flags))
    
                return func(*args, **kwargs)
    
            return my_time
    
        return time_arg
    
    
    
    @time_fun("itsource")
    
    def fun1(arg1, arg2, name):
    
        print("+++++{},{},{}++++".format(arg1, arg2, name))
    
    
    
    fun1(10, 20, name='rocky')
    
    time.sleep(2)
    
    fun1(10, 20, name='jim')

**2.5.** 用类来定义装饰器（了解）

可执行对象究竟是什么？

具有\_\_call\_\_方法的对象空间，就称之为可执行对象，每定义一个函数，就相当于在空间中定义了\_\_call\_\_方法。

如何利用类来实现装饰器

@Test \# fun = Test(fun)

def fun():

pass

*   *   *  λ Test的\_\_init\_\_方法应该接收被装饰函数的名称
         *  λ 调用fun()实际就是调用了Test类的\_\_call\_\_方法

class Test():

def \_\_init\_\_(self, fn):

self.old\_fun = fn

def \_\_call\_\_(self,):