python裝飾器領域博主的簡單介紹

本文目錄一覽：

1、Python之裝飾器簡介
2、推薦 8 個炫酷的 Python 裝飾器
3、「低門檻手把手」python 裝飾器(Decorators)原理說明
4、如何理解Python裝飾器

Python之裝飾器簡介

python函數式編程之裝飾器

1.開放封閉原則

簡單來說，就是對擴展開放，對修改封閉。

在面向對象的編程方式中，經常會定義各種函數。一個函數的使用分為定義階段和使用階段，一個函數定義完成以後，可能會在很多位置被調用。這意味着如果函數的定義階段代碼被修改，受到影響的地方就會有很多，此時很容易因為一個小地方的修改而影響整套系統的崩潰，所以對於現代程序開發行業來說，一套系統一旦上線，系統的源代碼就一定不能夠再改動了。然而一套系統上線以後，隨着用戶數量的不斷增加，一定會為一套系統擴展添加新的功能。

此時，又不能修改原有系統的源代碼，又要為原有系統開發增加新功能，這就是程序開發行業的開放封閉原則，這時就要用到裝飾器了。

「低門檻手把手」python 裝飾器(Decorators)原理說明

本文目的是由淺入深地介紹python裝飾器原理

裝飾器(Decorators)是 Python 的一個重要部分

其功能是，在不修改原函數(類)定義代碼的情況下，增加新的功能

為了理解和實現裝飾器，我們先引入2個核心操作：

在這個例子中，函數hi的形參name，默認為’world’

在函數內部，又定義了另一個函數 howdoyoudo，定義這個函數時，將形參name作為新函數的形參name2的默認值。

因此，在函數內部調用howdoyoudo()時，將以調用hi時的實參為默認值，但也可以給howdoyoudo輸入其他參數。

上面的例子運行後輸出結果為：

這裡新定義的howdoyoudo可以稱作一個「閉包」。不少關於裝飾器的blog都提到了這個概念，但其實沒必要給它取一個多專業的名字。我們知道閉包是函數內的函數就可以了

當我們進行 def 的時候，我們在做什麼？

這時，hi函數，打印一個字符串，同時返回一個字符串。

但hi函數本身也是一個對象，一個可以執行的對象。執行的方式是hi()。

這裡hi和hi()有本質區別，

hi 代表了這個函數對象本身

hi() 則是運行了函數，得到函數的返回值。

作為對比，可以想像以下代碼

此時也是b存在，可以正常使用。

我們定義2個函數，分別實現自加1，自乘2，

再定義一個函數double_exec，內容是將某個函數調用2次

在調用double_exec時，可以將函數作為輸入傳進來

輸出結果就是

同樣，也可以將函數作為輸出

輸出結果為

有了以上兩個核心操作，我們可以嘗試構造裝飾器了。

裝飾器的目的：在不修改原函數(類)定義代碼的情況下，增加新的功能

試想一下，現在有一個原函數

在不修改原函數定義代碼的情況下，如果想進行函數內容的添加，可以將這個函數作為一個整體，添加到這樣的包裹中：

我們定義了一個my_decorator函數，這個函數進行了一種操作：

對傳入的f，添加操作(運行前後增加打印)，並把添加操作後的內容連同運行原函數的內容，一起傳出

這個my_decorator，定義了一種增加前後打印內容的行為

調用my_decorator時，對這個行為進行了操作。

因此，new_function是一個在original_function上增加了前後打印行為的新函數

這個過程被可以被稱作裝飾。

這裡已經可以發現，裝飾器本身對於被裝飾的函數是什麼，是不需要考慮的。裝飾器本身只定義了一種裝飾行為，這個行為是通過裝飾器內部的閉包函數()進行定義的。

運行裝飾前後的函數，可以清晰看到裝飾的效果

我們復現一下實際要用裝飾器的情況，我們往往有一種裝飾器，想應用於很多個函數，比如

此時，如果我們想給3個print函數都加上裝飾器，需要這麼做

實際調用的時候，就需要調用添加裝飾器的函數名了

當然，也可以賦值給原函數名

這樣至少不需要管理一系列裝飾前後的函數。

同時，在不需要進行裝飾的時候，需要把

全部刪掉。

事實上，這樣並不方便，尤其對於更複雜的裝飾器來說

為此，python提供了一種簡寫方式

這個定義print1函數前的@my_decorator，相當於在定義完print1後，自動直接運行了

不論採用@my_decorator放在新函數前，還是顯示地重寫print1 = my_decorator(print1)，都會存在一個問題：

裝飾後的函數，名字改變了(其實不止名字，一系列的索引都改變了)

輸出結果為:

這個現象的原因是，裝飾行為本身，是通過構造了一個新的函數（例子中是wrap_func函數）來實現裝飾這個行為的，然後把這個修改後的函數賦給了原函數名。

