python中maker_python中的裝飾器

裝飾器

在stackoverflow上看到一篇講python中decorator的回答，實在是受益匪淺，決定将其翻譯成中文，分享給大家。

函數是對象

在python中，函數是對象。

以一個簡單的函數為例。def shout(word="yes"):

return word.capitalize()+"!"print(shout())

會輸出Yes!

作為對象，是可以指派給另外一個變量的。scream = shoutprint(scream())

輸出和上面是一樣的。

更有意思的是，python中的函數是可以定義在另外一個函數内部的。def talk():

def whisper(word="yes"):

return word.lower()+"..."

print(whisper())

talk()

輸出yes...

函數引用

通過上面的例子可以看到，函數是對象，是以可以被指派給另外一個變量

可以在另外一個函數中被定義。

這也就意味着，一個函數可以将另外一個函數作為傳回值。def getTalk(kind="shout"):

def shout(word="yes"):

return word.capitalize()+"!"

def whisper(word="yes"):

return word.lower()+"..."

if kind == "shout":        return shout    else:        return whisper

talk = getTalk()print talk    # 輸出 print talk()  # 輸出 Yes!print getTalk("whisper")()  # 輸出yes...

如果能夠傳回一個函數，也可以将一個函數作為參數傳入，複用上面的scream函數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):

# 定義一個wrapper

def the_wrapper_around_the_original_function():

# 在傳入的函數被執行前執行

print("Before the function runs")

a_function_to_decorate()        # 在傳入的函數被執行後執行

print("After the function runs")    return the_wrapper_around_the_original_functiondef 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 mea_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就會被調用，這很簡單，隻需要用a_stand_alone_function_decorated傳回的函數覆寫之前的a_stand_alone_function就可以了。

使用裝飾器@my_shiny_new_decoratordef another_stand_alone_function():

print("Leave me alone")

another_stand_alone_function()

# 輸出#Before the function runs#Leave me alone#After the function runs

是的，就是這麼簡單。 @decorator就是下面代碼的簡寫another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)

像下面的代碼def bread(func):

def wrapper():

print("''''''\>")

func()

print("")    return wrapperdef ingredients(func):

def wrapper():

print("#tomatoes#")

func()

print("~salad~")    return wrapperdef sandwich(food="--ham--"):

print(food)

sandwich()#outputs: --ham--sandwich = bread(ingredients(sandwich))

sandwich()

就可以寫成@[email protected] sandwich(food="--ham--"):

print(food)

sandwich()#outputs:#''''''\># #tomatoes## --ham--# ~salad~#

裝飾器的順序很重要，如果改變上面的順序，函數的行為就被改變了@[email protected] sandwich(food="--ham--"):

print(food)

strange_sandwich()#outputs:##tomatoes##''''''\># --ham--## ~salad~

還是一個裝飾器的例子# The decorator to make it bolddef makebold(fn):

# The new function the decorator returns

def wrapper():

# Insertion of some code before and after

return "

" + fn() + "

"

return wrapper# The decorator to make it italicdef makeitalic(fn):

# The new function the decorator returns

def wrapper():

# Insertion of some code before and after

return "" + fn() + ""

return [email protected]@makeitalicdef say():

return "hello"print(say())#outputs: 

hello

# 等同于下面的函數 def say():

return "hello"say = makebold(makeitalic(say))

print(say())#outputs: 

hello

裝飾器更進階的應用

向被裝飾的函數傳遞參數def a_decorator_passing_arguments(function_to_decorate):

def a_wrapper_accepting_arguments(arg1, arg2):

print("I got args! Look: {0}, {1}".format(arg1, arg2))

function_to_decorate(arg1, arg2)    return a_wrapper_accepting_arguments# 因為最終被調用是被裝飾器傳回的函數，即wrapper，# 是以将參數傳遞給wrapper會将這些參數傳遞給被裝飾的函數@a_decorator_passing_argumentsdef print_full_name(first_name, last_name):

print("My name is {0} {1}".format(first_name, last_name))

