2. 程式人生 > >閉包&裝飾器

閉包&裝飾器

阿新 • • 發佈：2019-01-21
日誌 才有 釋放 for 員工 能夠 調用函數 xxx 變量

閉包

1.函數引用

def test():
    print(‘--test--‘)

# 調用函數
test()
# 引用函數
ret = test

print(id(ret))
print(id(test))

# 通過引用調用函數
ret()

#輸出結果
--test--
1718807047704
1718807047704
--test--

2.什麽是閉包

# 定義一個函數
def test(num):
    # 在函數內部再定義一個函數，並且這個函數用到外部函數的變量，那麽將這個函數以及用到的一些變量稱之為閉包
    def inner_test(inner_num):
        
 
print(‘inner_num:%d‘ %inner_num)
        return num +inner_num
    # 其實這裏返回的就是閉包的結果
    return inner_test

# 給test函數賦值，這個20就是給參數num
ret = test(10)
# 這裏的50其實給參數inner_num
print(ret(50))
# 這裏的100其實給參數inner_num
print(ret(100))

# 輸出結果：
inner_num:50
60
inner_num:100
110

3. 一個閉包的實際例子：

def line_conf(a, b):
    def line(x):
        
 
return a*x + b
    return line

line1 = line_conf(1, 1)
line2 = line_conf(4, 5)
print(line1(5))
print(line2(5))

這個例子中，函數line與變量a,b構成閉包。在創建閉包的時候，我們通過line_conf的參數a,b說明了這兩個變量的取值，這樣，我們就確定了函數的最終形式(y = x + 1和y = 4x + 5)。我們只需要變換參數a,b，就可以獲得不同的直線表達函數。由此，我們可以看到，閉包也具有提高代碼可復用性的作用。

如果沒有閉包，我們需要每次創建直線函數的時候同時說明a,b,x。這樣，我們就需要更多的參數傳遞，也減少了代碼的可移植性。

註意點:

由於閉包引用了外部函數的局部變量，則外部函數的局部變量沒有及時釋放，消耗內存

4. 修改外部函數中的變量

python3的方法：

def outer(start=0):
    def inner():
        nonlocal start
        start += 1
        return start
    return inner

o1= outer(5)
print(o1())  # 6
print(o1())  # 7

o2 = outer(10)
print(o2())  # 11
print(o2())  # 12

python2的方法：

def outer(start=0):
    count=[start]
    def inner():
        count[0] += 1
        return count[0]
    return inner

o1 = closeure.outer(5)
print(o1())  # 6
print(o1())  # 7
o2 = closeure.outer(10)
print(o2())  # 11
print(o2())  # 12

裝飾器

1、先明白這段代碼

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

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

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

foo = lambda x: x + 1

foo()  # 執行lambda表達式，而不再是原來的foo函數，因為foo這個名字被重新指向了另外一個匿名函數

函數名僅僅是個變量，只不過指向了定義的函數而已，所以才能通過函數名()調用，如果 函數名=xxx被修改了，那麽當在執行 函數名()時，調用的就不知之前的那個函數了

2、需求

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

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

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()

目前公司有條不紊的進行著，但是，以前基礎平臺的開發人員在寫代碼時候沒有關註驗證相關的問題，即：基礎平臺的提供的功能可以被任何人使用。現在需要對基礎平臺的所有功能進行重構，為平臺提供的所有功能添加驗證機制，即：執行功能前，先進行驗證。

老大把工作交給員工C，他是這麽做的：

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

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()

老大把工作交給員工D，他是這麽做的：

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

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‘)

老大看了下員工D的實現，嘴角漏出了一絲的欣慰的笑，語重心長的跟員工D聊了個天：

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

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

如果將開放封閉原則應用在上述需求中，那麽就不允許在函數 f1 、f2、f3、f4的內部進行修改代碼，老板就給了員工D一個實現方案：

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為例：

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函數返回值 返回給業務調用者

3. 裝飾器(decorator)功能

  1. 引入日誌

  2. 函數執行時間統計

  3. 執行函數前預備處理

  4. 執行函數後清理功能

  5. 權限校驗等場景

  6. 緩存

4. 裝飾器示例

例1:無參數的函數

技術分享圖片 
import time

def set_func(foo):
    def call_func():
        start_time = time.time()
        foo()
        end_time = time.time()
        print("運行時間：%f" % (end_time-start_time))
    return call_func

@set_func
def test():
    print("test")
    for i in range(100000):
        pass
test()

test = set_fun(foo)

# test先作為參數賦值給foo後,test接收指向set_fun返回的call_func
# 調用test(),即等價調用call_func()
# 內部函數call_func被引用，所以外部函數的foo變量(自由變量)並沒有釋放
# foo裏保存的是原test函數對象
View Code

例2：帶參數函數的裝飾

技術分享圖片 
def set_func(foo):
    def call_func(num):
        foo(num)
    return call_func

@set_func
def test(num):
    print(num)

test(11)
View Code

例3：對多個函數進行裝飾

技術分享圖片 
def set_func(foo):
    def call_func():
        foo()
    return call_func