這樣，會導致我們預期的被裝飾函數的一些系統變量（比如__name__）發生了變化。

對此，python提供了解決方案：

經過這個行為後，被裝飾函數的系統變量問題被解決了

輸出結果為

剛才的例子都比較簡單，被裝飾的函數是沒有參數的。如果被裝飾的函數有參數，只需要在定義裝飾行為時（事實上，這個才更通用），增加(*args, **kwargs)描述即可

之前的描述中可以感受到，對於例子中的裝飾行為(前後加打印)，函數被裝飾後，本質上是調用了新的裝飾函數wrap_func。

因此，如果原函數需要有輸入參數傳遞，只需要在wrap_func（或其他任意名字的裝飾函數）定義時，也增加參數輸入(*args, **kwargs)，並將這些參數，原封不動地傳給待裝飾函數f。

這種定義裝飾行為的方式更具有普遍性，忘記之前的定義方式吧

我們試一下

輸出

這裡需要注意的是，如果按照以下的方式定義裝飾器

那麼以下語句將不會執行

因為裝飾後實際的函數wrap_func(雖然名字被改成了原函數，系統參數也改成了原函數)，運行到return f(*args, **kwargs) 的時候已經結束了

因為裝飾器my_decorator本身也是可以輸入的，因此，只需要在定義裝飾器時，增加參數，並在後續函數中使用就可以了，比如

此時裝飾器已經可以有輸入參數了

輸出

你可能發現，為什麼不用簡寫版的方法了

因為以上代碼會報錯！！

究其原因，雖然

等價於

但是，

並不等價於

這本身和@語法有關，使用@my_decorator時，是系統在應用一個以單個函數作為參數的閉包函數。即，@是不能帶參數的。

但是你應該發現了，之前的@wraps(f)不是帶參數了嗎？請仔細觀察以下代碼

通過一層嵌套，my_decorator_with_parma本質上是返回了一個參數僅為一個函數的函數(my_decorator)，但因為my_decorator對my_decorator_with_parma來說是一個閉包，my_decorator_with_parma是可以帶參數的。（這句話真繞）

通過以上的定義，我們再來看

可以這麼理解，my_decorator_with_parma(msg=’yusheng’)的結果是原來的my_decorator函數，同時，因為my_decorator_with_parma可以傳參，參數實際上是參與了my_decorator的（因為my_decorator對my_decorator_with_parma是閉包）， my_decorator_with_parma(msg=’yusheng’) 全等於一個有參數參加的my_decorator

因此，以上代碼等價於有參數msg傳遞的

比較繞，需要理解一下，或者乾脆強記這種範式：

以上範式包含函數的輸入輸出、裝飾器的輸入，可以應對大部分情況了。

實驗一下：

輸出

以上是一個log裝飾器，利用datetime統計了函數的耗時，

並且，裝飾器可以進行輸出文件操作，如果給出了文件路徑，則輸出文件，否則就打印。

利用這個裝飾器，可以靈活地進行耗時統計

不設置輸出文件地址，則打印。運行結果為：

也可以輸出到文件

輸出結果為

同時在當前目錄生成了一個test.log 文件，內容為：

以上的裝飾器都是以函數形式出現的，但我們可以稍做改寫，將裝飾器以類的形式實現。

這個裝飾器類Log 上個例子里的裝飾器函數log功能是一樣的，同時，這個裝飾器類還可以作為基類被其他繼承，進一步增加功能。

原文

如何理解Python裝飾器

理解Python中的裝飾器

@makebold

@makeitalic

def say():

return “Hello”

打印出如下的輸出：

biHelloi/b

你會怎麼做？最後給出的答案是：

def makebold(fn):

def wrapped():

return “b” + fn() + “/b”

return wrapped

def makeitalic(fn):

def wrapped():

return “i” + fn() + “/i”

return wrapped

@makebold

@makeitalic

def hello():

return “hello world”

print hello() ## 返回 bihello world/i/b

現在我們來看看如何從一些最基礎的方式來理解Python的裝飾器。英文討論參考Here。

裝飾器是一個很著名的設計模式，經常被用於有切面需求的場景，較為經典的有插入日誌、性能測試、事務處理等。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量函數中與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外的功能。

1.1. 需求是怎麼來的？

裝飾器的定義很是抽象，我們來看一個小例子。

def foo():

print ‘in foo()’

foo()

這是一個很無聊的函數沒錯。但是突然有一個更無聊的人，我們稱呼他為B君，說我想看看執行這個函數用了多長時間，好吧，那麼我們可以這樣做：

import time

def foo():

start = time.clock()

print ‘in foo()’

end = time.clock()

print ‘used:’, end – start

foo()