print_full_name("Peter", "Venkman")# outputs:#I got args! Look: Peter Venkman#My name is Peter Venkman

裝飾方法

python中方法和函數是一樣的。唯一不同的是，方法期望傳入的第一個參數是目前的對象(self)。

也就是說裝飾方法和裝飾函數沒有差異，隻需要在裝飾方法的時候将第一個參數考慮進去就行def method_friendly_decorator(method_to_decorate):    def wrapper(self, lie):

lie = lie - 3

return method_to_decorate(self, lie)    return wrapperclass Lucy(object):

def __init__(self):        self.age = 32

@method_friendly_decorator    def sayYourAge(self, lie):

print("I am {0}, what did you think?".format(self.age + lie))

l = Lucy()

l.sayYourAge(-3)#outputs: I am 26, what did you think?

如果試圖些一個通用的裝飾器，可以用*args, **kwargsdef a_decorator_passing_arbitrary_arguments(function_to_decorate):

# The wrapper accepts any arguments

def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):

print("Do I have args?:")

print(args)

print(kwargs)        # Then you unpack the arguments, here *args, **kwargs

# If you are not familiar with unpacking, check:        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/

function_to_decorate(*args, **kwargs)    return [email protected]_decorator_passing_arbitrary_argumentsdef function_with_no_argument():

print("Python is cool, no argument here.")

function_with_no_argument()#outputs#Do I have args?:#()#{}#Python is cool, no argument [email protected]_decorator_passing_arbitrary_argumentsdef function_with_arguments(a, b, c):

print(a, b, c)

function_with_arguments(1,2,3)#outputs#Do I have args?:#(1, 2, 3)#{}#1 2 3 @a_decorator_passing_arbitrary_argumentsdef function_with_named_arguments(a, b, c, platypus="Why not ?"):

print("Do {0}, {1} and {2} like platypus? {3}".format(a, b, c, platypus))

function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!")#outputs#Do I have args ? :#('Bill', 'Linus', 'Steve')#{'platypus': 'Indeed!'}#Do Bill, Linus and Steve like platypus? Indeed!class Mary(object):

def __init__(self):

self.age = 31    @a_decorator_passing_arbitrary_arguments

def sayYourAge(self, lie=-3):

# You can now add a default value

print("I am {0}, what did you think?".format(self.age + lie))

m = Mary()

m.sayYourAge()#outputs# Do I have args?:#(<__main__.mary>,)#{}#I am 28, what did you think?

向裝飾器傳遞參數

那麼問題來了，怎麼向裝飾器傳遞參數呢？

這有點讓人撓頭，因為裝飾器必須接受一個函數作為參數。

是以可以直接向裝飾器傳遞參數。

回想一下之前的代碼# Decorators are ORDINARY functionsdef my_decorator(func):

print("I am an ordinary function")    def wrapper():

print("I am function returned by the decorator")

func()    return wrapper# Therefore, you can call it without any "@"def lazy_function():

print("zzzzzzzz")

decorated_function = my_decorator(lazy_function)#outputs: I am an ordinary function# It outputs "I am an ordinary function", because that’s just what you do:# calling a function. Nothing [email protected]_decoratordef lazy_function():

print("zzzzzzzz")#outputs: I am an ordinary function

這兩個是一樣的。my_decorator被調用了。

當寫下@my_decorator時，python會調用被标注為my_decorator的函數def decorator_maker():

print("I make decorators! I am executed only once: "

"when you make me create a decorator.")    def my_decorator(func):

print("I am a decorator! I am executed only when you decorate a function.")        def wrapped():

print("I am the wrapper around the decorated function. "                  "I am called when you call the decorated function. "

"As the wrapper, I return the RESULT of the decorated function.")            return func()

print("As the decorator, I return the wrapped function.")        return wrapped

print("As a decorator maker, I return a decorator")    return my_decorator# Let’s create a decorator. It’s just a new function after all.new_decorator = decorator_maker()

#outputs:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator# Then we decorate the functiondef decorated_function():

print("I am the decorated function.")

