【python】装饰器详细解读——究其本质：偷梁换柱

初步理解装饰器

现在在网上买手机时，很多商家都会提供贴膜、送手机壳的服务。我们可以认为手机就是被装饰的函数，而商家就是装饰器。下面是用伪代码来描述这个过程。

# 从官方店买手机的流程：付钱、拿货
def 买手机流程():
	'''这个是正常的流程'''
	付钱()
	return 拿货() # 直接返回一个【手机】

def 第三方商家(原流程):
	'''如果从第三方卖家那里买，就是卖家先去官方店买手机，然后再卖给你，就多了一些流程
	【装饰器的内层函数要替换被装饰的函数，也就是外层函数的参数】
	'''
	def 卖家流程():
		手机 = 原流程()
		手机 = 贴膜(手机)	# 送贴膜和手机壳是商家额外提供的步骤
		送手机壳()
		return 手机 # 卖家的流程也会返回【手机】，但是多了一些步骤
	'''【这个函数会把内层函数返回，这样原来的函数就会被内层函数替换】
	在这里也就是“卖家流程”会替换正常的“买手机”流程。
	当然这里只是把新流程返回出去了，真正的替换是在下面的赋值
	'''
	return 卖家流程 # 最后会用这个流程来替换原流程

# 如果是从官方店买：
我的手机 = 买手机流程()
# 如果是从第三方卖家买：
买手机流程=第三方商家(买手机流程)
'''经过第三方商家后，现在的“买手机”已经不是原来的那个了，而是第三方商家提供的“卖家流程”。
这里经过赋值以后，买手机这个流程（函数）已经是“卖家流程”了
【注意这里是给函数赋值，也就是把原来的函数替换了】
'''
我的手机 = 买手机()

总的来说，装饰器做的就是制造一个新函数，它和被装饰的原函数长得一样、所以可以直接替换原函数。究其本质的话，装饰器其实就是在“偷梁换柱”而已。

装饰器的本质

python的装饰器写法实际上是一个python提供的语法糖。

语法糖就是在计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。

首先定义如下函数作为装饰器

def highlight(func):
	def wrapper():
		print("================")
		func()
		print("================")
	return wrapper

那么对于如下的代码

@highlight
def say_hello():
	print("hello")

等价于下面的写法

def say_hello():
	print("hello")
say_hello = highlight(say_hello)

装饰器实际上是一个以函数为参数的函数，并且这个函数返回值也是函数。

如果参数和接收返回值的对象是同一个函数的话，就完成了对函数的替换。

那么上面【买手机】例子中的代码就可以简写为如下代码。

def 第三方商家(原流程):
	# 这里为了节约篇幅就省略具体的函数体了
	...

@第三方商家
def 买手机():
	...

我的手机=买手机

装饰器的各种写法

适配有参函数的装饰器

当被装饰的函数没有参数的时候，这种装饰器很好写，就是一个简单的替换关系。

def decorator(f):
	def wrapper():
		# todo 函数执行前做的事情
		ret_val = f() # 接收返回值
		return ret_val # 返回原函数的返回值。当然我们也可以处理一下再返回
		# todo 函数执行后做的事情
	return wrapper # 把内层函数返回出去

但是实际开发过程中，一个装饰器不止用在一个函数上——或者说装饰器本来就是要用在不同函数上的——所以我们要让装饰器能适配各种参数的函数。而上面那种写法显然只能用于没有参数的函数。

在python中，如果参数的个数不确定，则我们可以用下面的方法来定义函数

def func(*args, **kwargs):
	...

这样定义的函数可以按照一定的规则任意传入参数。这里就不过多说明这个规则是什么了，只要知道这样写可以任意传参数就行。

其中args接收没有名字的参数，是一个列表；而kwargs接收有名字的参数，是一个字典。例如下面的代码。

func(1, 2, 3, a=1, b=2, c=3)

这样传入参数以后

args=[1, 2, 3]
kwargs={"a": 1, "b": 2, "c": 3}

而在列表变量前面加上一个“*”可以把列表变成参数，而在字典变量前面加两个“*”则可以把字典也变成参数。例子如下。

a=[1, 2]
b={"a": 3, "b": 4}
func(*a, **b)
# 等价于：
func(1, 2, a=3, b=4)

也就是说，定义函数时，*可以把参数变成列表和字典；而调用函数时，*可以把列表和字典变成参数。

现在有了这样一件“法宝”，我们就可以让装饰器适配任意参数的函数了。我们可以按照如下方法去写

def decorator(f):
    def wrapper(*args, **kwargs):
        print("=========BEGIN==========")
        f(*args, **kwargs)
        print("==========END===========")
    return wrapper

