Python - 闭包和装饰器

一、闭包

1. 闭包的概念与使用

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

• 作用：可以保存外部函数内的变量，不会随着外部函数调用完而销毁

• 优点：提高代码的可重用性，不需要再手动定义额外的功能函数

• 缺点：由于闭包引用了外部函数的变量，则外部函数的变量没有及时释放，消耗内存

• 形成条件

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

# 外部函数
 def test1(a):
     b = 10
     # 内部函数
     def test2():
         # 内部函数使用了外部函数的变量或者参数
         print(a, b)
     # 返回内部函数, 这里返回的内部函数就是闭包实例
     return test2
# 定义一个外部函数
def func_out(num1):
    # 定义一个内部函数
    def func_inner(num2):
        # 内部函数使用了外部函数的变量(num1)
        result = num1 + num2
        print("结果是:", result)
    # 外部函数返回了内部函数，这里返回的内部函数就是闭包
    return func_inner

# 创建闭包实例    
f = func_out(1)
# 执行闭包
f(2)
f(3)

# 结果是: 3
# 结果是: 4
def func_out(name):
    def func_inner(info):
        print(name + ':'+ info)
    return func_inner

Zhangshan = func_out('张三')
Lisi = func_out('李四')
Zhangshan('到了吗？')
Zhangshan('Hello？？')
Lisi('还有5分钟！')

# 张三:到了吗？
# 张三:Hello？？
# 李四:还有5分钟！

2. 修改闭包内的外部变量

• 需要使用 nonlocal 关键字来完成

def func_out(name):
    def func_inner(info):
        # 告诉解释器，此处使用的是外部变量 name
        nonlocal name
        name = '黑客'
        print(name + ':'+ info)
    return func_inner

Zhangshan = func_out('张三')
Lisi = func_out('李四')
Zhangshan('到了吗？')
Zhangshan('Hello？？')
Lisi('还有5分钟！')

二、装饰器

1. 装饰器的定义

• 定义作用：给已有函数增加额外功能的函数（本质上就是一个闭包函数），有且只有一个参数，且必须是函数类型

• 执行时间：加载模块时立即执行

• 功能特点

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

# 装饰器
# def decorator(fn): # fn:被装饰的目标函数.
#     def inner():
#         '''执行函数之前'''
#         fn() # 执行被装饰的目标函数
#         '''执行函数之后'''
#     return inner
# 添加一个登录验证的功能
def check(fn):
    def inner():
        print("请先登录....")
        fn()
    return inner


def comment():
    print("发表评论")

# 使用装饰器来装饰函数
comment = check(comment)
comment()

# 请先登录....
# 发表评论

2. 装饰器的语法糖写法

语法糖的书写格式：@装饰器名字

# 添加一个登录验证的功能
def check(fn):
    print("装饰器函数执行了")
    def inner():
        print("请先登录....")
        fn()
    return inner

# 使用语法糖方式来装饰函数，@check 等价于 comment = check(comment)
@check
def comment():
    print("发表评论")

comment()

# 请先登录....
# 发表评论
import time

# 装饰器函数
def get_time(func):
    def inner():
        begin = time.time()
        func()
        end = time.time()
        print("函数执行花费%f" % (end-begin))
    return inner


@get_time
def func1():
    for i in range(100000):
        print(i)


func1()

# ...
# 99996
# 99997
# 99998
# 99999
# 函数执行花费0.235354

3. 各类函数的装饰器

（1）装饰带有参数的函数

# 添加输出日志的功能
def logging(fn):
    def inner(num1, num2):
        print("--正在努力计算--")
        fn(num1, num2)

    return inner


# 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    print(result)


sum_num(1, 2)

# --正在努力计算--
# 3

（2）装饰带有返回值的函数

# 添加输出日志的功能
def logging(fn):
    def inner(num1, num2):
        print("--正在努力计算--")
        result = fn(num1, num2)
        return result
    return inner


# 使用装饰器装饰函数
@logging
def sum_num(a, b):
    result = a + b
    return result


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

# --正在努力计算--
# 3

（3）装饰带有不定长参数的函数

# 添加输出日志的功能
def logging(fn):
    def inner(*args, **kwargs):
        print("--正在努力计算--")
        fn(*args, **kwargs)

    return inner


# 使用语法糖装饰函数
@logging
def sum_num(*args, **kwargs):
    result = 0
    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    print(result)

sum_num(1, 2, a=10)

# --正在努力计算--
# 13

（4）通用装饰器

# 通用装饰器
def logging(fn):
  def inner(*args, **kwargs):
      print("--正在努力计算--")
      result = fn(*args, **kwargs)
      return result

  return inner
# 添加输出日志的功能
def logging(fn):
    def inner(*args, **kwargs):
        print("--正在努力计算--")
        result = fn(*args, **kwargs)
        return result

    return inner


# 使用语法糖装饰函数
@logging
def sum_num(*args, **kwargs):
    result = 0
    for value in args:
        result += value

    for value in kwargs.values():
        result += value

    return result


@logging
def subtraction(a, b):
    result = a - b
    print(result)

result = sum_num(1, 2, a=10)
print(result)

subtraction(4, 2)

# --正在努力计算--
# 13
# --正在努力计算--
# 2

4. 多个装饰器的使用

• 装饰顺序：由内到外

def make_div(func):
    """对被装饰的函数的返回值 div标签"""
    def inner(*args, **kwargs):
        return "<div>" + func() + "</div>"
    return inner


def make_p(func):
    """对被装饰的函数的返回值 p标签"""
    def inner(*args, **kwargs):
        return "<p>" + func() + "</p>"
    return inner


# 装饰过程: 
# 1. content = make_p(content) 2. content = make_div(content)
# content = make_div(make_p(content))
@make_div
@make_p
def content():
    return "人生苦短"

result = content()

print(result)

#<div><p>人生苦短</p></div>

5. 带有参数的装饰器

• 添加参数方式：在装饰器外面再包裹上一个函数，让最外面的函数接收参数，返回的是装饰器，因为@符号后面必须是装饰器实例
• 传参格式：@装饰器(参数,...)

# 添加输出日志的功能
def logging(flag):

    def decorator(fn):
        def inner(num1, num2):
            if flag == "+":
                print("--正在努力加法计算--")
            elif flag == "-":
                print("--正在努力减法计算--")
            result = fn(num1, num2)
            return result
        return inner

    # 返回装饰器
    return decorator


# 返回装饰器装饰函数 add = decorator(add)
@logging("+")
def add(a, b):
    result = a + b
    return result

# 返回装饰器装饰函数 sub = decorator(sub)
@logging("-")
def sub(a, b):
    result = a - b
    return result

result = add(1, 2)
print(result)

result = sub(1, 2)
print(result)

# --正在努力加法计算--
# 3
# --正在努力减法计算--
# -1

6. 类装饰器的使用

• 类装饰器：装饰器的特殊用法，就是通过定义一个类来装饰函数
• __call__()：把类的实例变成可调用对象(callable)，也就是说可以像调用函数一样进行调用

class Check(object):
    def __init__(self, fn):
        # 初始化操作在此完成
        self.__fn = fn

    # 实现__call__方法，表示对象是一个可调用对象，可以像调用函数一样进行调用
    def __call__(self, *args, **kwargs):
        # 在call方法里进行对fn函数的装饰，可以添加额外的功能
        print("请先登陆...")
        self.__fn()

# @Check 等价于 comment = Check(comment)
@Check
def comment():
    print("发表评论")

# 调用类的实例
comment()