python装饰器@property

Posted 2020-11-04 啸傲风月

装饰器示例

def w1(func):
    def inner():
        print(‘...验证权限...‘)
        func()

    return inner


@w1
def f1():
    print(‘f1 called‘)


@w1
def f2():
    print(‘f2 called‘)


f1()
f2()

输出结果：

...验证权限...
f1 called
...验证权限...
f2 called

当调用f1，f2函数时，首先执行了验证。通过一个闭包函数w1，调用函数上通过关键词@w1，对f1，f2完成了装饰。

当python解释器解释@w1时，会调用w1函数，同时将被修饰函数名传入（例如f1），在执行w1函数的时候，直接把inner函数返回了，同事把它赋值给f1，此时的f1已经不是未加修饰的f1了，而是指向了w1.inner函数地址。再调用f1函数，就好先执行权限验证，然后调用原来的f1()，该处的f1是通过参数传进来的f1.

执行时机

def w1(fun):
    print(‘...装饰器开始装饰...‘)

    def inner():
        print(‘...验证权限...‘)
        fun()

    return inner


@w1
def test():
    print(‘test‘)

test()

输出结果：

...装饰器开始装饰...
...验证权限...
test

由此可见，执行@w1时相当于执行了如下代码：

test = w1(test)

两个装饰器执行流程和修饰结果

def makeBold(fun):
    print(‘----a----‘)

    def inner():
        print(‘----1----‘)
        return ‘<b>‘ + fun() + ‘</b>‘

    return inner


def makeItalic(fun):
    print(‘----b----‘)

    def inner():
        print(‘----2----‘)
        return ‘<i>‘ + fun() + ‘</i>‘

    return inner


@makeBold
@makeItalic
def test():
    print(‘----c----‘)
    print(‘----3----‘)
    return ‘hello python decorator‘


ret = test()
print(ret)

输出结果：

----b----
----a----
----1----
----2----
----c----
----3----
<b><i>hello python decorator</i></b>

可以发现，先用第二个装饰器(makeItalic)进行装饰，接着再用第一个装饰器(makeBold)进行装饰，而在调用过程中，先执行第一个装饰器(makeBold)，接着再执行第二个装饰器(makeItalic)。

对有参数函数进行装饰

def w_say(fun):
    """
    如果原函数有参数，那闭包函数必须保持参数个数一致，并且将参数传递给原方法
    """

    def inner(name):
        """
        如果被装饰的函数有行参，那么闭包函数必须有参数
        :param name:
        :return:
        """
        print(‘say inner called‘)
        fun(name)

    return inner


@w_say
def hello(name):
    print(‘hello ‘ + name)


hello(‘wangcai‘)

输出结果：

say inner called
hello wangcai

多个参数或不定个参数

def w_add(func):
    def inner(*args, **kwargs):
        print(‘add inner called‘)
        func(*args, **kwargs)

    return inner


@w_add
def add(a, b):
    print(‘%d + %d = %d‘ % (a, b, a + b))


@w_add
def add2(a, b, c):
    print(‘%d + %d + %d = %d‘ % (a, b, c, a + b + c))


add(2, 4)
add2(2, 4, 6)

输出结果：

add inner called
2 + 4 = 6
add inner called
2 + 4 + 6 = 12

对带返回值的函数进行修饰

def w_test(func):
    def inner():
        print(‘w_test inner called start‘)
        func()
        print(‘w_test inner called end‘)
    return inner


@w_test
def test():
    print(‘this is test fun‘)
    return ‘hello‘


ret = test()
print(‘ret value is %s‘ % ret)

输出结果：

w_test inner called start
this is test fun
w_test inner called end
ret value is None

可以发现，此时，并没有输出test函数的‘hello’,而是None，那是为什么呢，可以发现，在inner函数中对test进行了调用，但是没有接受不了返回值，也没有进行返回，那么默认就是None了，知道了原因，那么来修改一下代码：

def w_test(func):
    def inner():
        print(‘w_test inner called start‘)
        str = func()
        print(‘w_test inner called end‘)
        return str

    return inner


@w_test
def test():
    print(‘this is test fun‘)
    return ‘hello‘


ret = test()
print(‘ret value is %s‘ % ret)

输出结果：

w_test inner called start
this is test fun
w_test inner called end
ret value is hello

带参数的装饰器

def func_args(pre=‘xiaoqiang‘):
    def w_test_log(func):
        def inner():
            print(‘...记录日志...visitor is %s‘ % pre)
            func()

        return inner

    return w_test_log


# 带有参数的装饰器能够起到在运行时，有不同的功能

# 先执行func_args(‘wangcai‘)，返回w_test_log函数的引用
# @w_test_log
# 使用@w_test_log对test_log进行装饰
@func_args(‘wangcai‘)
def test_log():
    print(‘this is test log‘)


test_log()

输出结果：

...记录日志...visitor is wangcai
this is test log

通用装饰器

def w_test(func):
    def inner(*args, **kwargs):
        ret = func(*args, **kwargs)
        return ret

    return inner


@w_test
def test():
    print(‘test called‘)


@w_test
def test1():
    print(‘test1 called‘)
    return ‘python‘


@w_test
def test2(a):
    print(‘test2 called and value is %d ‘ % a)


test()
test1()
test2(9)

输出结果：

test called
test1 called
test2 called and value is 9 

类装饰器

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

当创建一个对象后，直接去执行这个对象，那么是会抛出异常的，因为他不是callable，无法直接执行，但进行修改后，就可以直接执行调用了，如下

class Test(object):
    def __call__(self, *args, **kwargs):
        print(‘call called‘)


t = Test()
print(t())

下面，引入正题，看一下如何用类装饰函数。

class Test(object):
    def __init__(self, func):
        print(‘test init‘)
        print(‘func name is %s ‘ % func.__name__)
        self.__func = func

    def __call__(self, *args, **kwargs):
        print(‘装饰器中的功能‘)
        self.__func()


@Test
def test():
    print(‘this is test func‘)


test()

输出结果：

test init
func name is test 
装饰器中的功能
this is test func

和之前的原理一样，当python解释器执行到到@Test时，会把当前test函数作为参数传入Test对象，调用init方法，同时将test函数指向创建的Test对象，那么在接下来执行test()的时候，其实就是直接对创建的对象进行调用，执行其call方法。