"""
閉包：
    概述：
        使用了外部函數(shù)變量的內(nèi)部函數(shù)，稱之為閉包。
    回顧：局部變量的生命周期？
        局部變量隨著函數(shù)的調(diào)用而存在，隨著函數(shù)的調(diào)用完畢而銷毀，即：函數(shù)執(zhí)行結(jié)束后，變量就被釋放了。
    格式：
        def 外部函數(shù)名(形參列表):
            可以在這里定義 外部函數(shù)的 局部變量
            def 內(nèi)部函數(shù)名(形參列表):
                在這里使用 外部函數(shù)的變量
            return 內(nèi)部函數(shù)名
    閉包的三個前提條件：
        1：有嵌套，即：有外部函數(shù)，有內(nèi)部函數(shù)。
        2：有引用，即：在內(nèi)部函數(shù)中，有使用外部函數(shù)的引用。
        3：有返回，即：在外部函數(shù)中，返回內(nèi)部函數(shù)（對象）
"""
# 需求1：回顧局部變量的作用域。
def method():
    number = 10
    return number
# 需求2：演示閉包，定義用于求和的閉包函數(shù)，外部函數(shù)有參數(shù)num1，內(nèi)部函數(shù)有參數(shù)num2，內(nèi)部函數(shù)返回num1+num2
def outer(num1):                        # 定義了外部函數(shù)outer
    def inner(num2):                    # 定義了內(nèi)部函數(shù)inner
        sum = num1+num2                 # 使用了外部函數(shù)的變量num1
        print(f"求和的結(jié)果是：{sum}")
    return inner                        # 外部函數(shù)返回內(nèi)部函數(shù)對象
if __name__ == '__main__':
    # 目前：函數(shù)每次調(diào)用都會生成一個新的number變量，函數(shù)調(diào)用結(jié)束后，number變量就會銷毀。
    print(method())  # 10
    print(method()+1) # 11
    print(method()+1) # 11
    print(method()+1) # 11
    print(20* "-")
    """
        fn = outer(10) # fn是外部函數(shù)outer的返回值，即內(nèi)部函數(shù)inner
        fn = def inner(num2):                       # 定義了內(nèi)部函數(shù)inner
                sum = 10 + num2                     # 使用了外部函數(shù)的變量num1
                print(f"求和的結(jié)果是：{sum}")
    """
    fn = outer(10) # fn是外部函數(shù)outer的返回值，即內(nèi)部函數(shù)inner
    """
    此時  fn = outer(10)
     = def outer(10)
        def inner(num2):                    
            sum = 10 + num2                 
            print(f"求和的結(jié)果是：{sum}")
    """
    """
        fn(1)
        inner(1):                            # 定義了內(nèi)部函數(shù)inner
                sum = 10 + 1                 # 使用了外部函數(shù)的變量num1
                print(f"求和的結(jié)果是：{sum}")
    """
    fn(1)
    """
        fn(2)
        inner(2):                            # 定義了內(nèi)部函數(shù)inner
                sum = 10 + 2                 # 使用了外部函數(shù)的變量num1
                print(f"求和的結(jié)果是：{sum}")
    """
    fn(2)

"""
nonlocal關(guān)鍵字的介紹：
    概述：
        是一個關(guān)鍵字，可以實現(xiàn)讓內(nèi)部函數(shù)去修改外部函數(shù)的變量值。
    回顧：
        global      聲明變量    ->為全局變量
        nonlocal    聲明變量    ->可以被內(nèi)部函數(shù)修改
"""
# 需求：編寫一個閉包，讓內(nèi)部函數(shù)去訪問外部函數(shù)的變量，并修改她的值，觀察結(jié)果
# 1：定義閉包代碼，讓內(nèi)部函數(shù)去修改外部函數(shù)的變量值
def fn_outer(): # 聲明外部函數(shù)
    x = 100
    def fn_inner(): # 聲明內(nèi)部函數(shù)
        # 核心，內(nèi)部函數(shù)想修改外部函數(shù)的變量值，該變量值需要用到nonlocal關(guān)鍵字修飾
        nonlocal x
        x = x + 20  # 在內(nèi)部函數(shù)中，去修改外部函數(shù)的變量值
        print(f"x的值為：{x}")
    return fn_inner
if __name__ == '__main__':
    fn = fn_outer()
    fn()
    fn()
    fn()

"""
裝飾器的介紹：
    概述：
        裝飾器=閉包函數(shù)，即：裝飾器是閉包函數(shù)的一種寫法。
    目的/作用：
        在不改變原有函數(shù)的基礎(chǔ)上，對原有函數(shù)的功能做加強。
    前提條件：
        1：有嵌套
        2：有引用
        3：有返回
        4：有額外功能
    裝飾器的用法：
        寫法1：傳統(tǒng)寫法
            變量名 = 裝飾器名(要被裝飾的原函數(shù)名)
            變量名()       # 執(zhí)行的就是，裝飾后的原函數(shù)
        寫法2：語法糖         語法糖 = 語法格式簡化版
            在定義原函數(shù)的時候，加上@裝飾器名即可，之后就能正確調(diào)用該原函數(shù)即可
"""
# 需求：發(fā)表評論前，需要先登錄（模擬的操作）
# 1：定義裝飾器（閉包函數(shù)），用于對指定函數(shù)功能做增強。
def login(fn_name):       #有外部函數(shù)
    # 定義內(nèi)部函數(shù)，用于對指定的fn_name函數(shù)功能做增強。
    def inner():                #有內(nèi)部函數(shù)
        print("登錄中...登錄成功....") #有額外功能
        fn_name()               #有引用
    return inner                #有返回
