12步輕鬆搞定python裝飾器

發表於2015-07-05

呵呵！作為一名教python的老師，我發現學生們基本上一開始很難搞定python的裝飾器，也許因為裝飾器確實很難懂。搞定裝飾器需要你瞭解一些函數語言程式設計的概念，當然還有理解在python中定義和呼叫函式相關語法的一些特點。

我沒法讓裝飾器變得簡單，但是通過一步步的剖析，我也許能夠讓你在理解裝飾器的時候更自信一點。因為裝飾器很複雜，這篇文章將會很長（自己都說很長，還敢這麼多廢話blablabla前戲就不繼續翻譯直接省略了)

1. 函式

在python中，函式通過def關鍵字、函式名和可選的引數列表定義。通過return關鍵字返回值。我們舉例來說明如何定義和呼叫一個簡單的函式：

def foo():
     return 1
foo()
1

def foo():

return 1

foo()

方法體（當然多行也是一樣的）是必須的，通過縮排來表示，在方法名的後面加上雙括號()就能夠呼叫函式

2. 作用域

在python中，函式會建立一個新的作用域。python開發者可能會說函式有自己的名稱空間，差不多一個意思。這意味著在函式內部碰到一個變數的時候函式會優先在自己的名稱空間裡面去尋找。讓我們寫一個簡單的函式看一下本地作用域和全域性作用域有什麼不同：

a_string = "This is a global variable"
def foo():
     print locals()
print globals() # doctest: +ELLIPSIS
{, 'a_string': 'This is a global variable'}
foo() # 2
{}

a_string = "This is a global variable"

def foo():

print locals()

print globals() # doctest: +ELLIPSIS

{, 'a_string': 'This is a global variable'}

foo() # 2

{}

內建的函式globals返回一個包含所有python直譯器知道的變數名稱的字典（為了乾淨和洗的白白的，我省略了python自行建立的一些變數）。在#2我呼叫了函式 foo 把函式內部本地作用域裡面的內容列印出來。我們能夠看到，函式foo有自己獨立的名稱空間，雖然暫時名稱空間裡面什麼都還沒有。

3. 變數解析規則

當然這並不是說我們在函式裡面就不能訪問外面的全域性變數。在python的作用域規則裡面，建立變數一定會一定會在當前作用域裡建立一個變數，但是訪問或者修改變數時會先在當前作用域查詢變數，沒有找到匹配變數的話會依次向上在閉合的作用域裡面進行檢視找。所以如果我們修改函式foo的實現讓它列印全域性的作用域裡的變數也是可以的：

a_string = "This is a global variable"
def foo():
     print a_string # 1
foo()
This is a global variable

a_string = "This is a global variable"

def foo():

print a_string # 1

foo()

This is a global variable

在#1處，python直譯器會嘗試查詢變數a_string，當然在函式的本地作用域裡面是找不到的，所以接著會去上層的作用域裡面去查詢。
但是另一方面，假如我們在函式內部給全域性變數賦值，結果卻和我們想的不一樣：

a_string = "This is a global variable"
def foo():
     a_string = "test" # 1
     print locals()
foo()
{'a_string': 'test'}
a_string # 2
'This is a global variable'

a_string = "This is a global variable"

def foo():

a_string = "test" # 1

print locals()

foo()

{'a_string': 'test'}

a_string # 2

'This is a global variable'

我們能夠看到，全域性變數能夠被訪問到（如果是可變資料型別(像list,dict這些)甚至能夠被更改）但是賦值不行。在函式內部的#1處，我們實際上新建立了一個區域性變數，隱藏全域性作用域中的同名變數。我們可以通過列印出區域性名稱空間中的內容得出這個結論。我們也能看到在#2處列印出來的變數a_string的值並沒有改變。

4. 變數生存週期

值得注意的一個點是，變數不僅是生存在一個個的名稱空間內，他們都有自己的生存週期，請看下面這個例子：

def foo():
     x = 1
foo()
print x # 1
Traceback (most recent call last):

NameError: name 'x' is not defined

def foo():

x = 1

foo()

print x # 1