decorated_function = new_decorator(decorated_function)#outputs:#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function# Let’s call the function:decorated_function()#outputs:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

将代碼中的中間變量去掉試試。def decorated_function():

print("I am the decorated function.")

decorated_function = decorator_maker()(decorated_function)#outputs:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function.# Finally:decorated_function()

#outputs:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

再簡化一次代碼@decorator_maker()def decorated_function():

print("I am the decorated function.")#outputs:#I make decorators! I am executed only once: when you make me create a decorator.#As a decorator maker, I return a decorator#I am a decorator! I am executed only when you decorate a function.#As the decorator, I return the wrapped function.#Eventually: decorated_function()

#outputs:#I am the wrapper around the decorated function. I am called when you call the decorated function.#As the wrapper, I return the RESULT of the decorated function.#I am the decorated function.

回到之前的問題，如果我們能夠随時生成裝飾器，我們也能向那個生成的裝飾器傳遞參數。def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):

print("I make decorators! And I accept arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))    def my_decorator(func):

# The ability to pass arguments here is a gift from closures.

# If you are not comfortable with closures, you can assume it’s ok,

# or read: http://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python

print("I am the decorator. Somehow you passed me arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))        # Don't confuse decorator arguments and function arguments!

def wrapped(function_arg1, function_arg2) :

print("I am the wrapper around the decorated function.\n"

"I can access all the variables\n"

"\t- from the decorator: {0} {1}\n"

"\t- from the function call: {2} {3}\n"

"Then I can pass them to the decorated function"

.format(decorator_arg1, decorator_arg2,                          function_arg1, function_arg2))            return func(function_arg1, function_arg2)        return wrapped    return [email protected]_maker_with_arguments("Leonard", "Sheldon")def decorated_function_with_arguments(function_arg1, function_arg2):

print("I am the decorated function and only knows about my arguments: {0}"

" {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments("Rajesh", "Howard")#outputs:#I make decorators! And I accept arguments: Leonard Sheldon#I am the decorator. Somehow you passed me arguments: Leonard Sheldon#I am the wrapper around the decorated function. #I can access all the variables #   - from the decorator: Leonard Sheldon #   - from the function call: Rajesh Howard #Then I can pass them to the decorated function#I am the decorated function and only knows about my arguments: Rajesh Howard

下面這個就是帶參數的裝飾器c1 = "Penny"c2 = "Leslie"@decorator_maker_with_arguments("Leonard", c1)def decorated_function_with_arguments(function_arg1, function_arg2):

print("I am the decorated function and only knows about my arguments:"

" {0} {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments(c2, "Howard")#outputs:#I make decorators! And I accept arguments: Leonard Penny#I am the decorator. Somehow you passed me arguments: Leonard Penny#I am the wrapper around the decorated function. #I can access all the variables #   - from the decorator: Leonard Penny #   - from the function call: Leslie Howard #Then I can pass them to the decorated function#I am the decorated function and only knows about my arguments: Leslie Howard

用上面的方法可以向裝飾器傳遞參數，也可以用 *args, **kwargs這樣的參數形式。

但是要記住，這樣的動态方法隻能被使用一次，就是導入這個腳本的時候，後面不能再動态使用。

裝飾一個裝飾器

看下面的裝飾器def decorator_with_args(decorator_to_enhance):

"""

This function is supposed to be used as a decorator.

It must decorate an other function, that is intended to be used as a decorator.

Take a cup of coffee.

It will allow any decorator to accept an arbitrary number of arguments,

saving you the headache to remember how to do that every time.

"""

# We use the same trick we did to pass arguments

def decorator_maker(*args, **kwargs):

# We create on the fly a decorator that accepts only a function

# but keeps the passed arguments from the maker.

def decorator_wrapper(func):

# We return the result of the original decorator, which, after all,

# IS JUST AN ORDINARY FUNCTION (which returns a function).

# Only pitfall: the decorator must have this specific signature or it won't work:

return decorator_to_enhance(func, *args, **kwargs)        return decorator_wrapper    return decorator_maker

他應該這樣使用# You create the function you will use as a decorator. And stick a decorator on it :-)# Don't forget, the signature is "decorator(func, *args, **kwargs)"@decorator_with_args def decorated_decorator(func, *args, **kwargs):

def wrapper(function_arg1, function_arg2):

print("Decorated with {0} {1}".format(args, kwargs))        return func(function_arg1, function_arg2)    return wrapper# Then you decorate the functions you wish with your brand new decorated [email protected]_decorator(42, 404, 1024)def decorated_function(function_arg1, function_arg2):

print("Hello {0} {1}".format(function_arg1, function_arg2))

decorated_function("Universe and", "everything")#outputs:#Decorated with (42, 404, 1024) {}#Hello Universe and everything# Whoooot!

最佳實踐裝飾器在python2.4後被引入，使用的時候确認版本支援。

使用裝飾器會增加函數調用的時間。

被裝飾的函數不能取消裝飾

裝飾器使得代碼更加難以調試

注意，使用裝飾器會會有一些副作用，被裝飾的函數其實已經是另外一個函數了。

為了消除這個副作用，可以使用functools.wraps這個方法。看下面的例子。# For debugging, the stacktrace prints you the function __name__def foo():

print("foo")

print(foo.__name__)#outputs: foo# With a decorator, it gets messy    def bar(func):

def wrapper():

print("bar")        return func()    return [email protected] foo():

print("foo")

print(foo.__name__)#outputs: wrapper# "functools" can help for thatimport functoolsdef bar(func):

# We say that "wrapper", is wrapping "func"

# and the magic begins    @functools.wraps(func)

def wrapper():

print("bar")        return func()    return [email protected] foo():

print("foo")

print(foo.__name__)#outputs: foo

實際使用

裝飾器可以在很多場景下使用。

比如倒入某個外部庫的時候，可以使用裝飾器擴充庫中函數的行為。

或者在debug的時候使用。def benchmark(func):

"""

A decorator that prints the time a function takes    to execute.

"""

import time    def wrapper(*args, **kwargs):

t = time.clock()

res = func(*args, **kwargs)

print("{0} {1}".format(func.__name__, time.clock()-t))        return res    return wrapperdef logging(func):

"""

A decorator that logs the activity of the script.    (it actually just prints it, but it could be logging!)

"""

def wrapper(*args, **kwargs):

res = func(*args, **kwargs)

print("{0} {1} {2}".format(func.__name__, args, kwargs))        return res    return wrapperdef counter(func):

"""

A decorator that counts and prints the number of times a function has been executed

"""

def wrapper(*args, **kwargs):

wrapper.count = wrapper.count + 1

res = func(*args, **kwargs)

print("{0} has been used: {1}x".format(func.__name__, wrapper.count))        return res

wrapper.count = 0

return [email protected]@[email protected] reverse_string(string):

return str(reversed(string))

print(reverse_string("Able was I ere I saw Elba"))

print(reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!"))#outputs:#reverse_string ('Able was I ere I saw Elba',) {}#wrapper 0.0#wrapper has been used: 1x#ablE was I ere I saw elbA#reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {}#wrapper 0.0#wrapper has been used: 2x#!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A

使用裝飾器可以少寫很多重複的代碼@[email protected]@loggingdef get_random_futurama_quote():

from urllib import urlopen

result = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()    try:

value = result.split("

")[1].split("")[0]        return value.strip()    except:        return "No, I'm ... doesn't!"print(get_random_futurama_quote())

print(get_random_futurama_quote())#outputs:#get_random_futurama_quote () {}#wrapper 0.02#wrapper has been used: 1x#The laws of science be a harsh mistress.#get_random_futurama_quote () {}#wrapper 0.01#wrapper has been used: 2x#Curse you, merciful Poseidon!

python提供了很多的内在裝飾器，如property,staticmethod等等。

還有一些其它的庫也用到了裝飾器Django用裝飾器來管理緩存和視圖函數的權限

Twisted用裝飾器來僞造内聯異步調用

作者：大蟒傳奇

連結：https://www.jianshu.com/p/954736037176