@decorator
def say(times, word):
    for _ in range(times):
        print("hello", word)

say(5, word="world")

运行结果

=========BEGIN==========
hello world
hello world
hello world
hello world
hello world
==========END===========

带参数的装饰器

光是能适配参数还不够，装饰器本身也可以接收参数。比如说我想定义一个装饰器，可以把一个函数重复执行指定次数，如下。

@repeat(3)
def func():
	print("hello")

我们把这个装饰器写法复原成最本质的写法，即

def func():
	print("hello")
func = repeat(3)(func) # 装饰器的本质：参数和返回值都是函数的函数

对比一般的装饰器的本质

func = decorator(func)

可以看出，repeat(3)这个函数的返回值是一个装饰器，也就是说，装饰器被定义在一个函数中，而这个函数返回装饰器。那么我们可以这样实现这个装饰器：

def repeat(n):	# 用于给装饰器提供参数的函数
	# =============装饰器=================
    def decorator(f):	# 装饰器
        def wrapper(*args, **kwargs):	# 装饰器内层函数
            for _ in range(n):
                f(*args, **kwargs)
        return wrapper
    # ====================================
    return decorator	# 返回装饰器函数

@repeat(3)
def say_hello(word):
	print("hello", word)

say_hello("world")

运行结果

hello world
hello world
hello world

多层嵌套装饰器

其实就是一个函数被多个装饰器修饰。先看一个抽象的例子。

@deco2
@deco1
def func():
	...

很显然，函数func先被deco1修饰，然后又被deco2修饰。把这段代码展开得到：

func = deco1(func)
func = deco2(func)

那么很显然，执行func时的顺序是：deco2 -> deco1 -> func. 但是值得注意的是，装饰器产生的效果的顺序是反过来的，原因是内层装饰器的结果要被外层装饰器修饰。

看一个具体的例子就很清晰了。

def highlight(f):
    '''把函数的输出包裹在两排等号中间以突出显示'''
    def wrapper(*args, **kwargs):
        print("=========BEGIN==========")
        f(*args, **kwargs)
        print("==========END===========")
    return wrapper

def repeat(n):
    def decorator(f):
        '''把函数重复执行n次'''
        def wrapper(*args, **kwargs):
            for _ in range(n):
                f(*args, **kwargs)
        return wrapper
    return decorator

'''先突出显示再重复'''
@repeat(3)
@highlight
def say1(word):
    print("hello", word)

'''先重复再突出显示'''
@highlight
@repeat(3)
def say2(word):
    print("hello", word)

print("\n============say1: 先突出显示再重复===========")
say1("world")
print("\n============say1: 先重复再突出显示===========")
say2("RLS")

运行结果

####### say1: 先突出显示再重复 #######
=========BEGIN==========
hello world
==========END===========
=========BEGIN==========
hello world
==========END===========
=========BEGIN==========
hello world
==========END===========

####### say1: 先重复再突出显示 #######
=========BEGIN==========
hello RLS
hello RLS
hello RLS
==========END===========

总结成一句话，谁离原函数近，谁先生效。

装饰器的副作用以及解决方案

影响函数的属性

对于一个没有被装饰器修饰过的函数而已，它的属性就是定义这个函数时的属性值。而一个函数一旦经过装饰器的修饰，那么它的属性就会变成最外层装饰器的内层函数的属性值。下面以__name__属性为例进行演示。

def func1():
	pass

@highlight # highlight装饰器见上文定义
@repeat(3) # repeat装饰器见上文定义
def func2():
	pass
print(func1.__name__)
print(func2.__name__)

运行结果

func1
wrapper

解决方案
python标准库functools中提供了一个装饰器wraps，参数为装饰器所修饰的函数，把这个装饰器作用在自定义装饰器的内层函数上就可以解决函数属性值被装饰器修改的副作用。

import functools
def repeat(n):
    def decorator(f):
        '''把函数重复执行n次
        functools.wraps这个装饰器可以避免自定义装饰器修改函数的__name__属性
        '''
        @functools.wraps(f)	# 注意是作用在【装饰器】的【内层函数】
        def warpper(*args, **kwargs):
            for _ in range(n):
                f(*args, **kwargs)
        return warpper
    return decorator

@repeat(3)
def func():
	pass
print(func.__name__)

运行结果

func

装饰器的应用

下面是几个常用装饰器的场景

• 打印日志
• 性能测试
• 权限校验
• 缓存
• 事务处理

小结

装饰器本质上是一个参数和返回值都是函数的函数。利用装饰器可以增强原有方法的功能，但要在一些场合下要注意装饰器的副作用，可以自定义装饰器内使用标准库里的@functools.wraps(f)装饰器来消除副作用。