Traceback (most recent call last):

NameError: name 'x' is not defined

#1處發生的錯誤不僅僅是因為作用域規則導致的（儘管這是丟擲了NameError的錯誤的原因）它還和python以及其它很多程式語言中函式呼叫實現的機制有關。在這個地方這個執行時間點並沒有什麼有效的語法讓我們能夠獲取變數x的值，因為它這個時候壓根不存在！函式foo的名稱空間隨著函式呼叫開始而開始，結束而銷燬。

5. 函式引數

python允許我們向函式傳遞引數，引數會變成本地變數存在於函式內部。

def foo(x):
     print locals()
foo(1)
{'x': 1}

def foo(x):

print locals()

foo(1)

{'x': 1}

在Python裡有很多的方式來定義和傳遞引數，完整版可以檢視 python官方文件。我們這裡簡略的說明一下：函式的引數可以是必須的位置引數或者是可選的命名，預設引數。

def foo(x, y=0): # 1
     return x - y
foo(3, 1) # 2
2
foo(3) # 3
3
foo() # 4
Traceback (most recent call last):

TypeError: foo() takes at least 1 argument (0 given)
foo(y=1, x=3) # 5
2

def foo(x, y=0): # 1

return x - y

foo(3, 1) # 2

foo(3) # 3

foo() # 4

Traceback (most recent call last):

TypeError: foo() takes at least 1 argument (0 given)

foo(y=1, x=3) # 5

在#1處我們定義了函式foo,它有一個位置引數x和一個命名引數y。在#2處我們能夠通過常規的方式來呼叫函式，儘管有一個命名引數，但引數依然可以通過位置傳遞給函式。在呼叫函式的時候，對於命名引數y我們也可以完全不管就像#3處所示的一樣。如果命名引數沒有接收到任何值的話，python會自動使用宣告的預設值也就是0。需要注意的是我們不能省略第一個位置引數x, 否則的話就會像#5處所示發生錯誤。

目前還算簡潔清晰吧，但是接下來可能會有點令人困惑。python支援函式呼叫時的命名引數（個人覺得應該是命名實參）。看看#5處的函式呼叫，我們傳遞的是兩個命名實參，這個時候因為有名稱標識，引數傳遞的順序也就不用在意了。

當然相反的情況也是正確的：函式的第二個形參是y，但是我們通過位置的方式傳遞值給它。在#2處的函式呼叫foo(3,1)，我們把3傳遞給了第一個引數，把1傳遞給了第二個引數，儘管第二個引數是一個命名引數。

桑不起，感覺用了好大一段才說清楚這麼一個簡單的概念：函式的引數可以有名稱和位置。這意味著在函式的定義和呼叫的時候會稍稍在理解上有點兒不同。我們可以給只定義了位置引數的函式傳遞命名引數（實參），反之亦然！如果覺得不夠可以檢視官方文件

6. 巢狀函式

Python允許建立巢狀函式。這意味著我們可以在函式裡面定義函式而且現有的作用域和變數生存週期依舊適用。

def outer():
     x = 1
     def inner():
         print x # 1
     inner() # 2

outer()
1

def outer():

x = 1

def inner():

print x # 1

inner() # 2

outer()

這個例子有一點兒複雜，但是看起來也還行。想一想在#1發生了什麼：python直譯器需找一個叫x的本地變數，查詢失敗之後會繼續在上層的作用域裡面尋找，這個上層的作用域定義在另外一個函式裡面。對函式outer來說，變數x是一個本地變數，但是如先前提到的一樣，函式inner可以訪問封閉的作用域（至少可以讀和修改）。在#2處，我們呼叫函式inner，非常重要的一點是，inner也僅僅是一個遵循python變數解析規則的變數名，python直譯器會優先在outer的作用域裡面對變數名inner查詢匹配的變數.

7. 函式是python世界裡的一級類物件

顯而易見，在python裡函式和其他東西一樣都是物件。（此處應該大聲歌唱）啊！包含變數的函式，你也並不是那麼特殊！

issubclass(int, object) # all objects in Python inherit from a common baseclass
True
def foo():
     pass
