前话:

python的修饰器可以说是python语言最有灵性的一个功能了，看到网上有各种乱乱的文章，所以想自己写得亲民一下，如有错误请指出。

正文：

@fnc & 被修饰函数无参数

首先看一组简单的代码：

#修饰器
def dec(fn):
    print("此处fn为函数",fn)
    return fn

@dec
#被修饰函数
def my_fn():
    return "函数返回值"

print(my_fn())
>>> 此处fn为函数 
>>> 函数返回值

以上的代码的修饰过程相当于my_fn => dec(my_fn)

@fnc & 被修饰函数有参数

接下来为被修饰函数加参数:

def dec(fn):
    print("此处fn为函数",fn)
    return fn

@dec
def my_fn(a):
    return "函数返回值为"+str(a)

print(my_fn('参数'))
>>> 此处fn为函数 
>>> 函数返回值为参数

此处依然为my_fn => dec(my_fn)

[小插曲]@fnc() & 被修饰函数无/有参数

在修饰器和被修饰函数都带参数前，先准备一个小插曲：

def dec_out():
    print('运行了dec_out')
    def dec_in (b):
        print("运行了dec_in")
        return b
    return dec_in

@dec_out()
def my_fn(a):
    return "函数返回值为"+str(a)

print(my_fn('my_fn参数'))
>>> 运行了dec_out
>>> 运行了dec_in
>>> 函数返回值为my_fn参数

看到这么多函数不要晕哦，我来解释一下：

首先运行my_fn函数时先进入了修饰器
遇到了dec_out时发现修饰器位置是一个被执行的函数(带着括号)，于是便执行了一下
修饰器就因为里面的return dec_in就等效成了@dec_out() => @dec_in
因此my_fn('my_fn参数')就等效成了dec_in(my_fn)('my_fn参数')

在这里休息一下，我来解答一下可能存在的疑惑：

Q:为什么上一个情况my_fn => dec(my_fn)，这次是dec_in(my_fn)('my_fn参数')

A:注意细节哦，上一个是my_fn，这次是my_fn('my_fn参数')

[正餐]@fnc(*arg) & 被修饰函数无/有参数

到了正餐了，有了上一个的铺垫，这次的也可以理解了

def dec_out(a):
    print("dec_out收到了",a)
    def dec_in (b):
        print("dec_in收到了",b)
        return b
    return dec_in

@dec_out("修饰器参数")
def my_fn(a):
    return "函数返回值为"+str(a)

print(my_fn('my_fn参数'))
>>> dec_out收到了 修饰器参数
>>> dec_in收到了 
>>> 函数返回值为my_fn参数

有没有预知到这次的结局呢？某种意义上很清楚明了了:

@dec_out("修饰器参数")在运行的因为return dec_in等效成了@dec_in，进而my_fn('my_fn参数')等效成了dec_in (my_fn)('my_fn参数')

这里我就不人肉DEBUG来给各位讲解了。

[加餐]多重@fnc(*arg) & 被修饰函数无/有参数

一下比较简单:

def dec_first(fn):
    print("dec_first运行了")
    return fn

def dec_second(fn):
    print("dec_second运行了")
    return fn

@dec_first
@dec_second
def my_fn():
    return "my_fn运行了"

print(my_fn())
>>> dec_second运行了
>>> dec_first运行了
>>> my_fn运行了

从以上可以看出修饰器的运行顺序是从临近被修饰函数开始的。但是不要认为解释器是直接从第二个修饰器开始解释的。

请看一下代码:

def dec_first_out(a):
    print("dec_first_out收到了",a)
    def dec_first_in(fn):
        print("dec_first_in运行了")
        return fn
    return dec_first_in

def dec_second(fn):
    print("dec_second运行了")
    return fn

@dec_first_out('第一个参数')
@dec_second
def my_fn():
    return "my_fn运行了"

print(my_fn())
>>> dec_first_out收到了 第一个参数
>>> dec_second运行了
>>> dec_first_in运行了
>>> my_fn运行了

由此可以看出，解释器看到了最上方的修饰器处于运行状态(有括号)于是运行，后再按上面咱们发现的行为运行。

[最后的晚餐]被修饰的修饰器

听起来复杂，实际还是这么回事:

def dec_dec(fn):
    print("dec_dec运行了")
    return fn
@dec_dec
def dec(fn):
    print("dec运行了")
    return fn

@dec
def my_fn():
    return "my_fn运行了"

print(my_fn())
>>> dec_dec运行了
>>> dec运行了
>>> my_fn运行了

看到这里应该已经清楚了吧，最有灵性的功能也是按部就班的执行的。

总结

总的来看，python的修饰器可以这么理解：

如果@后方不是一个函数名称，则运行到为一个函数名称为止，这种情况才会被解释成一个参数为被修饰函数的函数调用过程。（这么说是为了通俗明了，实际这么说欠妥）
多层的(闭包)函数作为修饰器要注意最终运行结果为一个函数名

Python修饰器

前话: