闭包（closures）与python装饰器（Decorator）

1、闭包 （function closures）

引用自有变量的函数，简单来说就是在自己函数内定义的变量，通过嵌套函数引用它间接意义上扩大它的作用域，使其影响到函数以外的区域。

talk is cheap，show me the code

def print_msg():
    msg = "I'm closure"

    # printer是嵌套函数
    def printer():
        print(msg)

    return printer


# 这里获得的就是一个闭包
closure = print_msg()
closure()
# 输出 I'm closure

 2、python装饰器（Decorator）：

@functools.wraps(func) python装饰器，拷贝原函数元信息 包括 docstring（文档字符串，函数中用于解释程序的文字）、name（函数名称）、和参数列表（原函数的参数）。

函数里面的嵌套函数加装饰器相当于把log(test)赋值给嵌套函数wrapper

import functools


def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        print('args = {}'.format(*args))
        return func(*args, **kwargs)

    return wrapper


@log
def test(p):
    print(test.__name__ + " param: " + p)
    
test("I'm a param")

输出：
call test():
args = I'm a param
test param: I'm a param

 装饰器，是将加了@函数名称 下的函数整体作为 装饰器函数的参数，如上面的func就是相当于test函数类似于函数调用：

def test(p):
    print(test.__name__ + " param: " + p)

wrapper = log(test)
wrapper("I'm a param")

带参数的装饰器

装饰器允许传入参数，一个携带了参数的装饰器将有三层函数，如下所示：

 

import functools

def log_with_param(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('call %s():' % func.__name__)
            print('args = {}'.format(*args))
            print('log_param = {}'.format(text))
            return func(*args, **kwargs)

        return wrapper

    return decorator
    
@log_with_param("param")
def test_with_param(p):
    print(test_with_param.__name__)


test_with_param("I'm a param")

看到这个代码是不是又有些疑问，内层的decorator函数的参数func是怎么传进去的？和上面一般的装饰器不大一样啊。

其实道理是一样的，将其@语法去除，恢复函数调用的形式一看就明白了：

 

# 传入装饰器的参数，并接收返回的decorator函数
decorator = log_with_param("param")
# 传入test_with_param函数
wrapper = decorator(test_with_param)
# 调用装饰器函数
wrapper("I'm a param")

输出结果与正常使用装饰器相同：

 

call test_with_param():
args = I'm a param
log_param = param
test_with_param

至此，装饰器这个有点费解的特性也没什么神秘了。

Python中函数是第一公民，函数是对象、是变量，可以作为参数、可以是返回值，非常的灵活与强大。