笔记-python-装饰器

1. 装饰器

装饰器的实质是返回的函数对象的函数，其次返回的函数对象是可以调用的，搞清楚这两点后，装饰器是很容易理解的。

1.1. 相关概念理解

首先，要理解在Python中，函数也是一种对象

def foo(x):

print(x)

print(type(foo))

>>><class 'function'>

查看函数拥有的方法：

dir(foo)

>>>

['__call__',

'__class__',

'__closure__',

'__code__',

'__defaults__',

'__delattr__',

……]

因为函数是对象，所以函数可以作为参数传入另一个函数：

def bar(f, x):

x += 1

f(x)

bar(foo, 4) 5

1.2. 返回函数的函数

修饰函数是这样的一种函数，它接受一个函数作为输入，通常输出也是一个函数：

示例：

def loud(f):

def new_func(*args, **kw):

print('calling with', args, kw)

rtn = f(*args, **kw)

print('return value is', rtn)

return rtn

return new_func

loudlen = loud(len)

lisa = [10,20,30]

loudlen(lisa)

>>> loudlen

>>> len

<built-in function len>

解释：

在python中变量其实都是指针，对象、包括函数也是，可以相互赋值，下面也是合法的语句，在这个基础上理解容易得多；

loudlen1 = loudlen

loudlen1([10,20,30])

1.3. 使用 @

@是一个语法糖，与其说是修饰函数倒不如说是引用、调用它修饰的函数。

下面的一段代码，里面两个函数，没有被调用，也会有输出结果：

# 原理

def test(f):

print("before ...")

f()

print("after ...")

@test

def func():

print("func was called" )

直接运行，输出结果：

before ...

func was called

after ...

上面代码只定义了两个函数： test和func。没有地方调用它们。如果没有“@test”，运行应该是没有任何输出的。

但是，Python解释器读到函数修饰符“@”的时候，后面步骤会是这样了：

1. 去调用 test函数，test函数的入口参数就是那个叫“func”的函数；

2. test函数被执行，入口参数的（也就是func函数）会被调用（执行）；

换言之，修饰符带的那个函数的入口参数，就是下面的那个整个的函数。

再来看一个例子：

def test(func):

func()

print("call test")

def test1(f):

f()

print( "call test1")

def main():

@test

def fun():

print("call fun")

@test1

def fun1():

print( "call fun1")

main()

输出结果：

call fun

call fun1

call test1

call test

仔细体会调用顺序。

需要注意的：

1. 函数先定义，再修饰它；反之会编译器不认识；

2. 修饰符“@”后面必须是之前定义的某一个函数；

1.4. 多重装饰

def first(func):

print('%s() was post to first()'%func.__name__)

def _first(*args,**kwargs):

print('call the function %s() in _first().'%func.__name__)

return func(*args, **kwargs)

return _first

def second(func):

print('%s() was post second()'%func.__name__)

def _second(*args, **kwargs):

print('call the function %s() in _second.'%func.__name__)

return func(*args, **kwargs)

return _second

@first

@second

def test():

return 'hello'

输出：

test() was post second()

_second() was post to first()

>>> test()

call the function _second() in _first().

call the function test() in _second.

'hello'

>>> test

<function first.<locals>._first at 0x000000A71BCBE488>

有意思的是在视觉效果上装饰器解释时是由内向外的，而执行时是由外至内的。

上面的代码实质上相当于下面的代码：

>>> def test():

return 'hello world'

>>> test=second(test)

test() was post to second()

>>> test

>>> test=first(test)

_second() was post to first()

>>> test

>>> test()

Call the function _second() in _first().

Call the function test() in _second().

'hello world'

1.5. 带参数的装饰器

上面都是无参数装饰，下面是一个有参数装饰的例子：

# 装饰器带参数

def log(text):

def decorator(func):

def wrapper(*args,**kw):

print("%s %s():" %(text, func.__name__))

print(args,kw)

return func(*args, **kw)

return wrapper

return decorator

@log("execute")

def now(*args,**kwargs):

print("time.ctime()")

now(1,2,3)

输出：

execute now():

(1, 2, 3) {}

time.ctime()

上面的@log(“execute“)等价于

now = log(“execute”)(now)

>>> now

<function log.<locals>.decorator.<locals>.wrapper at 0x000000B1AA97E400>

2. 附录：

面向切面编程AOP (Aspect Oriented Programming):

AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。