1.1、简单的装饰器

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

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

? 那么，如何执行原函数那？

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

# 旧函数，待装饰的函数

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提供了一个便捷的写法，我们称之为语法糖。

语法糖的写法：

· 找到要装饰的函数

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

@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 wrapper

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

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. 被装饰函数有参数

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

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.2、被装饰函数有不定参数和返回值

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

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.3、改变装饰器行为（给装饰器传参数）

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

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

@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.4、用类来定义装饰器（了解）

? 可执行对象究竟是什么？

? 具有__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'{fn()}'

return wrapper

def italic(fn):

def wrapper():

return f'{fn()}'

return wrapper

@italic

@bold

def hello():

return 'Hello World'

print(hello())

【结果】：

Hello World

1.4、总结

• 装饰器实际也是一个函数（可调用对象）；
• 接收一个老函数的名称；
• 返回新函数的名称；
• 在新函数里调用老函数；