很好，功能看起來無懈可擊。可是蛋疼的B君此刻突然不想看這個函數了，他對另一個叫foo2的函數產生了更濃厚的興趣。

怎麼辦呢？如果把以上新增加的代碼複製到foo2里，這就犯了大忌了~複製什麼的難道不是最討厭了么！而且，如果B君繼續看了其他的函數呢？

1.2. 以不變應萬變，是變也

還記得嗎，函數在Python中是一等公民，那麼我們可以考慮重新定義一個函數timeit，將foo的引用傳遞給他，然後在timeit中調用foo並進行計時，這樣，我們就達到了不改動foo定義的目的，而且，不論B君看了多少個函數，我們都不用去修改函數定義了！

import time

def foo():

print ‘in foo()’

def timeit(func):

start = time.clock()

func()

end =time.clock()

print ‘used:’, end – start

timeit(foo)

看起來邏輯上並沒有問題，一切都很美好並且運作正常！……等等，我們似乎修改了調用部分的代碼。原本我們是這樣調用的：foo()，修改以後變成了：timeit(foo)。這樣的話，如果foo在N處都被調用了，你就不得不去修改這N處的代碼。或者更極端的，考慮其中某處調用的代碼無法修改這個情況，比如：這個函數是你交給別人使用的。

1.3. 最大限度地少改動！

既然如此，我們就來想想辦法不修改調用的代碼；如果不修改調用代碼，也就意味着調用foo()需要產生調用timeit(foo)的效果。我們可以想到將timeit賦值給foo，但是timeit似乎帶有一個參數……想辦法把參數統一吧！如果timeit(foo)不是直接產生調用效果，而是返回一個與foo參數列表一致的函數的話……就很好辦了，將timeit(foo)的返回值賦值給foo，然後，調用foo()的代碼完全不用修改！

#-*- coding: UTF-8 -*-

import time

def foo():

print ‘in foo()’

# 定義一個計時器，傳入一個，並返回另一個附加了計時功能的方法

def timeit(func):

# 定義一個內嵌的包裝函數，給傳入的函數加上計時功能的包裝

def wrapper():

start = time.clock()

func()

end =time.clock()

print ‘used:’, end – start

# 將包裝後的函數返回

return wrapper

foo = timeit(foo)

foo()

這樣，一個簡易的計時器就做好了！我們只需要在定義foo以後調用foo之前，加上foo = timeit(foo)，就可以達到計時的目的，這也就是裝飾器的概念，看起來像是foo被timeit裝飾了。在在這個例子中，函數進入和退出時需要計時，這被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。與傳統編程習慣的從上往下執行方式相比較而言，像是在函數執行的流程中橫向地插入了一段邏輯。在特定的業務領域裏，能減少大量重複代碼。面向切面編程還有相當多的術語，這裡就不多做介紹，感興趣的話可以去找找相關的資料。

這個例子僅用於演示，並沒有考慮foo帶有參數和有返回值的情況，完善它的重任就交給你了：）

上面這段代碼看起來似乎已經不能再精簡了，Python於是提供了一個語法糖來降低字符輸入量。

import time

def timeit(func):

def wrapper():

start = time.clock()

func()

end =time.clock()

print ‘used:’, end – start

return wrapper

@timeit

def foo():

print ‘in foo()’

foo()

重點關注第11行的@timeit，在定義上加上這一行與另外寫foo = timeit(foo)完全等價，千萬不要以為@有另外的魔力。除了字符輸入少了一些，還有一個額外的好處：這樣看上去更有裝飾器的感覺。

——————-

要理解python的裝飾器，我們首先必須明白在Python中函數也是被視為對象。這一點很重要。先看一個例子：

def shout(word=”yes”) :

return word.capitalize()+” !”

print shout()

# 輸出 : ‘Yes !’

# 作為一個對象，你可以把函數賦給任何其他對象變量

scream = shout

# 注意我們沒有使用圓括號，因為我們不是在調用函數

# 我們把函數shout賦給scream，也就是說你可以通過scream調用shout

print scream()

# 輸出 : ‘Yes !’

# 還有，你可以刪除舊的名字shout，但是你仍然可以通過scream來訪問該函數

del shout

try :

print shout()

except NameError, e :

print e

#輸出 : “name ‘shout’ is not defined”

print scream()

# 輸出 : ‘Yes !’

我們暫且把這個話題放旁邊，我們先看看python另外一個很有意思的屬性：可以在函數中定義函數：

def talk() :

# 你可以在talk中定義另外一個函數

def whisper(word=”yes”) :

return word.lower()+”…”;

# … 並且立馬使用它

print whisper()

# 你每次調用’talk’，定義在talk裏面的whisper同樣也會被調用

talk()

# 輸出 :

# yes…

# 但是”whisper” 不會單獨存在:

