python装饰器学习总结

这是一篇迟到的总结。

以下是我的学习总结步骤：

• STEP1：

# test1 begin:
# 不是装饰器的装饰器
def deco1(func):
    print "before func() called:"
    func()
    print "after func() called."
    return func

@deco1
def run1():
    print "run1() called!"
    return
# test1 end;

"""
before func() called.
run1() called.
after func() called.
run1() called.
"""

执行完run1()方法后可以看到run1()函数被执行了两次，并不符合要求，所以我称之为不是装饰器的装饰器。严格意义上它也是个装饰器，哈哈。

• STEP2：

# test2 begin:
# 最简易的装饰器，在函数执行前后附加操作
def deco2(func):
    def _deco():
        print "before func() called:"
        print func()
        print "after func() called."
    return _deco


@deco2
def run2():
    print "run2() called!"
    return "OK"
# test2 end;

"""
before func() called:
run2() called!
OK
after func() called.
"""

这就是一个最简易的装饰器，它完成了装饰器应该完成的任务，但是它只能装饰不带参数的函数。

• STEP3：

# test3 begin:
# 对带固定参数的函数进行装饰
def deco3(func):
    def _deco(a, b):
        print "before func() called:"
        res = func(a, b)
        print "after func() called."
        return res
    return _deco


@deco3
def run3(a, b):
    print "run3(%s, %s) called!" % (a, b)
    return a + b
# test3 end;

"""
before func() called:
run3(1, 3) called!
after func() called.
4
"""

步骤三能够达到装饰带参数的函数的效果了，但是函数参数如果不一样呢？

• STEP4：

# test4 begin:
# 对带随机参数的函数进行装饰
def deco4(func):
    def _deco(*a, **b):
        print "before func() called:"
        res = func(*a, **b)
        print "after func() called."
        return res
    return _deco


@deco4
def run4_1(a, b):
    print "run4_1(%s, %s) called!" % (a, b)
    return a + b


@deco4
def run4_2(a, b, c):
    print "run4_2(%s, %s, %s) called!" % (a, b, c)
    return a + b + c['+'] - c['-']
# test4 end;

"""
before func() called:
run4_1(1, 2) called!
after func() called.
3
before func() called:
run4_2(3, 5, {'+': 2, '-': 10}) called!
after func() called.
0
"""

到这里，被装饰的函数的参数个数就是可以变化的了。

• STEP5：

# test5 begin:
# 让装饰器带参数
def deco5(arg):
    def _deco(func):
        def __deco(*a, **b):
            print "[%s]before %s called:" % (arg, func.__name__)
            res = func(*a, **b)
            print "[%s]after %s called." % (arg, func.__name__)
            return res
        return __deco
    return _deco


@deco5("test5_1")
def run5_1(a, b):
    print "run5_1(%s, %s) called!" % (a, b)
    return a + b


@deco5("test5_2")
def run5_2(a, b, c):
    print "run5_2(%s, %s, %s) called!" % (a, b, c)
    return a + b + c['+'] - c['-']
# test5 end;

"""
[test5_1]before run5_1 called:
run5_1(1, 2) called!
[test5_1]after run5_1 called.
3
[test5_2]before run5_2 called:
run5_2(3, 5, {'+': 2, '-': 10}) called!
[test5_2]after run5_2 called.
0
"""

为了让装饰器本身可以带参数，我们把装饰器的定义结构做了改变，可以看到是三层嵌套的，最外层的入参就是装饰器自己的参数，中间层的入参是被装饰的函数句柄，而最内层的函数入参就是被装饰的函数的入参了。

• STEP6：

# test6 begin:
# 让装饰器带类参数
def deco6(cls):
    def _deco(func):
        def __deco(*a, **b):
            print "before %s called:" % (func.__name__)
            cls.before()
            res = func(*a, **b)
            cls.after()
            print "after %s called." % (func.__name__)
            return res
        return __deco
    return _deco


class Deco6(object):
    def __init__(self):
        print "Deco6.__init__() called."

    @classmethod
    def before(cls):
        print "Deco6.before() called:"

    @classmethod
    def after(cls):
        print "Deco6.after() called;"


@deco6(Deco6)
def run6_1(a, b):
    print "run6_1(%s, %s) called!" % (a, b)
    return a + b


@deco6(Deco6)
def run6_2(a, b, c):
    print "run6_2(%s, %s, %s) called!" % (a, b, c)
    return a + b + c['+'] - c['-']
# test7 end;

"""
before run6_1 called:
Deco6.before() called:
run6_1(1, 2) called!
Deco6.after() called;
after run6_1 called.
3
before run6_2 called:
Deco6.before() called:
run6_2(3, 5, {'+': 2, '-': 10}) called!
Deco6.after() called;
after run6_2 called.
0
"""

至于带类参数，道理上是一样的，其实字符串参数本身就是类对象，类本身也是对象。

• STEP7：

# test7 begin:
# 让装饰器来装饰装饰器
@deco5("test7")
@deco6(Deco6)
def run7(a, b, c):
    print "run7_2(%s, %s, %s) called!" % (a, b, c)
    return a + b + c['+'] - c['-']
# test7 end;

"""
[test7]before __deco called:
before run7 called:
Deco6.before() called:
run7_2(8, 5, {'+': 2, '-': 10}) called!
Deco6.after() called;
after run7 called.
[test7]after __deco called.
5

（有双横线会变成粗体，所以上面这段输出我当做代码贴上来了。）这里主要测试一下装饰器的嵌套，至于效果，读者自行根据执行结果总结哈。

下面是我的执行过程，如果对上面输出结果的最后一行数字有疑惑，可以看看我下面的代码，有print的就会多出一行。

if __name__ == '__main__':
    # run1()
    # run2()
    # print run3(1, 3)
    # print run4_1(1, 2)
    # print run4_2(3, 5, {'-': 10, '+': 2})
    # print run5_1(1, 2)
    # print run5_2(3, 5, {'-': 10, '+': 2})
    # print run6_1(1, 2)
    # print run6_2(3, 5, {'-': 10, '+': 2})
    # print run7(8, 5, {'-': 10, '+': 2})