@set_func
def test1():
    print("test1")

@set_func
def test2():
    print("test2")

test1()
test2()
View Code

例4：在調用函數之前已經開始裝飾

技術分享圖片 
def set_func(foo):
    print("開始裝飾")
    def call_func():
        foo()
    return call_func

@set_func
def test1():
    print("test1")
View Code

例5：對不定長參數的函數裝飾

技術分享圖片 
def set_func(foo):
    def call_func(*args, **kwargs):
        foo(*args, **kwargs)
        print("--end--")
    return call_func

@set_func
def test1(num, *args, **kwargs):
    print("test1",num)
    print("test1",args)
    print("test1",kwargs)

test1(11)
test1(11,22,33)
test1(11,22,33,a=55)
View Code

例6;對有返回值的函數裝飾（通用裝飾器）

技術分享圖片 
def set_func(foo):
    def call_func(*args, **kwargs):
        return foo(*args, **kwargs)
    return call_func

@set_func
def test1():
    print("test1")
    return "ok"
ret = test1()
print(ret)
View Code

例7：多個裝飾器對一個函數裝飾

技術分享圖片 
def set_func1(foo):
    print("裝飾器1開始裝飾")
    def call_func(*args, **kwargs):
        print("裝飾器1功能")
        return foo(*args, **kwargs)
    return call_func

def set_func2(foo):
    print("裝飾器2開始裝飾")
    def call_func(*args, **kwargs):
        print("裝飾器2功能")
        return foo(*args, **kwargs)
    return call_func

@set_func1
@set_func2
def test1():
    print("test1")

test1()

# 輸出結果：
裝飾器2開始裝飾
裝飾器1開始裝飾
裝飾器1功能
裝飾器2功能
test1
View Code 技術分享圖片 
def set_func1(foo):
    print("裝飾器1開始裝飾")
    def call_func():
        return "<tr>"+foo()+"</tr>"
    return call_func

def set_func2(foo):
    print("裝飾器2開始裝飾")
    def call_func():
        return "<td>" + foo() + "</td>"
    return call_func

@set_func1
@set_func2
def test1():
    return "ok"
print(test1())

# 輸出結果：
裝飾器2開始裝飾
裝飾器1開始裝飾
<tr><td>ok</td></tr>
View Code

例8：用類對函數進行裝飾

技術分享圖片 
class Test(object):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("裝飾器的功能")
        return self.func(*args, **kwargs)

@Test
def test():
    return "ok"

print(test())

#說明：
#1. 當用Test來裝作裝飾器對test函數進行裝飾的時候，首先會創建Test的實例對象
#   並且會把test這個函數名當做參數傳遞到__init__方法中
#   即在__init__方法中的屬性func指向了test指向的函數
#
#2. test指向了用Test創建出來的實例對象
#
#3. 當在使用test()進行調用時，就相當於讓這個對象()，因此會調用這個對象的__call__方法
#
#4. 為了能夠在__call__方法中調用原來test指向的函數體，所以在__init__方法中就需要一個實例屬性來保存這個函數體的引用
#   所以才有了self.func = func這句代碼，從而在調用__call__方法中能夠調用到test之前的函數體
View Code

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

技術分享圖片 
def level(level_num):
    def set_func(func):
        def call_func(*args, **kwargs):
            if level_num == 1:
                print("極品貨")
            elif level_num == 2:
                print("A貨")
            func(*args, **kwargs)
        return call_func
    return set_func


@level(1)
def test1():
    print("ok")

@level(2)
def test2():
    print("ok")

test1()
test2()
# 下面的裝飾過程
# 1. 調用level("1")
# 2. 將步驟1得到的返回值，即set_func返回， 然後set_func(func)
# 3. 將set_func(func)的結果返回，即call_func
# 4. 讓test1 = call_func，即test1現在指向call_func
View Code

閉包&裝飾器

相關推薦

Day59 Python--閉包&amp;裝飾器

一，函式知識點回顧 def func(): pass print(func) #函式名對應記憶體地址 a = func #可以賦值給變數 a() def func2(arg): #可以做引數 arg() func2(func) def func3(): #可以做返回值

閉包&amp;裝飾器

日誌 才有 釋放 for 員工 能夠 調用函數 xxx 變量 閉包 1.函數引用 def test(): print(‘--test--‘) # 調用函數 test() # 引用函數 ret = test print(id(ret)) print(id(tes

Day 19 函數之閉包、裝飾器

false print glob src true success 返回值 count please 一、什麽是裝飾器 器即函數 裝飾即修飾，意指為其他函數添加新功能 裝飾器定義：本質就是函數，功能是為其他函數添加新功能 二、裝飾器遵循的原則 1.不修改被裝飾函數

python閉包和裝飾器（轉）

