Python中的闭包装饰器和深浅拷贝案例演示

"""
闭包：
    概述：
        使用了外部函数变量的内部函数，称之为闭包。
    回顾：局部变量的生命周期？
        局部变量随着函数的调用而存在，随着函数的调用完毕而销毁，即：函数执行结束后，变量就被释放了。
    格式：
        def 外部函数名(形参列表):
            可以在这里定义 外部函数的 局部变量
            def 内部函数名(形参列表):
                在这里使用 外部函数的变量
            return 内部函数名
    闭包的三个前提条件：
        1：有嵌套，即：有外部函数，有内部函数。
        2：有引用，即：在内部函数中，有使用外部函数的引用。
        3：有返回，即：在外部函数中，返回内部函数（对象）
"""
# 需求1：回顾局部变量的作用域。
def method():
    number = 10
    return number
# 需求2：演示闭包，定义用于求和的闭包函数，外部函数有参数num1，内部函数有参数num2，内部函数返回num1+num2
def outer(num1):                        # 定义了外部函数outer
    def inner(num2):                    # 定义了内部函数inner
        sum = num1+num2                 # 使用了外部函数的变量num1
        print(f"求和的结果是：{sum}")
    return inner                        # 外部函数返回内部函数对象
if __name__ == '__main__':
    # 目前：函数每次调用都会生成一个新的number变量，函数调用结束后，number变量就会销毁。
    print(method())  # 10
    print(method()+1) # 11
    print(method()+1) # 11
    print(method()+1) # 11
    print(20* "-")
    """
        fn = outer(10) # fn是外部函数outer的返回值，即内部函数inner
        fn = def inner(num2):                       # 定义了内部函数inner
                sum = 10 + num2                     # 使用了外部函数的变量num1
                print(f"求和的结果是：{sum}")
    """
    fn = outer(10) # fn是外部函数outer的返回值，即内部函数inner
    """
    此时  fn = outer(10)
     = def outer(10)
        def inner(num2):                    
            sum = 10 + num2                 
            print(f"求和的结果是：{sum}")
    """
    """
        fn(1)
        inner(1):                            # 定义了内部函数inner
                sum = 10 + 1                 # 使用了外部函数的变量num1
                print(f"求和的结果是：{sum}")
    """
    fn(1)
    """
        fn(2)
        inner(2):                            # 定义了内部函数inner
                sum = 10 + 2                 # 使用了外部函数的变量num1
                print(f"求和的结果是：{sum}")
    """
    fn(2)

"""
nonlocal关键字的介绍：
    概述：
        是一个关键字，可以实现让内部函数去修改外部函数的变量值。
    回顾：
        global      声明变量    ->为全局变量
        nonlocal    声明变量    ->可以被内部函数修改
"""
# 需求：编写一个闭包，让内部函数去访问外部函数的变量，并修改她的值，观察结果
# 1：定义闭包代码，让内部函数去修改外部函数的变量值
def fn_outer(): # 声明外部函数
    x = 100
    def fn_inner(): # 声明内部函数
        # 核心，内部函数想修改外部函数的变量值，该变量值需要用到nonlocal关键字修饰
        nonlocal x
        x = x + 20  # 在内部函数中，去修改外部函数的变量值
        print(f"x的值为：{x}")
    return fn_inner
if __name__ == '__main__':
    fn = fn_outer()
    fn()
    fn()
    fn()

"""
装饰器的介绍：
    概述：
        装饰器=闭包函数，即：装饰器是闭包函数的一种写法。
    目的/作用：
        在不改变原有函数的基础上，对原有函数的功能做加强。
    前提条件：
        1：有嵌套
        2：有引用
        3：有返回
        4：有额外功能
    装饰器的用法：
        写法1：传统写法
            变量名 = 装饰器名(要被装饰的原函数名)
            变量名()       # 执行的就是，装饰后的原函数
        写法2：语法糖         语法糖 = 语法格式简化版
            在定义原函数的时候，加上@装饰器名即可，之后就能正确调用该原函数即可
"""
# 需求：发表评论前，需要先登录（模拟的操作）
# 1：定义装饰器（闭包函数），用于对指定函数功能做增强。
def login(fn_name):       #有外部函数
    # 定义内部函数，用于对指定的fn_name函数功能做增强。
    def inner():                #有内部函数
        print("登录中...登录成功....") #有额外功能
        fn_name()               #有引用
    return inner                #有返回