foo.__class__ # 1
<type 'function'>
issubclass(foo.__class__, object)
True

issubclass(int, object) # all objects in Python inherit from a common baseclass

True

def foo():

pass

foo.__class__ # 1

issubclass(foo.__class__, object)

True

你也許從沒有想過，你定義的函式居然會有屬性。沒辦法，函式在python裡面就是物件，和其他的東西一樣，也許這樣描述會太學院派太官方了點：在python裡，函式只是一些普通的值而已和其他的值一毛一樣。這就是說你尅一把函式想引數一樣傳遞給其他的函式或者說從函式了裡面返回函式！如果你從來沒有這麼想過，那看看下面這個例子：

def add(x, y):
     return x + y
def sub(x, y):
     return x - y
def apply(func, x, y): # 1
     return func(x, y) # 2
apply(add, 2, 1) # 3
3
apply(sub, 2, 1)
1

def add(x, y):

return x + y

def sub(x, y):

return x - y

def apply(func, x, y): # 1

return func(x, y) # 2

apply(add, 2, 1) # 3

apply(sub, 2, 1)

這個例子對你來說應該不會很奇怪。add和sub是非常普通的兩個python函式，接受兩個值，返回一個計算後的結果值。在#1處你們能看到準備接收一個函式的變數只是一個普通的變數而已，和其他變數一樣。在#2處我們呼叫傳進來的函式：“()代表著呼叫的操作並且呼叫變數包含的值。在#3處，你們也能看到傳遞函式並沒有什麼特殊的語法。” 函式的名稱只是很其他變數一樣的表識別符號而已。

你們也許看到過這樣的行為：“python把頻繁要用的操作變成函式作為引數進行使用，像通過傳遞一個函式給內建排序函式的key引數從而來自定義排序規則。那把函式當做返回值回事這樣的情況呢：

def outer():
     def inner():
         print "Inside inner"
     return inner # 1

foo = outer() #2
foo # doctest:+ELLIPSIS
<function inner at 0x>
foo()
Inside inner

def outer():

def inner():

print "Inside inner"

return inner # 1

foo = outer() #2

foo # doctest:+ELLIPSIS

foo()

Inside inner

這個例子看起來也許會更加的奇怪。在#1處我把恰好是函式識別符號的變數inner作為返回值返回出來。這並沒有什麼特殊的語法：”把函式inner返回出來，否則它根本不可能會被呼叫到。“還記得變數的生存週期嗎？每次函式outer被呼叫的時候，函式inner都會被重新定義，如果它不被當做變數返回的話，每次執行過後它將不復存在。

在#2處我們捕獲住返回值 – 函式inner，將它存在一個新的變數foo裡。我們能夠看到，當對變數foo進行求值，它確實包含函式inner，而且我們能夠對他進行呼叫。初次看起來可能會覺得有點奇怪，但是理解起來並不困難是吧。堅持住，因為奇怪的轉折馬上就要來了（嘿嘿嘿嘿，我笑的並不猥瑣！）

8. 閉包

我們先不急著定義什麼是閉包，先來看看一段程式碼，僅僅是把上一個例子簡單的調整了一下：

def outer():
     x = 1
     def inner():
         print x # 1
     return inner
foo = outer()
foo.func_closure # doctest: +ELLIPSIS
(<cell at 0x: int object at 0x>,)

def outer():

x = 1

def inner():

print x # 1

return inner

foo = outer()

foo.func_closure # doctest: +ELLIPSIS

(<cell at 0x: int object at 0x>,)

在上一個例子中我們瞭解到，inner作為一個函式被outer返回，儲存在一個變數foo，並且我們能夠對它進行呼叫foo()。不過它會正常的執行嗎？我們先來看看作用域規則。

所有的東西都在python的作用域規則下進行工作：“x是函式outer裡的一個區域性變數。當函式inner在#1處列印x的時候，python直譯器會在inner內部查詢相應的變數，當然會找不到，所以接著會到封閉作用域裡面查詢，並且會找到匹配。

