Python之闭包&装饰器

1. 闭包

1.1 闭包的定义

我们都知道当一个函数调用完，函数内定义的变量都销毁了，但是我们有时候需要保存函数内的这个变量，每次在这个变量的基础上完成一些列的操作，比如: 每次在这个变量的基础上和其它数字进行求和计算，那怎么办呢?

闭包的定义:
在函数嵌套的前提下，内部函数使用了外部函数的变量，并且在外部函数中返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。

闭包的构成条件
通过闭包的定义，我们可以得知闭包的形成条件:

1. 在函数嵌套(函数里面再定义函数)的前提下
2. 内部函数使用了外部函数的变量(还包括外部函数的参数)
3. 外部函数返回了内部函数

1.2 简单的示例代码

# 1. 定义外部函数
def func(num):

    # 2. 定义内部函数
    def inner(inner_num):
        # 3. 内部函数逻辑代码...
        print(num + inner_num)

    # 3. 外部函数返回内部函数类
    return inner


if __name__ == '__main__':
    f = func(1)
    print(type(f))  # <class 'function'>
    f(1)  # 2
    f(2)  # 3

1.3 闭包的使用

需求: 根据配置信息使用闭包实现不同人的对话信息，例如对话:
Tom: How are you? Jerry:I`m fine , Thanks。

def person(name):
    def say(words):
        print(f'{name} say: {words}')
        
    return say

tom = person('Tom')
tom('How are you ? Jerry.')

jerry = person('Jerry')
jerry('I`m fine. Thanks')

# 结果
# Tom say: How are you ? Jerry.
# Jerry say: I`m fine. Thanks

1.4 对闭包内的外部变量的修改

如果在闭包的内部函数内直接使用 p=10 这种修改方式，相当于新建了一个临时变量，并不是修改的外部变量。正确的使用方法是在需要改变外部变量前声明这是外部变量：nonlocal p

def person(name):

    def say(words):
        print('I changed my name.My name is Jack,now!')
        nonlocal name  # 申明name是外部变量
        name = 'Jack'
        print(f'{name} say: {words}')
    return say

2. 装饰器

2.1 装饰器的定义

给已有函数增加额外功能的函数，它本质上就是一个闭包函数。

装饰器的功能特点:

1. 不修改已有函数的源代码
2. 不修改已有函数的调用方式
3. 给已有函数增加额外的功能

2.2 示例代码

def decorator(fn):
    def inner():
        print('执行前的一些装饰代码...')
        fn()  # 执行被装饰的方法
        print('执行后的一些装饰代码...')
    return inner


def fn():
    print('这里是fn方法执行了...')

# 装饰
f = decorator(fn)
f()

# 结果：
# 执行前的一些装饰代码...
# 这里是fn方法执行了...
# 执行后的一些装饰代码...

注意： 闭包函数有且只有一个参数，必须是函数类型，这样定义的函数才是装饰器。

2.3 装饰器语法糖

如果有多个函数都需要添加登录验证的功能，每次都需要编写func = decorator(func)这样代码对已有函数进行装饰，这种做法还是比较麻烦。

Python给提供了一个装饰函数更加简单的写法，那就是语法糖，语法糖的书写格式是:
@装饰器名字，通过语法糖的方式也可以完成对已有函数的装饰

示例代码

def decorator(fn):
    def inner():
        print('执行前的一些装饰代码...')
        fn()  # 执行被装饰的方法
        print('执行后的一些装饰代码...')
    return inner

# 装饰
@decorator
def fn():
    print('这里是fn方法执行了...')

fn()

# 结果:
# 执行前的一些装饰代码...
# 这里是fn方法执行了...
# 执行后的一些装饰代码...

2.4 装饰器的基本使用

装饰带参数的函数：

def logging(fn):
    def inner(p1, p2):
        print('正在计算')
        fn(p1, p2)
        print('计算完毕')
    return inner

@logging
def sum_num(a, b):
    rtn = a + b
    print(rtn)

sum_num(1, 2)  # 3

装饰带返回值的函数

# 不确定有几个参数也可以用 *args 代替
def logging(fn):
    def inner(*args):
        print(f'正在计算{fn.__name__}{args}')
        rtn = fn(*args)
        print(f'计算完毕:{fn.__name__}{args}={rtn}')
        return rtn
    return inner

@logging
def sum_num(a, b):
    return a + b

rtn = sum_num(1, 2)
print(rtn)

# 结果
# 正在计算sum_num(1, 2)
# 计算完毕:sum_num(1, 2)=3
# 3

装饰有不定长参数的函数

