88 python高級 - 裝飾器

時間  2021-08-15
標籤 python redis 數據庫 編程 緩存 app ide 函數式編程 函數 日誌 欄目 Python 简体版
原文   原文鏈接

一、先明白這段代碼

#### 第一波 ####
def foo():
    print('foo')

foo     #表示是函數
foo()   #表示執行foo函數



#### 第二波 ####
def foo():
    print('foo')

foo = lambda x: x + 1

foo()   # 執行下面的lambda表達式，而再也不是原來的foo函數，由於foo這個名字被從新指向了另一個匿名函數

二、需求

初創公司有N個業務部門，1個基礎平臺部門，基礎平臺負責提供底層的功能，如：數據庫操做、redis調用、監控API等功能。業務部門使用基礎功能時，只需調用基礎平臺提供的功能便可。以下：python

############### 基礎平臺提供的功能以下 ###############

def f1():
    print('f1')

def f2():
    print('f2')

def f3():
    print('f3')

def f4():
    print('f4')

############### 業務部門A 調用基礎平臺提供的功能 ###############

f1()
f2()
f3()
f4()

############### 業務部門B 調用基礎平臺提供的功能 ###############

f1()
f2()
f3()
f4()

目前公司有條不紊的進行着，可是，之前基礎平臺的開發人員在寫代碼時候沒有關注驗證相關的問題，即：基礎平臺的提供的功能能夠被任何人使用。如今須要對基礎平臺的全部功能進行重構，爲平臺提供的全部功能添加驗證機制，即：執行功能前，先進行驗證。redis

老大把工做交給 Low B，他是這麼作的：數據庫

跟每一個業務部門交涉，每一個業務部門本身寫代碼，調用基礎平臺的功能以前先驗證。誒，這樣一來基礎平臺就不須要作任何修改了。太棒了，有充足的時間泡妹子…編程

當天Low B 被開除了…緩存

老大把工做交給 Low BB，他是這麼作的：app

############### 基礎平臺提供的功能以下 ############### 

def f1():
    # 驗證1
    # 驗證2
    # 驗證3
    print('f1')

def f2():
    # 驗證1
    # 驗證2
    # 驗證3
    print('f2')

def f3():
    # 驗證1
    # 驗證2
    # 驗證3
    print('f3')

def f4():
    # 驗證1
    # 驗證2
    # 驗證3
    print('f4')

############### 業務部門不變 ############### 
### 業務部門A 調用基礎平臺提供的功能### 

f1()
f2()
f3()
f4()

### 業務部門B 調用基礎平臺提供的功能 ### 

f1()
f2()
f3()
f4()
過了一週 Low BB 被開除了…

老大把工做交給 Low BBB，他是這麼作的：ide

只對基礎平臺的代碼進行重構，其餘業務部門無需作任何修改函數式編程

############### 基礎平臺提供的功能以下 ############### 

def check_login():
    # 驗證1
    # 驗證2
    # 驗證3
    pass


def f1():

    check_login()

    print('f1')

def f2():

    check_login()

    print('f2')

def f3():

    check_login()

    print('f3')

def f4():

    check_login()

    print('f4')

老大看了下Low BBB 的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟Low BBB聊了個天：函數

老大說：
寫代碼要遵循開放封閉原則，雖然在這個原則是用的面向對象開發，可是也適用於函數式編程，簡單來講，它規定已經實現的功能代碼不容許被修改，但能夠被擴展，即：日誌

  • 封閉：已實現的功能代碼塊
  • 開放：對擴展開發

若是將開放封閉原則應用在上述需求中，那麼就不容許在函數 f1 、f二、f三、f4的內部進行修改代碼，老闆就給了Low BBB一個實現方案：

def w1(func):
    def inner():
        # 驗證1
        # 驗證2
        # 驗證3
        func()
    return inner

@w1
def f1():
    print('f1')
@w1
def f2():
    print('f2')
@w1
def f3():
    print('f3')
@w1
def f4():
    print('f4')

對於上述代碼，也是僅僅對基礎平臺的代碼進行修改，就能夠實如今其餘人調用函數 f1 f2 f3 f4 以前都進行【驗證】操做，而且其餘業務部門無需作任何操做。

Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什麼呢？

老大正要生氣，忽然Low BBB的手機掉到地上，恰巧屏保就是Low BBB的女朋友照片，老大一看一緊一抖，喜笑顏開，決定和Low BBB交個好朋友。

詳細的開始講解了：

單獨以f1爲例：

def w1(func):
    def inner():
        # 驗證1
        # 驗證2
        # 驗證3
        func()
    return inner

@w1
def f1():
    print('f1')

python解釋器就會從上到下解釋代碼，步驟以下：

  1. def w1(func): ==>將w1函數加載到內存
  2. @w1

沒錯， 從表面上看解釋器僅僅會解釋這兩句代碼，由於函數在 沒有被調用以前其內部代碼不會被執行。

從表面上看解釋器着實會執行這兩句，可是 @w1 這一句代碼裏卻有大文章， @函數名 是python的一種語法糖。

上例@w1內部會執行一下操做：

執行w1函數

執行w1函數 ，並將 @w1 下面的函數做爲w1函數的參數，即：@w1 等價於 w1(f1) 因此，內部就會去執行：

def inner(): 
    #驗證 1
    #驗證 2
    #驗證 3
    f1()     # func是參數，此時 func 等於 f1 
return inner# 返回的 inner，inner表明的是函數，非執行函數 ,其實就是將原來的 f1 函數塞進另一個函數中

w1的返回值
將執行完的w1函數返回值 賦值 給@w1下面的函數的函數名f1 即將w1的返回值再從新賦值給 f1，即：