lee type ade 機制 並且 change -1 pri neu 一、python閉包 1、內嵌函數 >>> def func1(): ... print (‘func1 running...‘) ... def func2(

函數的閉包和裝飾器

time pre col 美的 style 修改 功能 技術 def 函數的閉包： 　　#1.閉 必須是內部的函數 　　#2.包 引用了外部作用域中的變量 命名空間： 　　一共有三種命名空間從大範圍到小範圍的順序：內置命名空間、全局命名空間、局部命名空間 作用域

Day4 閉包、裝飾器decorator、叠代器與生成器、面向過程編程、三元表達式、列表解析與生成器表達式、序列化與反序列化

反序 bsp pic nbsp tor 序列 space 列表解析 列表 http://pic.cnhubei.com/space.php?uid=1774&do=album&id=1362489http://pic.cnhubei.com/space.ph

Python--閉包與裝飾器

python 閉包 裝飾器 閉包的意義：返回的函數對象，不僅僅是一個函數對象，在該函數外還包裹了一層作用域，這使得，該函數無論在何處調用，優先使用自己外層包裹的作用域 #應用領域：延遲計算（原來我們是傳參，現在我們是包起來）from urllib.request import urlopen

函數進階：閉包、裝飾器

fun 閉包、裝飾器 擴展 輸出 關系 返回 空間 名字空間 局部變量 命名空間（又稱“名稱空間”）： 存放名字的地方 （概念性的東西） 例如：變量x = 1, 1存放在內存中，命名空間就是存放名字x與1綁定關系的地方。 名稱空間有3種： locals：是函數內的（或者

閉包與裝飾器

函數名 for循環 a + b 使用 style 裝飾 post 內存地址 lee 一、函數名 　　函數名在本質上就是函數的內存地址，函數名有以下功能： 　　　　函數名可以賦值給別的變量；； 　　　　函數名還可以當做容器類型裏面的元素，（列表、字典）； 　　　　函數名可以當

函數名，閉包，裝飾器

span play 分享 技術 splay 容器類 函數的參數 spl pri #輸出的__closure__有cell元素 ：是閉包函數 def func(): name = ‘eva‘ def inner(): print(name)

閉包，裝飾器

print conf 文章 tar 函數的參數 led world 方法 str 閉包 1. 函數引用 def test1(): print("--- in test1 func----") # 調用函數 test1() # 引用函數 ret = test1

Python 基礎第十一天(閉包和裝飾器初識)

過程 理解 繼續 記錄 turn 格式 -s pos 變量賦值 今日內容: 函數名的應用 閉包 裝飾器的初識 裝飾器的傳參 1.函數名的應用 函數名是函數的名字. 本質：變量，特殊的變量。是函數的內存地址 函數名() 可以執行此函數 (1)單獨打印函數名,可以得到函數的內存

Python高級--閉包與裝飾器

定義 修改 pass alt 區別 strong 分享 func 基礎 前言：在Python中，閉包是一種非常有用的功能！它通常與裝飾器一起搭配使用，可以在不改變被裝飾函數的功能的基礎上，完成更多的功能。如權限認證。 一、如何定義閉包 　　1.閉包就是兩個嵌套的函數，外層函

python閉包與裝飾器

添加 war 返回值 AR set ret 功能 rgs 區別 閉包閉包:兩個函數的嵌套,外部函數返回內部函數的引用,外部函數一定有參數def 外部函數(參數): 　　def 內部函數(): 　　　　pass return 內部函數 他跟函數之間的

Python閉包和裝飾器

global col line AR bar lis 它的 class failed （1）python的LEGB： LEGB是指：按照L>E>G>B 的順序優先級進行變量查找。 L：local函數內部作用域，是最底層的單個函數

函數嵌套與閉包嘗試裝飾器

不能 都沒有 定義 type tro ann bsp local nds 什麽是函數嵌套： 在函數裏面再定義一個函數 def foo(): print(‘from foo‘) def test(): pass def father(au

閉包和裝飾器

裝飾器 urn turn func 就是 在外 嵌套 調用 CA #閉包 叫什麽閉包 有什麽用:在執行函數的時候可以在外部函數中保留參數在內存中 寫法:兩個函數的嵌套,外部函數返回內部函數的引用,外部函數必須有參數 def 外部函數(參數): 　　def 內部函數()

函數進階---作用域、閉包、裝飾器

閉包 查看 就是 喜歡 name 應該 tro 變量 擴展 名稱空間 名稱空間指存放名字的地方 名稱空間分為三種： locals:函數內部的名稱空間，包括局部變量與形參 globals:全局變量，函數模塊定義所在模塊的空間 builtins 內置模塊的名稱空間 不

13、python中的函數（閉包與裝飾器）

屬性 新的 做的 一個 too 實現 inf 高級 器） 一、嵌套函數 函數的內部又再定義另一個函數，這個函數就叫嵌套函數，裏面含函數就叫內部函數。 示例： 二、返回函數 函數可以接收函數對象作為參數，同理函數也能返回一個函數對象作為返回值。

python中的閉包和裝飾器

原函數 com 持久 sys 判斷 關於 success 常用 參數傳遞 閉包函數介紹 什麽是閉包 維基百科中關於閉包的概念： 在一些語言中，在函數中可以（嵌套）定義另一個函數時，如果內部的函數引用了外部的函數的變量，則可能產生閉包。閉包可以用來在一個函數與一組 “私有”