Python装饰器

很多写装饰器的都是直接甩给你最终的装饰器代码,然后给你说下大致的原理,比如:

#现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
#观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：
@log
def now():
    print('hello world')
#调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：    
>>> now()
call now():
hello world

然后来上一句,把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

对装饰器只是大致的解释了下原理,但是对于初学者根本就是懵逼的状态

我认为任何事都是一个复杂的组合体,就跟数学一样,一个复杂的题是有很多简单的题组成的,化繁为简就可以很清晰的理解事情的本质

下面让我们把装饰器拆分来看

1.函数/函数执行

首先区分函数和函数的执行

def foo():
    print('foo')

foo     #表示是函数
foo()   #表示执行foo函数

2.函数指针

def foo():
    print('foo')

foo = lambda x: x + 1

foo()# 执行下面的lambda表达式，而不再是原来的foo函数，因为foo这个名字被重新指向了另外一个匿名函数

3.最减版装饰器

def w1(func):
    def inner():
        func()
    return inner

@w1
def f1():
    print('f1')

这段代码不清楚没关系,让我们转成另外一段,因为@w1 等价于 w1(f1)

def w1(func):
    def inner():
        func()
    return inner

def f1():
    print('f1')

f1 = w1(f1)

如果你还是不清楚,那让我们来一步步解释下

执行w1函数 ，并将 f1 作为w1函数的参数，内部就会回返inner(由1.函数/函数执行应该知道这是函数),即将w1的返回值再重新赋值给 f1,即:

新f1 = def inner(): 
            想要添加的方法内容
            原来f1()
        return inner

当执行f1时,就会调用inner函数,先执行你想要添加的方法内容,然后再执行原有的f1方法

再看下最减版的装饰器了,看看理解了吗.

4.用装饰器给方法添加点内容

def addStr(fn):
    def wrapped():
        return '添加的内容:' + fn()
    return wrapped

@addStr
def test1()
    return 'hello world'

print(test1())

运行结果:

添加内容:hello world

5.装饰器(decorator)功能

• 引入日志
• 函数执行时间统计
• 执行函数前预备处理
• 执行函数后清理功能
• 权限校验等场景
• 缓存

6.装饰有参数的函数

上边是装饰无参数的函数,下边让我们看下装饰有参数的函数

def test(func):
    def wrappedfunc(a, b):
        print(a, b)
        func(a, b)
    return wrappedfunc

@test
def foo(a, b):
    print(a+b)
foo(1,2)

7.装饰不定长参数的函数

def test(func):
    def wrappedfunc(*args, **kwargs):
        print(args, kwargs)
        func(*args, **kwargs)
    return wrappedfunc

@test
def foo1(a, b):
    print(a+b)
@test
def foo2(a, b, c):
    print(a+b+c)

foo1(1,2)
foo2(1,2,3)

对于不定长参数的函数参数可以通过(*args, **kwargs)来修饰,*args代表tuple(元组),**kwargs代表dict(字典),这样装饰器就可以修饰不同参数长度的函数

8.装饰带有return的函数

def test(func):
    def wrappedfunc():
        return func()
    return wrappedfunc

@test
def foo1():
    return 'haha'
@test
def foo2():
    print('----foo2----')

foo2()
print(foo1())

运行可以知道两个函数都可以正常运行,因为foo2没有return的,在wrappedfunc中return的是None,不会影响函数的正常执行,而foo1中有return的也可以通过wrappedfunc中的return返回回来.

9.通用装饰器

这里就回到了开头大家普遍看到的通用装饰器

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def now():
    print('hello world')

这时候看这个装饰器,是不是感觉明白多了func.name就是打印函数名的一个方法

10.装饰器带参数,在原有装饰器的基础上，设置外部变量

def test(pre="hello"):
    def testfun(func):
        def wrappedfunc():
            print(pre)
            return func()
        return wrappedfunc
    return testfun

@test("python")
def foo():
    print("I am foo")

可以理解为:foo()=test(“python”)(foo)()

11.类装饰器

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 call() 方法，那么这个对象就是callable的。

class Test(object):
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s"%func.__name__)
        self.__func = func
    def __call__(self):
        print("---装饰器中的功能---")
        self.__func()
#说明：
#1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象
#    并且会把test这个函数名当做参数传递到__init__方法中
#    即在__init__方法中的func变量指向了test函数体
#
#2. test函数相当于指向了用Test创建出来的实例对象
#
#3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法
#
#4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用
#    所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体
@Test
def test():
    print("----test---")
test()
showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"

运行结果如下

—初始化—
func name is test
—装饰器中的功能—
—-test—