def logging(fn):
    def inner(*args, **kwargs):
        print(f'正在计算{fn.__name__}{args, kwargs}')
        rtn = fn(*args, **kwargs)
        print(f'计算完毕:{fn.__name__}{args , kwargs}={rtn}')
        return rtn
    return inner

@logging
def sum_num(*args, **kwargs):
    rtn = 0
    for i in args:
        rtn += i
    
    for i in kwargs.values():
        rtn += i
    
    return rtn

rtn = sum_num(1, 2, a=3)
print(rtn)

# 结果
# 正在计算sum_num((1, 2), dict_values([3]))
# 计算完毕:sum_num((1, 2), dict_values([3]))=6
# 6

通用装饰器

def decorator(fn):
    def inner(*args, **kwargs):
        print('执行前的一些装饰内容')
        rtn = fn(*args, **kwargs)
        print('执行后的一些装饰内容')
        return rtn
    return inner

2.5 多个装饰器时的装饰顺序

def make_div(func):

    def inner(*args, **kwargs):
        print('加div标签')
        return f'<div>{func(*args, **kwargs)}</div>'
    return inner


def make_p(func):
    def inner(*args, **kwargs):
        print('加p标签')
        return f'<p>{func(*args, **kwargs)}</p>'

    return inner


@make_p
@make_div
def content(msg):
    return msg

print(content('Hello Python!'))

# 加p标签
# 加div标签
# <p><div>Hello Python!</div></p>  注意结果，是div先装饰，再是p
# 前面是装饰器的加载顺序，这个在官方文档里面并没有说明

2.6 装饰器带有参数

装饰器只能接收一个参数，并且还是函数类型。

若存在如下需求

def logging(fn, operator):
    def inner(*args, **kwargs):
        print(f'正在进行{operator}计算')
        rtn = fn(*args, **kwargs)
        print(f'{operator}计算完毕，结果为{rtn}')
        return rtn

    return inner


@logging('+')
def sum_num(a, b):
    return a + b


rtn = sum_num(1, 2)
print(rtn)

Traceback (most recent call last):
  File "F:\Python-Workspace\start\close_pk\simple.py", line 11, in <module>
    @logging('+')
TypeError: logging() missing 1 required positional argument: 'operator'

解决方案：

装饰器的调用方式为@装饰器类，而装饰器不能直接传参数(默认会传一个被装饰的函数)
所以我们需要保证@后跟一个装饰器就可以了
由此我们可以在装饰器外面再包裹上一个函数，让最外面的函数接收参数，其结果返回的是装饰器，因为@符号后面必须是装饰器实例。

def logging(operator):
    def decorator(fn):
        def inner(*args, **kwargs):
            print(f'正在进行{operator}计算')
            rtn = fn(*args, **kwargs)
            print(f'{operator}计算完毕，结果为{rtn}')
            return rtn

        return inner
    return decorator  # 返回了一个装饰器

# 正常的装饰方式为 @logging  
# 所以只要保证@后面是一个装饰器类就可以了
# 所以使用@logging('+')相当于调用了logging('+')方法，返回了一个装饰器
@logging('+')  
def sum_num(a, b):
    return a + b


rtn = sum_num(1, 2)
print(rtn)

2.7 类装饰器

class logger:

    def __init__(self, func):
        # 类的初始化方法
        self.__func = func

    def __call__(self, *args, **kwargs):
        """call 方法表示这个类可以象函数一样调用"""
        print('方法被执行前的一些装饰...')
        rtn = self.__func(*args, **kwargs)
        print('方法被执行后的一些装饰')
        return rtn


@logger
def sum_num(a, b):
    return a + b

print(sum_num(1,3))

@logger 相当于创建了一个logger类，所以需要在logger类实现__init__()方法，init__后这个类就相当于是一个装饰器了。而想要让logger类能象函数一样调用，则需要再实现__call()方法，call方法就相当于闭包的内部函数。

2.8 带参数的装饰器类

与函数式相似，@后需要跟一个装饰器。因为我们可以将闭包最外层的函数类比为装饰器类的__init__方法，内部函数类比为__call__方法。
所以要想实现需求，那么需要在__call__方法内再加一个内部函数，这个内部函数代替了call成为真正的装饰函数，所以__call__也需要返回这个内部函数，这时__call__就相当于闭包装饰器带参数的情况下，加的那一层函数。

class logger:

    def __init__(self, operator):
        # 类的初始化方法
        self.__operator = operator

    def __call__(self, func):
        """call 方法表示这个类可以象函数一样调用"""
        def wrapper(*args, **kwargs):
            print(f'执行{self.__operator}操作')
            rtn = func(*args, **kwargs)
            print(f'执行完毕，结果={rtn}')
            return rtn
        return wrapper


@logger('+')
def sum_num(a, b):
    return a + b

print(sum_num(1,3))