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

简单的装饰器

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.3.python的装饰器语法糖

old_name = factory(old_name)这句话就是生成装饰器的核心语句。为了不每次都写这样的无脑代码，python提供了一个便捷的写法，咱们称之为语法糖。
语法糖的写法：
· 找到要装饰的函数
· 在上面写上@，而后跟装饰器函数的名称br/>@decortate
def fun():
print('in fun() ...')
1.1.4.总结
python的装饰器写法思路：
1.定义一个中介函数，该函数命名为装饰行为，接收一个可调用对象
def get_timer(fn):
pass
2.在中介函数内部实现装饰行为函数
def get_timer(fn):
def wrapper():
... ... # 装饰代码实现
3.在中介函数最后返回装饰行为的函数名：
def get_timer(fn):
def wrapper():
... ... # 装饰代码实现
return wrapperbr/>【注意】：返回的是函数名，而不是函数调用
4.在须要被装饰的函数前，定义@装饰器名称
@get_timer
def fun():
pass

1.2.python装饰器的几种形式

1.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()

1.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)

1.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')

1.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')

1.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,):
    ... ...                     # 装饰内容
    ret = self.old_fun()

@Test
def fun(a, b, name):
pass
fun()

1.3.多层装饰

在实际开发时，一个原函数，可使用多个装饰函数进行修饰，这种行为就称之为多层装饰。
对于多层装饰，要理解他的执行过程。

def bold(fn):
    def wrapper():
        return f'<b>{fn()}</b>'
return wrapper

def italic(fn):
    def wrapper():
        return f'<i>{fn()}</i>'
    return wrapper

@italic
@bold
def hello():
    return 'Hello World'

print(hello())

【结果】：<i><b>Hello World</b></i>1.4.总结装饰器实际也是一个函数（可调用对象）；接收一个老函数的名称；返回新函数的名称；在新函数里调用老函数；