try :

print whisper()

except NameError, e :

print e

#輸出 : “name ‘whisper’ is not defined”*

函數引用

從以上兩個例子我們可以得出，函數既然作為一個對象，因此：

1. 其可以被賦給其他變量

2. 其可以被定義在另外一個函數內

這也就是說，函數可以返回一個函數，看下面的例子：

def getTalk(type=”shout”) :

# 我們定義另外一個函數

def shout(word=”yes”) :

return word.capitalize()+” !”

def whisper(word=”yes”) :

return word.lower()+”…”;

# 然後我們返回其中一個

if type == “shout” :

# 我們沒有使用(),因為我們不是在調用該函數

# 我們是在返回該函數

return shout

else :

return whisper

# 然後怎麼使用呢 ?

# 把該函數賦予某個變量

talk = getTalk()

# 這裡你可以看到talk其實是一個函數對象:

print talk

#輸出 : function shout at 0xb7ea817c

# 該對象由函數返回的其中一個對象:

print talk()

# 或者你可以直接如下調用 :

print getTalk(“whisper”)()

#輸出 : yes…

還有，既然可以返回一個函數，我們可以把它作為參數傳遞給函數：

def doSomethingBefore(func) :

print “I do something before then I call the function you gave me”

print func()

doSomethingBefore(scream)

#輸出 :

#I do something before then I call the function you gave me

#Yes !

這裡你已經足夠能理解裝飾器了，其他它可被視為封裝器。也就是說，它能夠讓你在裝飾前後執行代碼而無須改變函數本身內容。

手工裝飾

那麼如何進行手動裝飾呢？

# 裝飾器是一個函數，而其參數為另外一個函數

def my_shiny_new_decorator(a_function_to_decorate) :

# 在內部定義了另外一個函數：一個封裝器。

# 這個函數將原始函數進行封裝，所以你可以在它之前或者之後執行一些代碼

def the_wrapper_around_the_original_function() :

# 放一些你希望在真正函數執行前的一些代碼

print “Before the function runs”

# 執行原始函數

a_function_to_decorate()

# 放一些你希望在原始函數執行後的一些代碼

print “After the function runs”

#在此刻，”a_function_to_decrorate”還沒有被執行，我們返回了創建的封裝函數

#封裝器包含了函數以及其前後執行的代碼，其已經準備完畢

return the_wrapper_around_the_original_function

# 現在想像下，你創建了一個你永遠也不遠再次接觸的函數

def a_stand_alone_function() :

print “I am a stand alone function, don’t you dare modify me”

a_stand_alone_function()

#輸出: I am a stand alone function, don’t you dare modify me

# 好了，你可以封裝它實現行為的擴展。可以簡單的把它丟給裝飾器

# 裝飾器將動態地把它和你要的代碼封裝起來，並且返回一個新的可用的函數。

a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)

a_stand_alone_function_decorated()

#輸出 :

#Before the function runs

#I am a stand alone function, don’t you dare modify me

#After the function runs

現在你也許要求當每次調用a_stand_alone_function時，實際調用卻是a_stand_alone_function_decorated。實現也很簡單，可以用my_shiny_new_decorator來給a_stand_alone_function重新賦值。

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)

a_stand_alone_function()

#輸出 :

#Before the function runs

#I am a stand alone function, don’t you dare modify me

#After the function runs

# And guess what, that’s EXACTLY what decorators do !

裝飾器揭秘

前面的例子，我們可以使用裝飾器的語法：

@my_shiny_new_decorator

def another_stand_alone_function() :

print “Leave me alone”

another_stand_alone_function()

#輸出 :

#Before the function runs

#Leave me alone

#After the function runs

當然你也可以累積裝飾：

def bread(func) :

def wrapper() :

print “/”””\”

func()

print “\______/”

return wrapper

def ingredients(func) :

def wrapper() :

print “#tomatoes#”

func()

print “~salad~”

return wrapper

def sandwich(food=”–ham–“) :

print food

sandwich()

#輸出 : –ham–

sandwich = bread(ingredients(sandwich))

sandwich()

#outputs :

#/”””\

# #tomatoes#

# –ham–

# ~salad~

#\______/

使用python裝飾器語法：

@bread

@ingredients

def sandwich(food=”–ham–“) :

print food

sandwich()

#輸出 :

#/”””\

# #tomatoes#

# –ham–

# ~salad~

#\______/

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/152909.html

python裝飾器領域博主的簡單介紹

本文目錄一覽：

Python之裝飾器簡介

推薦 8 個炫酷的 Python 裝飾器

「低門檻 手把手」python 裝飾器(Decorators)原理說明

如何理解Python裝飾器

相關推薦

發表回復

「低門檻手把手」python 裝飾器(Decorators)原理說明