标签：inner 创建 关键词 ble python 地址 不同的 wan 引入
装饰器示例
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方法。
标签：inner 创建 关键词 ble python 地址 不同的 wan 引入
原文地址：https://www.cnblogs.com/xiaoaofengyue/p/9025180.html