但是從變數的生存週期來看，該怎麼理解呢？我們的變數x是函式outer的一個本地變數，這意味著只有當函式outer正在執行的時候才會存在。根據我們已知的python執行模式，我們沒法在函式outer返回之後繼續呼叫函式inner，在函式inner被呼叫的時候，變數x早已不復存在，可能會發生一個執行時錯誤。

萬萬沒想到，返回的函式inner居然能夠正常工作。Python支援一個叫做函式閉包的特性，用人話來講就是，巢狀定義在非全域性作用域裡面的函式能夠記住它在被定義的時候它所處的封閉名稱空間。這能夠通過檢視函式的func_closure屬性得出結論，這個屬性裡面包含封閉作用域裡面的值（只會包含被捕捉到的值，比如x，如果在outer裡面還定義了其他的值，封閉作用域裡面是不會有的)

記住，每次函式outer被呼叫的時候，函式inner都會被重新定義。現在變數x的值不會變化，所以每次返回的函式inner會是同樣的邏輯，假如我們稍微改動一下呢？

def outer(x):
     def inner():
         print x # 1
     return inner
print1 = outer(1)
print2 = outer(2)
print1()
1
print2()
2

def outer(x):

def inner():

print x # 1

return inner

print1 = outer(1)

print2 = outer(2)

print1()

print2()

從這個例子中你能夠看到閉包 – 被函式記住的封閉作用域 – 能夠被用來建立自定義的函式，本質上來說是一個硬編碼的引數。事實上我們並不是傳遞引數1或者2給函式inner，我們實際上是建立了能夠列印各種數字的各種自定義版本。

閉包單獨拿出來就是一個非常強大的功能，在某些方面，你也許會把它當做一個類似於面嚮物件的技術：outer像是給inner服務的構造器，x像一個私有變數。使用閉包的方式也有很多：你如果熟悉python內建排序方法的引數key，你說不定已經寫過一個lambda方法在排序一個列表的列表的時候基於第二個元素而不是第一個。現在你說不定也可以寫一個itemgetter方法，接收一個索引值來返回一個完美的函式，傳遞給排序函式的引數key。

不過，我們現在不會用閉包做這麼low的事(⊙o⊙)…！相反，讓我們再爽一次，寫一個高大上的裝飾器!

9. 裝飾器

裝飾器其實就是一個閉包，把一個函式當做引數然後返回一個替代版函式。我們一步步從簡到繁來瞅瞅：

def outer(some_func):
     def inner():
         print "before some_func"
         ret = some_func() # 1
         return ret + 1
     return inner
def foo():
     return 1
decorated = outer(foo) # 2
decorated()
before some_func
2

def outer(some_func):

def inner():

print "before some_func"

ret = some_func() # 1

return ret + 1

return inner

def foo():

return 1

decorated = outer(foo) # 2

decorated()

before some_func

仔細看看上面這個裝飾器的例子。們定義了一個函式outer，它只有一個some_func的引數，在他裡面我們定義了一個巢狀的函式inner。inner會列印一串字串，然後呼叫some_func，在#1處得到它的返回值。在outer每次呼叫的時候some_func的值可能會不一樣，但是不管some_func的之如何，我們都會呼叫它。最後，inner返回some_func() + 1的值 – 我們通過呼叫在#2處儲存在變數decorated裡面的函式能夠看到被列印出來的字串以及返回值2，而不是期望中呼叫函式foo得到的返回值1。

我們可以認為變數decorated是函式foo的一個裝飾版本，一個加強版本。事實上如果打算寫一個有用的裝飾器的話，我們可能會想願意用裝飾版本完全取代原先的函式foo，這樣我們總是會得到我們的”加強版“foo。想要達到這個效果，完全不需要學習新的語法，簡單地賦值給變數foo就行了：

foo = outer(foo)
foo # doctest: +ELLIPSIS
<function inner at 0x>

foo = outer(foo)

foo # doctest: +ELLIPSIS

現在，任何怎麼呼叫都不會牽扯到原先的函式foo，都會得到新的裝飾版本的foo，現在我們還是來寫一個有用的裝飾器。

