裝飾器語法糖運用

• 前言：函式名是一個特性的變數，可以作為容器的元素，也可以作為函式的引數，也可以當做返回值。

• 閉包定義：

  • 內層函式對外層函式（非全域性）變數的引用，這個內層函式就可以成為閉包

  • 在Python中我們用__closure__來檢查函式是否是閉包

  • def func1():
        name = '張三'
    
        def func2():
            print(name)  # 能夠訪問到外層作用域的變數
        func2()
        print(func2.__closure__)  # (<cell at 0x1036c7438: str object at 0x10389d088>,)
    
    func1()
    print(func1.__closure__)  # None
     
    

• 裝飾器

  • 前言：軟體設計原則：開閉原則，又稱開放封閉原則

    • 指對擴充套件程式碼的功能是開放的，但對修改原始碼是封閉的，

  • def create_people():
        print('女媧真厲害，捏個泥吹口氣就成了人！')
    
    
    def a(func):
        def b():
            print('灑點水')
            func()
        return b
    
    ret = a(create_people)
    ret()

  • 通過裝飾器語法等同於

  • def a(func):
        def b():
            print('灑點水')
            func()
        return b
    
    
    @a  # 裝飾器語法糖的作用就是上述函式ret（）
    def create_people():
        print('女媧真厲害，捏個泥吹口氣就成了人！')
    
    create_people()
     
    

• 裝飾帶返回值的函式，即return出被裝飾函式的執行結果

  • def foo(func):  # 接收的引數是一個函式名
        def bar():  # 定義一個內層函式
            print("這裡是新功能...")  # 新功能
            r = func()  # 在記憶體函式中拿到被裝飾函式的結果
            return r  # 返回被裝飾函式的執行結果
        return bar
    
    
    # 定義一個有返回值的函式
    @foo
    def f1():
        return '嘿嘿嘿'
    
    
    # 呼叫被裝飾函式
    ret = f1()  # 呼叫被裝飾函式並拿到結果
    print(ret)
     
    

• 裝飾帶引數的函式

  • def func1(func):              # 接收的引數為一個函式名
        def inner(*args, **kwargs):     # 這裡需要定義和被裝飾函式相同的引數
            print("新功能")                # 新功能
            ret = func(*args, **kwargs)     #被裝飾的函式和引數
            print("新功能")         
            return ret
        return inner
    
    # 定義一個需要倆個引數的函式
    @func1
    def func(a, b):
        return a + b
    
    
    ret = func(3, 5)
    print(ret)

• 帶引數的裝飾器 即在裝飾器外在寫一層函式，從而使其帶引數

  • def d(a=None):        # 定義一個外層函式，給裝飾器傳引數
        def func1(func):  # 接收的是一個函式名
            def inner(*args, **kwargs): # 被裝飾的函式，和引數
                if a:
                    print(f"歡迎來到{a}")   #新增新功能
                else:
                    print("歡迎來到王者榮耀")  
                func(*args, **kwargs)
            return inner
        return func1
    
    
    # @d("英雄聯盟")
    # def func(st):
    #     print(st)
    # func("敵軍還有三十秒到達戰場")
                                  # 歡迎來到英雄聯盟
                                  # 敵軍還有三十秒到達戰場
    
    @d()
    def func(st):
        print(st)
    func("敵軍還有三十秒到達戰場")
    # 歡迎來到王者榮耀
    # 敵軍還有三十秒到達戰場

• 裝飾器修復技術

  • 定義：被裝飾的函式最終都會失去本來的__doc__等資訊， Python給我們提供了一個修復被裝飾函式的工具。

  • from functools import wraps    #匯入
    print(f1.__doc__)
    print(f1.__name__)

• 多個裝飾器裝飾同一函式

  • def foo1(func):
        print("d1")
    
        def inner1():
            print("inner1")
            return "<i>{}</i>".format(func())
    
        return inner1
    
    
    def foo2(func):
        print("d2")
    
        def inner2():
            print("inner2")
            return "<b>{}</b>".format(func())
    
        return inner2
    
    
    @foo1
    @foo2
    def f1():
        return "Hello Andy"
    
    # f1 = foo2(f1)  ==> print("d2") ==> f1 = inner2
    # f1 = foo1(f1)  ==> print("d1") ==> f1 = foo1(inner2) ==> inner1
    
    ret = f1()  # 呼叫f1() ==> inner1()  ==> <i>inner2()</i>  ==> <i><b>inner1()</b></i> ==> <i><b>Hello Andy</b></i>
    print(ret)

• 類裝飾器

  • class D(object):
        def __init__(self, a=None):
            self.a = a
            self.mode = "裝飾"
    
        def __call__(self, *args, **kwargs):
            if self.mode == "裝飾":
                self.func = args[0]  # 預設第一個引數是被裝飾的函式
                self.mode = "呼叫"
                return self
            # 當self.mode == "呼叫"時，執行下面的程式碼（也就是呼叫使用類裝飾的函式時執行）
            if self.a:
                print("歡迎來到{}頁面。".format(self.a))
            else:
                print("歡迎來到首頁。")
            self.func(*args, **kwargs)
    
    
    @D()
    def index(name):
        print("Hello {}.".format(name))
    
    
    @D("電影")
    def movie(name):
        print("Hello {}.".format(name))
    
    if __name__ == '__main__':
        index('張三')
        movie('張三')

• 裝飾類

  • # 定義一個類裝飾器
    class D(object):
        def __call__(self, cls):
            class Inner(cls):
                # 重寫被裝飾類的f方法
                def f(self):
                    print('Hello 張三.')
            return Inner
    
    
    @D()
    class C(object):  # 被裝飾的類
        # 有一個例項方法
        def f(self):
            print("Hello world.")
    
    
    if __name__ == '__main__':
        c = C()
        c.f()