由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
```python
#!/usr/bin/env

# 自定义一个函数
def now():
    print('2018-12-10')

f = now
f()
```

函数对象有一个`__name__`属性，可以拿到函数的名字：
```python
#!/usr/bin/env

# 自定义一个函数
def now():
    print('2018-12-10')

f = now
f()

# 用函数名称直接获取，不过这种没什么用
print(now.__name__)
# 用变量函数名获取
print(f.__name__)
```
现在，假设我们要增强`now()`函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改`now()`函数的定义，
这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

本质上，`decorator`就是一个返回函数的高阶函数。
所以，我们要定义一个能打印日志的`decorator`，可以定义如下：
```python
#!/usr/bin/env

# 定义一个前置函数，func代表原始函数对象
def log(func):
    # 前置处理函数
    def wrapper():
        print('原始函数名称：',func.__name__)
        # 返回原始函数
        return func()
    return wrapper

# 自定义一个函数，使用log装饰器
@log
def now():
    print('2018-12-10')

f = now
f()
```
观察上面的`log()`函数，因为它是一个`decorator`，所以接受一个函数作为参数，并返回一个函数。
我们要借助Python的`@`语法，把`decorator`置于函数的定义处。
把`@log`放到`now()`函数的定义处，相当于执行了语句：
```python
#!/usr/bin/env

# 定义一个前置函数，func代表原始函数对象
def log(func):
    # 前置处理函数
    def wrapper():
        print('原始函数名称：',func.__name__)
        # 返回原始函数
        return func()
    return wrapper

# 自定义一个函数
def now():
    print('2018-12-10')

# 使用log装饰器
f = log(now)
f()
```
由于`log()`是一个`decorator`，返回一个函数，所以，原来的`now()`函数仍然存在，只是现在同名的`now`变量指向了新的函数，于是调用`now()`将执行新函数，即在`log()`函数中返回的`wrapper()`函数。
下面我们来研究下，`wrapper()`函数应该怎么接收原始函数中传递的参数：
```python
#!/usr/bin/env

# 定义一个前置函数，func代表原始函数对象
def log(func):
    # 前置处理函数
    def wrapper(*args, **kw):
        # 接收*的参数
        print(args[0])
        # 接收**的参数
        print(kw)
        print('原始函数名称：',func.__name__)
        # 返回原始函数
        return func(*args, **kw)
    return wrapper

# 自定义一个函数
def now(num1, num2, **kw):
    print(num1, num2, **kw)

# 使用log装饰器
f = log(now)
f(1, 2, a=1, b=2, c=3)
```
从上面的代码中我们可以看出，`decorator`接收原始函数中传递的参数，需要定义两个变量`*args`和`**kw`。
`*args`用于接收可变长度的普通变量传参。
`**kw`用于接收可变长度的元组变量传参。

如果`decorator`本身需要传入参数，那就需要编写一个返回`decorator`的高阶函数，写出来会更复杂。比如，要自定义`log`的文本：
```python
#!/usr/bin/env

# 定义一个前置函数，func代表原始函数对象
def log(text):
    # 前置处理函数-1
    def decorator(func):
        # 前置处理函数-2
        def wrapper(*args, **kw):
            # 接收*的参数
            print(args)
            # 接收**的参数
            print(kw)
            print('%s , %s():' % (text, func.__name__))
            # 返回原始函数
            return func(*args, **kw)
        return wrapper
    return decorator

# 自定义一个函数
@log('execute')
def now():
    print('2018-12-10')

f = now
f()
```
从上面的代码我们可以看出，三层以上嵌套的用法，`log`已经是可以传递参数的了，在函数体前的引用方式也是跟二层时差不多。
不过和两层嵌套的`decorator`相比，在函数体赋值给变量时，三层嵌套的写法应该是这样的：
```python
#!/usr/bin/env

# 定义一个前置函数，func代表原始函数对象
def log(text):
    # 前置处理函数-1
    def decorator(func):
        # 前置处理函数-2
        def wrapper(*args, **kw):
            # 接收*的参数
            print(args)
            # 接收**的参数
            print(kw)
            print('%s , %s():' % (text, func.__name__))
            # 返回原始函数
            return func(*args, **kw)
        return wrapper
    return decorator

# 自定义一个函数
def now():
    print('2018-12-10')

# 使用log装饰器
f = log('execute')(now)
f()
```
我们来剖析上面的语句，首先执行`log('execute')`，返回的是`decorator`函数，再调用返回的函数，参数是`now()`函数，返回值最终是`wrapper()`函数。

以上两种`decorator`的定义都没有问题，但还差最后一步。
因为我们讲了函数也是对象，它有`__name__`等属性，但你去看经过`decorator`装饰之后的函数，它们的`__name__`已经从原来的'`now`'变成了'`wrapper`'：
```python
# 程序末尾加入这句
print(f.__name__)
# wrapper
```
因为返回的那个`wrapper()`函数名字就是'`wrapper`'，所以，需要把原始函数的`__name__`等属性复制到`wrapper()`函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写`wrapper.__name__ = func.__name__`这样的代码，Python内置的`functools.wraps`就是干这个事的，所以，一个完整的`decorator`的写法如下：
```python
#!/usr/bin/env
import functools

# 定义一个前置函数，func代表原始函数对象
def log(text):
    # 前置处理函数-1
    def decorator(func):
        # 改变__name__的赋值
        @functools.wraps(func)

# 前置处理函数-2
        def wrapper(*args, **kw):
            # 接收*的参数
            print(args)
            # 接收**的参数
            print(kw)
            print('%s , %s():' % (text, func.__name__))
            # 返回原始函数
            return func(*args, **kw)
        return wrapper
    return decorator

# 自定义一个函数
def now():
    print('2018-12-10')

# 使用log装饰器
f = log('execute')(now)
f()

# 打印__name__对象信息
print(f.__name__)
```
`import functools`是导入`functools`模块。
模块的概念稍候讲解。
现在，只需记住在定义`wrapper()`的前面加上`@ functools.wraps(func)`(这里有个空格，自行忽略)即可。

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