想象我們有一個庫，這個庫能夠提供類似座標的物件，也許它們僅僅是一些x和y的座標對。不過可惜的是這些座標物件不支援數學運算子，而且我們也不能對原始碼進行修改，因此也就不能直接加入運算子的支援。我們將會做一系列的數學運算，所以我們想要能夠對兩個座標物件進行合適加減運算的函式，這些方法很容易就能寫出：

class Coordinate(object):
     def __init__(self, x, y):
         self.x = x
         self.y = y
     def __repr__(self):
         return "Coord: " + str(self.__dict__)
def add(a, b):
     return Coordinate(a.x + b.x, a.y + b.y)
def sub(a, b):
     return Coordinate(a.x - b.x, a.y - b.y)
one = Coordinate(100, 200)
two = Coordinate(300, 200)
add(one, two)
Coord: {'y': 400, 'x': 400}

class Coordinate(object):

def __init__(self, x, y):

self.x = x

self.y = y

def __repr__(self):

return "Coord: " + str(self.__dict__)

def add(a, b):

return Coordinate(a.x + b.x, a.y + b.y)

def sub(a, b):

return Coordinate(a.x - b.x, a.y - b.y)

one = Coordinate(100, 200)

two = Coordinate(300, 200)

add(one, two)

Coord: {'y': 400, 'x': 400}

如果不巧我們的加減函式同時也需要一些邊界檢查的行為那該怎麼辦呢？搞不好你只能夠對正的座標物件進行加減操作，任何返回的值也都應該是正的座標。所以現在的期望是這樣：

one = Coordinate(100, 200)
two = Coordinate(300, 200)
three = Coordinate(-100, -100)
sub(one, two)
Coord: {'y': 0, 'x': -200}
add(one, three)
Coord: {'y': 100, 'x': 0}

one = Coordinate(100, 200)

two = Coordinate(300, 200)

three = Coordinate(-100, -100)

sub(one, two)

Coord: {'y': 0, 'x': -200}

add(one, three)

Coord: {'y': 100, 'x': 0}

我們期望在不更改座標物件one, two, three的前提下one減去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}。與其給每個方法都加上引數和返回值邊界檢查的邏輯，我們來寫一個邊界檢查的裝飾器！

def wrapper(func):
     def checker(a, b): # 1
         if a.x < 0 or a.y < 0:
             a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
         if b.x < 0 or b.y < 0:
             b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
         ret = func(a, b)
         if ret.x < 0 or ret.y < 0:
             ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
         return ret
     return checker
add = wrapper(add)
sub = wrapper(sub)
sub(one, two)
Coord: {'y': 0, 'x': 0}
add(one, three)
Coord: {'y': 200, 'x': 100}

def wrapper(func):

def checker(a, b): # 1

if a.x < 0 or a.y < 0:

a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)

if b.x < 0 or b.y < 0:

b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)

ret = func(a, b)

if ret.x < 0 or ret.y < 0:

ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)

return ret

return checker

add = wrapper(add)

sub = wrapper(sub)

sub(one, two)

Coord: {'y': 0, 'x': 0}

add(one, three)

Coord: {'y': 200, 'x': 100}

這個裝飾器能想先前的裝飾器例子一樣進行工作，返回一個經過修改的函式，但是在這個例子中，它能夠對函式的輸入引數和返回值做一些非常有用的檢查和格式化工作，將負值的x和 y替換成0。

顯而易見，通過這樣的方式，我們的程式碼變得更加簡潔：將邊界檢查的邏輯隔離到單獨的方法中，然後通過裝飾器包裝的方式應用到我們需要進行檢查的地方。另外一種方式通過在計算方法的開始處和返回值之前呼叫邊界檢查的方法也能夠達到同樣的目的。但是不可置否的是，使用裝飾器能夠讓我們以最少的程式碼量達到座標邊界檢查的目的。事實上，如果我們是在裝飾自己定義的方法的話，我們能夠讓裝飾器應用的更加有逼格。

10. 使用 @ 識別符號將裝飾器應用到函式