# # 写法1：传统写法
# def comment():
#     print("发表评论...")
# 写法2：语法糖
# comment()上面加一个@check_login修饰符的含义是：将comment函数名作为check_login函数的参数传递给check_login函数，并返回check_login函数的返回值
@login
def comment():
    print("发表评论...")
if __name__ == '__main__':
    # 2：调用装饰器，并传入要被装饰的函数名
    # 写法1：传统写法
    # comment = check_login(comment)
    # comment()
    # 写法2：语法糖, 在定义原函数的时候，加上@装饰器名即可，之后就能正确调用该原函数即可
    comment()
# 输出结果为
登录中...登录成功....
发表评论...

# 需求：定义无参无返回值的原函数：get_sum(), 用于计算两个变量的和
def print_info(fn_name):
    def inner():
        print("【友好提示】正在努力计算中...")
        fn_name()
    return inner
@print_info
def get_sum():
    a = 10
    b = 20
    sum = a +b
    print("两个变量的和为：%d" % sum)
if __name__ == '__main__':
    get_sum()
# 输出结果
【友好提示】正在努力计算中...
两个变量的和为：30

# 需求：定义有参无返回值的原函数：get_sum(), 用于计算两个变量的和
def print_info(fn_name):
    def inner(a, b):
        print("【友好提示】正在努力计算中...")
        fn_name(a, b)
    return inner
@print_info
def get_sum(a, b):
    sum = a + b
    print("两个变量的和为：%d" % sum)
if __name__ == '__main__':
    get_sum(10, 20)
#输出结果
【友好提示】正在努力计算中...
两个变量的和为：30

def print_info(fn_name):
    def inner():
        print("【友好提示】正在努力计算中...")
        return fn_name()
    return inner
@print_info
def get_sum():
    a = 10
    b = 20
    sum = a + b
    return sum
if __name__ == '__main__':
    sum = get_sum()
    print(sum)
# 输出结果
【友好提示】正在努力计算中...
30

# 需求：定义有参无返回值的原函数：get_sum(), 用于计算两个变量的和
def print_info(fn_name):
    def inner(a, b):
        print("【友好提示】正在努力计算中...")
        return fn_name(a, b)
    return inner
@print_info
def get_sum(a, b):
    sum = a + b
    return sum
if __name__ == '__main__':
    sum = get_sum(10, 30)
    print(sum)
# 输出结果
具体执行步骤：
    1:当使用 @print_info 装饰 get_sum 时，相当于执行了：getSum = print_info(get_sum)
    2:此时，print_info(get_sum) 返回的是 inner 函数。所以，getSum 现在实际上是 inner 函数。
    3:当调用 getSum(10, 30) 时，实际上调用的是 inner(10, 30)。
    4:在 inner 函数内部，先打印提示信息，然后调用原始的函数（即之前的 get_sum，被装饰前的函数）并传入参数，得到结果，然后返回。
【友好提示】正在努力计算中...
40

'''
通用装饰器：① 有嵌套 ② 有引用 ③ 有返回 ④ 有不定长参数 ⑤ 有return返回值
'''
def logging(fn):
    def inner(*args, **kwargs):
        # 输出装饰器功能
        print('-- 正在努力计算 --')
        # 调用fn函数
        return fn(*args, **kwargs)
    return inner
@logging
def sum_num1(a, b):
    result = a + b
    return result
print(sum_num1(20, 10))
@logging
def sum_num2(a, b, c):
    result = a + b + c
    return result
print(sum_num2(10, 20, 30))
# 输出结果
-- 正在努力计算 --
30
-- 正在努力计算 --
60