新f1 = def inner(): 
            #驗證 1
            #驗證 2
            #驗證 3
            原來f1()
        return inner

因此，之後業務部門想要執行 f1 函數時，就會執行 新f1 函數，在新f1 函數內部先執行驗證，再執行原來的f1函數，而後將原來f1 函數的返回值返回給了業務調用者。

如此一來， 即執行了驗證的功能，又執行了原來f1函數的內容，並將原f1函數返回值 返回給業務調用着

Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！

3. 再議裝飾器

#定義函數：完成包裹數據
def makeBold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

#定義函數：完成包裹數據
def makeItalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makeBold
def test1():
    return "hello world-1"

@makeItalic
def test2():
    return "hello world-2"

@makeBold
@makeItalic
def test3():
    return "hello world-3"

print(test1()))
print(test2()))
print(test3()))

運行結果:

<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>

4. 裝飾器(decorator)功能

  1. 引入日誌
  2. 函數執行時間統計
  3. 執行函數前預備處理
  4. 執行函數後清理功能
  5. 權限校驗等場景
  6. 緩存

5. 裝飾器示例

例1:無參數的函數

from time import ctime, sleep

def timefun(func):
    def wrappedfunc():
        print("%s called at %s"%(func.__name__, ctime()))
        func()
    return wrappedfunc

@timefun
def foo():
    print("I am foo")

foo()
sleep(2)
foo()

上面代碼理解裝飾器執行行爲可理解成

foo = timefun(foo)
#foo先做爲參數賦值給func後,foo接收指向timefun返回的wrappedfunc
foo()
#調用foo(),即等價調用wrappedfunc()
#內部函數wrappedfunc被引用，因此外部函數的func變量(自由變量)並無釋放
#func裏保存的是原foo函數對象

例2:被裝飾的函數有參數

from time import ctime, sleep

def timefun(func):
    def wrappedfunc(a, b):
        print("%s called at %s"%(func.__name__, ctime()))
        print(a, b)
        func(a, b)
    return wrappedfunc

@timefun
def foo(a, b):
    print(a+b)

foo(3,5)
sleep(2)
foo(2,4)

例3:被裝飾的函數有不定長參數

from time import ctime, sleep

def timefun(func):
    def wrappedfunc(*args, **kwargs):
        print("%s called at %s"%(func.__name__, ctime()))
        func(*args, **kwargs)
    return wrappedfunc

@timefun
def foo(a, b, c):
    print(a+b+c)

foo(3,5,7)
sleep(2)
foo(2,4,9)

例4:裝飾器中的return

from time import ctime, sleep

def timefun(func):
    def wrappedfunc():
        print("%s called at %s"%(func.__name__, ctime()))
        func()
    return wrappedfunc

@timefun
def foo():
    print("I am foo")

@timefun
def getInfo():
    return '----hahah---'

foo()
sleep(2)
foo()


print(getInfo())

執行結果:

foo called at Fri Nov  4 21:55:35 2016
I am foo
foo called at Fri Nov  4 21:55:37 2016
I am foo
getInfo called at Fri Nov  4 21:55:37 2016
None

若是修改裝飾器爲return func()，則運行結果：

foo called at Fri Nov  4 21:55:57 2016
I am foo
foo called at Fri Nov  4 21:55:59 2016
I am foo
getInfo called at Fri Nov  4 21:55:59 2016
----hahah---

通常狀況下爲了讓裝飾器更通用，能夠有return。

例5:裝飾器帶參數,在原有裝飾器的基礎上，設置外部變量

#decorator2.py

from time import ctime, sleep

def timefun_arg(pre="hello"):
    def timefun(func):
        def wrappedfunc():
            print("%s called at %s %s"%(func.__name__, ctime(), pre))
            return func()
        return wrappedfunc
    return timefun

@timefun_arg("itcast")
def foo():
    print("I am foo")

@timefun_arg("python")
def too():
    print("I am too")

foo()
sleep(2)
foo()

too()
sleep(2)
too()

能夠理解爲

foo()==timefun_arg("itcast")(foo)()

例6：類裝飾器（擴展，非重點）

裝飾器函數實際上是這樣一個接口約束，它必須接受一個callable對象做爲參數，而後返回一個callable對象。在Python中通常callable對象都是函數，但也有例外。只要某個對象重寫了 call() 方法，那麼這個對象就是callable的。

class Test():
    def __call__(self):
        print('call me!')

t = Test()
t()  # call me

類裝飾器demo

class Test(object):
    def __init__(self, func):
        print("---初始化---")
        print("func name is %s"%func.__name__)
        self.__func = func
    def __call__(self):
        print("---裝飾器中的功能---")
        self.__func()
#說明：
#1. 當用Test來裝做裝飾器對test函數進行裝飾的時候，首先會建立Test的實例對象
#    而且會把test這個函數名當作參數傳遞到__init__方法中
#    即在__init__方法中的func變量指向了test函數體
#
#2. test函數至關於指向了用Test建立出來的實例對象
#
#3. 當在使用test()進行調用時，就至關於讓這個對象()，所以會調用這個對象的__call__方法
#
#4. 爲了可以在__call__方法中調用原來test指向的函數體，因此在__init__方法中就須要一個實例屬性來保存這個函數體的引用
#    因此纔有了self.__func = func這句代碼，從而在調用__call__方法中可以調用到test以前的函數體
@Test
def test():
    print("----test---")
test()
showpy()#若是把這句話註釋，從新運行程序，依然會看到"--初始化--"

運行結果以下：

---初始化---
func name is test
---裝飾器中的功能---
----test---
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程