Python2.4支援使用識別符號@將裝飾器應用在函式上，只需要在函式的定義前加上@和裝飾器的名稱。在上一節的例子裡我們是將原本的方法用裝飾後的方法代替:

add = wrapper(add)

1	add = wrapper(add)

這種方式能夠在任何時候對任意方法進行包裝。但是如果我們自定義一個方法，我們可以使用@進行裝飾：

@wrapper
 def add(a, b):
     return Coordinate(a.x + b.x, a.y + b.y)

@wrapper

def add(a, b):

return Coordinate(a.x + b.x, a.y + b.y)

需要明白的是，這樣的做法和先前簡單的用包裝方法替代原有方法是一毛一樣的， python只是加了一些語法糖讓裝飾的行為更加的直接明確和優雅一點。

11. *args and **kwargs

我們已經完成了一個有用的裝飾器，但是由於硬編碼的原因它只能應用在一類具體的方法上，這類方法接收兩個引數，傳遞給閉包捕獲的函式。如果我們想實現一個能夠應用在任何方法上的裝飾器要怎麼做呢？再比如，如果我們要實現一個能應用在任何方法上的類似於計數器的裝飾器，不需要改變原有方法的任何邏輯。這意味著裝飾器能夠接受擁有任何簽名的函式作為自己的被裝飾方法，同時能夠用傳遞給它的引數對被裝飾的方法進行呼叫。

非常巧合的是Python正好有支援這個特性的語法。可以閱讀 Python Tutorial 獲取更多的細節。當定義函式的時候使用了*，意味著那些通過位置傳遞的引數將會被放在帶有*字首的變數中，所以：

def one(*args):
     print args # 1
one()
()
one(1, 2, 3)
(1, 2, 3)
def two(x, y, *args): # 2
     print x, y, args
two('a', 'b', 'c')
a b ('c',)

def one(*args):

print args # 1

one()

()

one(1, 2, 3)

(1, 2, 3)

def two(x, y, *args): # 2

print x, y, args

two('a', 'b', 'c')

a b ('c',)

第一個函式one只是簡單地講任何傳遞過來的位置引數全部列印出來而已，你們能夠看到，在程式碼#1處我們只是引用了函式內的變數args, *args僅僅只是用在函式定義的時候用來表示位置引數應該儲存在變數args裡面。Python允許我們制定一些引數並且通過args捕獲其他所有剩餘的未被捕捉的位置引數，就像#2處所示的那樣。
*操作符在函式被呼叫的時候也能使用。意義基本是一樣的。當呼叫一個函式的時候，一個用*標誌的變數意思是變數裡面的內容需要被提取出來然後當做位置引數被使用。同樣的，來看個例子：

def add(x, y):
     return x + y
lst = [1,2]
add(lst[0], lst[1]) # 1
3
add(*lst) # 2
3

def add(x, y):

return x + y

lst = [1,2]

add(lst[0], lst[1]) # 1

add(*lst) # 2

#1處的程式碼和#2處的程式碼所做的事情其實是一樣的，在#2處，python為我們所做的事其實也可以手動完成。這也不是什麼壞事，*args要麼是表示呼叫方法大的時候額外的引數可以從一個可迭代列表中取得，要麼就是定義方法的時候標誌這個方法能夠接受任意的位置引數。
接下來提到的**會稍多更復雜一點，**代表著鍵值對的餐宿字典，和*所代表的意義相差無幾，也很簡單對不對：

def foo(**kwargs):
     print kwargs
foo()
{}
foo(x=1, y=2)
{'y': 2, 'x': 1}

def foo(**kwargs):

print kwargs

foo()

{}

foo(x=1, y=2)

{'y': 2, 'x': 1}

當我們定義一個函式的時候，我們能夠用**kwargs來表明，所有未被捕獲的關鍵字引數都應該儲存在kwargs的字典中。如前所訴，argshe kwargs並不是python語法的一部分，但在定義函式的時候，使用這樣的變數名算是一個不成文的約定。和*一樣，我們同樣可以在定義或者呼叫函式的時候使用**。

dct = {'x': 1, 'y': 2}
def bar(x, y):
     return x + y
bar(**dct)
3