"""
多个装饰器装饰1个函数，细节如下：
    多个装饰器装饰1个函数，装饰的顺序是由最贴近函数的那个开始，自下而上（执行顺序）
"""
# 需求：发表评论之前，需要先登录、在进行验证码验证，在不改变原有函数的基础上，对功能进行增强
# 1: 定义装饰器。加入：登录的功能 登录-》验证码-》发表评论
def check_login(fn_name):       #有外部函数
    # 定义内部函数，用于对指定的fn_name函数功能做增强。
    def inner():                #有内部函数
        print("登录中...") #有额外功能
        fn_name()               #有引用
    return inner                #有返回
# 2: 定义装饰器。加入：验证码的功能
def check_code(fn_name):       #有外部函数
    # 定义内部函数，用于对指定的fn_name函数功能做增强。
    def inner():                #有内部函数
        print("验证码验证中...") #有额外功能
        fn_name()               #有引用
    return inner                #有返回
# 3：定义被装饰的函数【自上而下】，意思是最上面的先装饰，让后往下
@check_login
@check_code
def comment():
    print("发表评论...")
if __name__ == '__main__':
#     # 写法1：传统的写法【自下而上】
#     code = check_code(comment)
#     login = check_login(code)
#     login()
#
    print("-" * 50)
    # 写法2：语法糖
    comment()
# 输出结果
登录中...
验证码验证中...
发表评论...

"""
带有参数的装饰器：
    1个装饰器的参数只能有1个
"""
# 需求：定义一个装饰器减法运算，又能装饰加法运算的装饰器
def logging(flag):
    def print_info(fn_name):
        def inner(a, b):
            if flag == "+":
                print("【友好提示】正在努力 加法 计算中...")
            elif flag == "-":
                print("【友好提示】正在努力 减法 运算中...")
            fn_name(a, b)
        return inner
    return print_info
@logging("+")
def add(a, b):
    sum = a + b
    print(f"【加法运算】结果为：{sum}")
@logging("-")
def substract(a, b):
    sum = a - b
    print(f"【减法运算】结果为：{sum}")
if __name__ == '__main__':
    add(10, 20)
    substract(20, 10)
# 输出结果
【友好提示】正在努力 加法 计算中...
【加法运算】结果为：30
【友好提示】正在努力 减法 运算中...
【减法运算】结果为：10

a = "python"

import copy
a=[1,2,3]
print("=====赋值=====")
b=a
print(a)
print(b)
print(id(a))
print(id(b))
print("=====浅拷贝=====")
b=copy.copy(a)
print(a)
print(b)
print(id(a))
print(id(b))
print("=====深拷贝=====")
b=copy.deepcopy(a)
print(a)
print(b)
print(id(a))
print(id(b))
# 结果如下
"""
=====赋值=====
[1, 2, 3]
[1, 2, 3]
37235144
37235144
=====浅拷贝=====
[1, 2, 3]
[1, 2, 3]
37235144
37191432
=====深拷贝=====
[1, 2, 3]
[1, 2, 3]
37235144
37210184
"""

import copy
l=[1,2,3,[4, 5]]
l1=l #赋值
l2=copy.copy(l) #浅拷贝
l3=copy.deepcopy(l) #深拷贝
l.append(6)
print(l)  
print(l1)
print(l2)
print(l3)
# 结果
"""
[1, 2, 3, [4, 5], 6]     #l添加一个元素6
[1, 2, 3, [4, 5], 6]     #l1跟着添加一个元素6
[1, 2, 3, [4, 5]]        #l2保持不变
[1, 2, 3, [4, 5]]        #l3保持不变
"""

import copy
l=[1,2,3,[4, 5]]
l1=l #赋值
l2=copy.copy(l) #浅拷贝
l3=copy.deepcopy(l) #深拷贝
l[3].append(6) 
print(l) 
print(l1)
print(l2)
print(l3)
# 结果
"""
[1, 2, 3, [4, 5, 6]]      #l[3]添加一个元素6
[1, 2, 3, [4, 5, 6]]      #l1跟着添加一个元素6
[1, 2, 3, [4, 5, 6]]      #l2跟着添加一个元素6
[1, 2, 3, [4, 5]]         #l3保持不变
"""