# # 寫法1：傳統(tǒng)寫法
# def comment():
#     print("發(fā)表評論...")
# 寫法2：語法糖
# comment()上面加一個@check_login修飾符的含義是：將comment函數(shù)名作為check_login函數(shù)的參數(shù)傳遞給check_login函數(shù)，并返回check_login函數(shù)的返回值
@login
def comment():
    print("發(fā)表評論...")
if __name__ == '__main__':
    # 2：調(diào)用裝飾器，并傳入要被裝飾的函數(shù)名
    # 寫法1：傳統(tǒng)寫法
    # comment = check_login(comment)
    # comment()
    # 寫法2：語法糖, 在定義原函數(shù)的時候，加上@裝飾器名即可，之后就能正確調(diào)用該原函數(shù)即可
    comment()
# 輸出結(jié)果為
登錄中...登錄成功....
發(fā)表評論...

# 需求：定義無參無返回值的原函數(shù)：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()
# 輸出結(jié)果
【友好提示】正在努力計算中...
兩個變量的和為：30

# 需求：定義有參無返回值的原函數(shù)：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)
#輸出結(jié)果
【友好提示】正在努力計算中...
兩個變量的和為：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)
# 輸出結(jié)果
【友好提示】正在努力計算中...
30

# 需求：定義有參無返回值的原函數(shù)：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)
# 輸出結(jié)果
具體執(zhí)行步驟：
    1:當(dāng)使用 @print_info 裝飾 get_sum 時，相當(dāng)于執(zhí)行了：getSum = print_info(get_sum)
    2:此時，print_info(get_sum) 返回的是 inner 函數(shù)。所以，getSum 現(xiàn)在實際上是 inner 函數(shù)。
    3:當(dāng)調(diào)用 getSum(10, 30) 時，實際上調(diào)用的是 inner(10, 30)。
    4:在 inner 函數(shù)內(nèi)部，先打印提示信息，然后調(diào)用原始的函數(shù)（即之前的 get_sum，被裝飾前的函數(shù)）并傳入?yún)?shù)，得到結(jié)果，然后返回。
【友好提示】正在努力計算中...
40

'''
通用裝飾器：① 有嵌套 ② 有引用 ③ 有返回 ④ 有不定長參數(shù) ⑤ 有return返回值
'''
def logging(fn):
    def inner(*args, **kwargs):
        # 輸出裝飾器功能
        print('-- 正在努力計算 --')
        # 調(diào)用fn函數(shù)
        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))
# 輸出結(jié)果
-- 正在努力計算 --
30
-- 正在努力計算 --
60

"""
多個裝飾器裝飾1個函數(shù)，細(xì)節(jié)如下：
    多個裝飾器裝飾1個函數(shù)，裝飾的順序是由最貼近函數(shù)的那個開始，自下而上（執(zhí)行順序）
"""
# 需求：發(fā)表評論之前，需要先登錄、在進行驗證碼驗證，在不改變原有函數(shù)的基礎(chǔ)上，對功能進行增強
# 1: 定義裝飾器。加入：登錄的功能 登錄-》驗證碼-》發(fā)表評論
def check_login(fn_name):       #有外部函數(shù)
    # 定義內(nèi)部函數(shù)，用于對指定的fn_name函數(shù)功能做增強。
    def inner():                #有內(nèi)部函數(shù)
        print("登錄中...") #有額外功能
        fn_name()               #有引用
    return inner                #有返回
# 2: 定義裝飾器。加入：驗證碼的功能
def check_code(fn_name):       #有外部函數(shù)
    # 定義內(nèi)部函數(shù)，用于對指定的fn_name函數(shù)功能做增強。
    def inner():                #有內(nèi)部函數(shù)
        print("驗證碼驗證中...") #有額外功能
        fn_name()               #有引用
    return inner                #有返回
# 3：定義被裝飾的函數(shù)【自上而下】，意思是最上面的先裝飾，讓后往下
@check_login
@check_code
def comment():
    print("發(fā)表評論...")
if __name__ == '__main__':
#     # 寫法1：傳統(tǒng)的寫法【自下而上】
#     code = check_code(comment)
#     login = check_login(code)
#     login()
#
    print("-" * 50)
    # 寫法2：語法糖
    comment()
# 輸出結(jié)果
登錄中...
驗證碼驗證中...
發(fā)表評論...

"""
帶有參數(shù)的裝飾器：
    1個裝飾器的參數(shù)只能有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"【加法運算】結(jié)果為：{sum}")
@logging("-")
def substract(a, b):
    sum = a - b
    print(f"【減法運算】結(jié)果為：{sum}")
if __name__ == '__main__':
    add(10, 20)
    substract(20, 10)
# 輸出結(jié)果
【友好提示】正在努力 加法 計算中...
【加法運算】結(jié)果為：30
【友好提示】正在努力 減法 運算中...
【減法運算】結(jié)果為：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))
# 結(jié)果如下
"""
=====賦值=====
[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)
# 結(jié)果
"""
[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)
# 結(jié)果
"""
[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保持不變
"""