dct = {'x': 1, 'y': 2}

def bar(x, y):

return x + y

bar(**dct)

12. 更通用的裝飾器

有了這招新的技能，我們隨隨便便就可以寫一個能夠記錄下傳遞給函式引數的裝飾器了。先來個簡單地把日誌輸出到介面的例子：

def logger(func):
     def inner(*args, **kwargs): #1
         print "Arguments were: %s, %s" % (args, kwargs)
         return func(*args, **kwargs) #2
     return inner

def logger(func):

def inner(*args, **kwargs): #1

print "Arguments were: %s, %s" % (args, kwargs)

return func(*args, **kwargs) #2

return inner

請注意我們的函式inner，它能夠接受任意數量和型別的引數並把它們傳遞給被包裝的方法，這讓我們能夠用這個裝飾器來裝飾任何方法。

@logger
 def foo1(x, y=1):
     return x * y
@logger
 def foo2():
     return 2
foo1(5, 4)
Arguments were: (5, 4), {}
20
foo1(1)
Arguments were: (1,), {}
1
foo2()
Arguments were: (), {}
2

@logger

def foo1(x, y=1):

return x * y

@logger

def foo2():

return 2

foo1(5, 4)

Arguments were: (5, 4), {}

foo1(1)

Arguments were: (1,), {}

foo2()

Arguments were: (), {}

隨便呼叫我們定義的哪個方法，相應的日誌也會列印到輸出視窗，和我們預期的一樣。

簡單 12 步理解 Python 裝飾器
2016-05-12
Python
Jenkins部署安裝，輕鬆三步搞定
2021-01-03
Jenkins
辦公室革命，教你輕鬆搞定輕鬆玩轉Excel
2016-04-12
Excel
一步步教你理解Python裝飾器
2016-07-18
Python
如何排查DNS解析出錯？這四步輕鬆搞定
2022-05-27
DNS
python裝飾器2：類裝飾器
2019-01-01
Python
python基礎學習12—-裝飾器
2018-09-09
Python
Python裝飾器探究——裝飾器引數
2016-12-19
Python
Python 裝飾器
2019-06-24
Python
Python裝飾器
2021-02-15
Python
裝飾器 python
2018-01-06
Python
Python 裝飾器裝飾類中的方法
2017-04-17
Python
Python裝飾器模式
2022-05-13
Python模式
python的裝飾器
2018-08-18
Python
1.5.3 Python裝飾器
2019-01-19
Python
Python 裝飾器（一）
2018-09-27
Python
Python 裝飾器原理
2023-02-06
Python
乾貨 | 裝置快速上雲，輕鬆搞定裝置與雲端通訊
2019-09-29
Apache Storm系列之二（輕鬆搞定 Storm 安裝與啟動）
2018-10-21
ApacheORM
輕鬆搞定專案流程自動化
2020-04-08
草根學Python（十六）裝飾器（逐步演化成裝飾器）
2018-01-11
Python
python 之裝飾器（decorator）
2019-12-17
Python
Python深入05 裝飾器
2019-11-29
Python
Python裝飾器詳解
2020-12-02
Python
Python中的裝飾器
2022-03-26
Python
【Python】淺談裝飾器
2017-05-01
Python
初識Python裝飾器
2017-06-20
Python
Python 裝飾器的理解
2016-07-06
Python
python裝飾器介紹
2017-08-07
Python
淺談Python裝飾器
2014-03-30
Python
如何偽裝自己的IP地址？兔子軟體IP代理輕鬆搞定
2020-06-18
教你8步輕鬆上手kafka
2022-12-27
Kafka
3D 穿梭效果？使用 CSS 輕鬆搞定
2021-11-10
3DCSS
Android輕鬆搞定Dialog提示動畫效果
2016-09-11
Android動畫
Java設計模式12：裝飾器模式
2015-10-25
Java設計模式
Python3 裝飾器解析
2020-07-18
Python
Python 語法之裝飾器
2019-12-19
Python
Python裝飾器高階用法
2019-02-24
Python

12步輕鬆搞定python裝飾器

相關文章