pythonwraps
① 如何理解python裝飾器
簡單來講，可以不嚴謹地把Python的裝飾器看做一個包裝函數的函數。
比如，有一個函數：
def func():
print 'func() run.'
if '__main__' == __name__:
func()
運行後將輸出:
func() run.
現在需要在函數運行前後列印一條日誌, 但是又不希望或者沒有許可權修改函數內部的結構, 就可以用到裝飾器(decorator):
def log(function):
def wrapper(*args, **kwargs):
print 'before function [%s()] run.' % function.__name__
rst = function(*args, **kwargs)
print 'after function [%s()] run.' % function.__name__
return rst
return wrapper
@log
def func():
print 'func() run.'
if '__main__' == __name__:
func()
對於原來的函數"func()"並沒有做修改,而是給其使用了裝飾器log,運行後的輸出為:
before function [func()] run.
func() run.
after function [func()] run.
把"@log"放到func()函數定義的地方,相當於執行了如下語句:
func = log(func)
因為log()返回了一個函數, 所以原本的func指向了log()返回的函數wrapper。wrapper的參數列表為(*args, **kwargs), 所以其可以接受所有的參數調用, 在wrapper中,先列印了一行
'before function [%s()] run.' % function.__name__
(在Python中函數也是對象,函數的__name__是它的名字),然後執行了原來的函數並記錄了返回值,在輸出
'after function [%s()] run.' % function.__name__
後返回了函數的執行結果。
如果decorator本身需要傳入參數，那就需要編寫一個返回decorator的decorator。比如在Flask中:
@app.route('/')
def index():
return 'hello, world!'
實現如下:
import functools
def log(text=''):
def decorator(function):
@functools.wraps(function)
def wrapper(*args, **kwargs):
print 'before function [%s()] run, text: [%s].' % (function.__name__, text)
rst = function(*args, **kwargs)
print 'after function [%s()] run, text: [%s].' % (function.__name__, text)
return rst
return wrapper
return decorator
@log('log text')
def func():
print 'func() run.'
if '__main__' == __name__:
func()
輸出如下:
before function [func()] run, text: [log text].
func() run.
after function [func()] run, text: [log text].
最後腦洞小開一下, 有沒有辦法實現既支持不帶參數(如log), 又支持帶參數(如log('text'))的decorator嗎?
import functools
def log(argument):
if not callable(argument):
def decorator(function):
@functools.wraps(function)
def wrapper(*args, **kwargs):
print 'before function [%s()] run, text: [%s].' % (function.__name__, text)
rst = function(*args, **kwargs)
print 'after function [%s()] run, text: [%s].' % (function.__name__, text)
return rst
return wrapper
return decorator
def wrapper(*args, **kwargs):
print 'before function [%s()] run.' % function.__name__
rst = argument(*args, **kwargs)
print 'after function [%s()] run.' % function.__name__
return rst
return wrapper
② 關於python裝飾器的wapper函數的作用
一層層地裝飾上去，如果不分成多個嵌套函數就無法傳遞參數了
裝飾器
在代碼運行期間動態增加功能的方式，稱之為「裝飾器」（Decorator）。本質上，decorator就是一個返回函數的高階函數。關鍵字wrapper
[python] view plain
</pre><pre name="code" class="python">>>>def now():
print ('2014-12-10')
#定義裝飾器
>>>def log(func):
@functools.wraps(func) #防止函數的名字被改變
def wrapper(*s,**kw):
print('call %s()'%func.__name__)
return func(*s,**kw)
return wrapper
>>>@log
defmmm(x,y):
print(x+y)
#調用裝飾器
>>>mmm
<functionmmm at 0x02C44660>
>>>mmm.__name__
'mmm'
>>>now.__name__
'wapper'
>>>@log
defnow(x,y):
print('d')
>>>now(1,4)
callnow()
d
③ python裝飾器有什麼用
先來個形象比方
內褲可以用來遮羞，但是到了冬天它沒法為我們防風禦寒，聰明的人們發明了長褲，有了長褲後寶寶再也不冷了，裝飾器就像我們這里說的長褲，在不影響內褲作用的前提下，給我們的身子提供了保暖的功效。
再回到我們的主題
裝飾器本質上是一個Python函數，它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數對象。它經常用於有切面需求的場景，比如：插入日誌、性能測試、事務處理、緩存、許可權校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外的功能。
先來看一個簡單例子：
def foo():
print('i am foo')
現在有一個新的需求，希望可以記錄下函數的執行日誌，於是在代碼中添加日誌代碼：
def foo():
print('i am foo')
logging.info("foo is running")
bar()、bar2()也有類似的需求，怎麼做？再寫一個logging在bar函數里？這樣就造成大量雷同的代碼，為了減少重復寫代碼，我們可以這樣做，重新定義一個函數：專門處理日誌 ，日誌處理完之後再執行真正的業務代碼
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()def bar():
print('i am bar')use_logging(bar)
邏輯上不難理解，
但是這樣的話，我們每次都要將一個函數作為參數傳遞給use_logging函數。而且這種方式已經破壞了原有的代碼邏輯結構，之前執行業務邏輯時，執行運行bar()，但是現在不得不改成use_logging(bar)。那麼有沒有更好的方式的呢？當然有，答案就是裝飾器。
簡單裝飾器
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapperdef bar():
print('i am bar')bar = use_logging(bar)bar()
函數use_logging就是裝飾器，它把執行真正業務方法的func包裹在函數裡面，看起來像bar被use_logging裝飾了。在這個例子中，函數進入和退出時
，被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。
@符號是裝飾器的語法糖，在定義函數的時候使用，避免再一次賦值操作
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper@use_loggingdef foo():
print("i am foo")@use_loggingdef bar():
print("i am bar")bar()
如上所示，這樣我們就可以省去bar =
use_logging(bar)這一句了，直接調用bar()即可得到想要的結果。如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不用重復修改函數或者增加新的封裝。這樣，我們就提高了程序的可重復利用性，並增加了程序的可讀性。
裝飾器在Python使用如此方便都要歸因於Python的函數能像普通的對象一樣能作為參數傳遞給其他函數，可以被賦值給其他變數，可以作為返回值，可以被定義在另外一個函數內。
帶參數的裝飾器
裝飾器還有更大的靈活性，例如帶參數的裝飾器：在上面的裝飾器調用中，比如@use_logging，該裝飾器唯一的參數就是執行業務的函數。裝飾器的語法允許我們在調用時，提供其它參數，比如@decorator(a)。這樣，就為裝飾器的編寫和使用提供了更大的靈活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
return decorator@use_logging(level="warn")def foo(name='foo'):
print("i am %s" % name)foo()
上面的use_logging是允許帶參數的裝飾器。它實際上是對原有裝飾器的一個函數封裝，並返回一個裝飾器。我們可以將它理解為一個含有參數的閉包。當我
們使用@use_logging(level="warn")調用的時候，Python能夠發現這一層的封裝，並把參數傳遞到裝飾器的環境中。
類裝飾器
再來看看類裝飾器，相比函數裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器還可以依靠類內部的\_\_call\_\_方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。
class Foo(object):
def __init__(self, func):
self._func = func
def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')
@Foo
def bar():
print ('bar')
bar()
functools.wraps
使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、__name__、參數列表，先看例子：
裝飾器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
函數
@loggeddef f(x):
"""does some math"""
return x + x * x
該函數完成等價於：
def f(x):
"""does some math"""
return x + x * xf = logged(f)
不難發現，函數f被with_logging取代了，當然它的docstring，__name__就是變成了with_logging函數的信息了。
print f.__name__ # prints 'with_logging'print f.__doc__ # prints None
這個問題就比較嚴重的，好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器函數中，這使得裝飾器函數也有和原函數一樣的元信息了。
from functools import wrapsdef logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging@loggeddef f(x):
"""does some math"""
return x + x * xprint f.__name__ # prints 'f'print f.__doc__ # prints 'does some math'
內置裝飾器
@staticmathod、@classmethod、@property
裝飾器的順序
@a@b@cdef f ():
等效於
f = a(b(c(f)))
④ python 高階函數有哪些
1、高階函數
變數可以指向函數，函數的參數可以接收變數，那麼函數可以接收另一個函數作為參數，這種函數稱為高階函數。
(1)把函數作為實參
(2)把函數作為返回值
2、系統的內置高階函數
(1)map函數：接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，並且把結果作為新的列表返回
(2)rece函數：把一個函數作用到一個序列上，這個函數必須接收兩個參數，rece把結果和序列的下一個元素做累積計算
(3)filter函數：也接收一個函數和一個序列，和map函數不同的是，filter函數把傳入的函數依次作用於每個元素，然後返回返回值是True的元素
(4)sorted函數：排序函數
把用戶名按照首字母不區分大小寫排序
(5)sorted()函數按照關鍵字排序
關鍵字：商品個數
(6)sorted()函數按照關鍵字排序，用鍵值來查找
(7)lambda匿名函數：有時候傳參數時不需要顯示自定義的函數，直接傳入匿名函數更方便；冒號前面的x,y表示函數參數，匿名函數不需要擔心函數名的沖突，匿名函數也是一個函數對象，可以把匿名函數賦值給一個變數，再利用變數來調用函數，匿名函數也可以作為返回值返回
3、高階函數的應用：
(1)sorted函數：
(2)sorted函數默認是從小到大排序
4、裝飾器
裝飾器就是用來裝飾函數的：想要增加原有函數的功能，但是不希望修改原有函數的定義，在代碼運行期間動態增加功能的方式
(1)此裝飾器的功能：計算函數的運行時間
import functools
@functools.wraps(f) ##保留原有函數的屬性
運行結果：
(2)此裝飾器的功能：用戶登錄認證
運行結果：
(3)此裝飾器的功能：認證用戶的同時，顯示用戶的轉賬金額
import inspect
inspect.getcallargs()將傳的參數封裝為一個字典，字典的key值是形式參數，value值是實參
(4)此裝飾器的功能：確保收到的每個參數都是整數，是整數就求和，否則拋出錯誤
(5)此裝飾器的功能：給裝飾器傳參數，是整數和浮點數就求和
python學習網，大量的免費python視頻教程，歡迎在線學習！
⑤ Python 使用wraps和不使用wraps的裝飾器的區別
@deco def my(): # your code list python 會解釋成：my = deco(my) 所以你實際上外面調用 my()函數時，調用的是deco 裡面的wrapfunc()，返回值就是 wrapfunc()的返回值，即"return times"
⑥ 如何理解Python裝飾器
裝飾器本質上是一個Python函數，它可以讓其他函數在不需要做任何代碼變動的前提下增加額外功能，裝飾器的返回值也是一個函數對象。它經常用於有切面需求的場景，比如：插入日誌、性能測試、事務處理、緩存、許可權校驗等場景。裝飾器是解決這類問題的絕佳設計，有了裝飾器，我們就可以抽離出大量與函數功能本身無關的雷同代碼並繼續重用。概括的講，裝飾器的作用就是為已經存在的對象添加額外的功能。
先來看一個簡單例子：
def foo():
print('i am foo')
現在有一個新的需求，希望可以記錄下函數的執行日誌，於是在代碼中添加日誌代碼：
def foo():
print('i am foo')
logging.info("foo is running")
bar()、bar2()也有類似的需求，怎麼做？再寫一個logging在bar函數里？這樣就造成大量雷同的代碼，為了減少重復寫代碼，我們可以這樣做，重新定義一個函數：專門處理日誌 ，日誌處理完之後再執行真正的業務代碼
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()
def bar():
print('i am bar')
use_logging(bar)
邏輯上不難理解，
但是這樣的話，我們每次都要將一個函數作為參數傳遞給use_logging函數。而且這種方式已經破壞了原有的代碼邏輯結構，之前執行業務邏輯時，執行運行bar()，但是現在不得不改成use_logging(bar)。那麼有沒有更好的方式的呢？當然有，答案就是裝飾器。
簡單裝飾器
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper
def bar():
print('i am bar')
bar = use_logging(bar)
bar()
函數use_logging就是裝飾器，它把執行真正業務方法的func包裹在函數裡面，看起來像bar被use_logging裝飾了。在這個例子中，函數進入和退出時
，被稱為一個橫切面(Aspect)，這種編程方式被稱為面向切面的編程(Aspect-Oriented Programming)。
@符號是裝飾器的語法糖，在定義函數的時候使用，避免再一次賦值操作
def use_logging(func):
def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
@use_logging
def foo():
print("i am foo")
@use_logging
def bar():
print("i am bar")
bar()
如上所示，這樣我們就可以省去bar =
use_logging(bar)這一句了，直接調用bar()即可得到想要的結果。如果我們有其他的類似函數，我們可以繼續調用裝飾器來修飾函數，而不用重復修改函數或者增加新的封裝。這樣，我們就提高了程序的可重復利用性，並增加了程序的可讀性。
裝飾器在Python使用如此方便都要歸因於Python的函數能像普通的對象一樣能作為參數傳遞給其他函數，可以被賦值給其他變數，可以作為返回值，可以被定義在另外一個函數內。
帶參數的裝飾器
裝飾器還有更大的靈活性，例如帶參數的裝飾器：在上面的裝飾器調用中，比如@use_logging，該裝飾器唯一的參數就是執行業務的函數。裝飾器的語法允許我們在調用時，提供其它參數，比如@decorator(a)。這樣，就為裝飾器的編寫和使用提供了更大的靈活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper
return decorator
@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)
foo()
上面的use_logging是允許帶參數的裝飾器。它實際上是對原有裝飾器的一個函數封裝，並返回一個裝飾器。我們可以將它理解為一個含有參數的閉包。當我
們使用@use_logging(level="warn")調用的時候，Python能夠發現這一層的封裝，並把參數傳遞到裝飾器的環境中。
類裝飾器
再來看看類裝飾器，相比函數裝飾器，類裝飾器具有靈活度大、高內聚、封裝性等優點。使用類裝飾器還可以依靠類內部的\_\_call\_\_方法，當使用 @ 形式將裝飾器附加到函數上時，就會調用此方法。
class Foo(object):
def __init__(self, func):
self._func = func
def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')
@Foo
def bar():
print ('bar')
bar()
functools.wraps
使用裝飾器極大地復用了代碼，但是他有一個缺點就是原函數的元信息不見了，比如函數的docstring、__name__、參數列表，先看例子：
裝飾器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
函數
@logged
def f(x):
"""does some math"""
return x + x * x
該函數完成等價於：
def f(x):
"""does some math"""
return x + x * x
f = logged(f)
不難發現，函數f被with_logging取代了，當然它的docstring，__name__就是變成了with_logging函數的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None
這個問題就比較嚴重的，好在我們有functools.wraps，wraps本身也是一個裝飾器，它能把原函數的元信息拷貝到裝飾器函數中，這使得裝飾器函數也有和原函數一樣的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging
@logged
def f(x):
"""does some math"""
return x + x * x
print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'
內置裝飾器
@staticmathod、@classmethod、@property
裝飾器的順序
@a
@b
@c
def f ():
等效於
f = a(b(c(f)))
⑦ 剛學一個星期的小白求教關於python裝飾器
fromfunctoolsimportwraps
deflog(func):
@wraps(func)
defwrapper(*args,**kw):
print('begincall:%s()'%func.__name__)
#這里返回的是被裝飾的函數的返回值，如果注釋了，參見add_3
#returnfunc(*args,**kw)
returnwrapper
@log
defnow():
print('2015-3-25')
@log
defadd_3(int_val):
return3+int_val
now()
print(add_3(4))#這就沒有輸出了，應該可以解釋了
⑧ python裝飾器使用
裝飾器是從英文decorator翻譯過來的，從字面上來看就是對某個東西進行修飾，增強被修飾物的功能，下面我們對裝飾器做下簡單介紹。
一、怎麼編寫裝飾器
裝飾器的實現很簡單，本質是一個可調用對象，可以是函數、方法、對象等，它既可以裝飾函數也可以裝飾類和方法，為了簡單說明問題，我們實現一個函數裝飾器，如下代碼：
有了這個裝飾器，我們就可以列印出什麼時候開始和結束調用函數，對於排查函數的調用鏈非常方便。
二、帶參數的裝飾器
上面的例子無論什麼時候調用sum都會輸出信息，如果我們需要按需輸出信息怎麼實現呢，這時就要用到帶參數的裝飾器了，如下代碼：
對sum使用裝飾器時沒有參數，這時debug為0，所以調用sum時不會輸出函數調用相關信息。
對multi使用裝飾器時有參數，這時debug為1，所以調用multi時會輸出函數調用相關信息。
三、函數名字問題
當我們列印被裝飾後的函數名字時，不知道大家有沒發現輸出的不是函數本身的名字，如下代碼會輸出『wrap』而不是『sum』：
有時這種表現並不是我們想要的，我們希望被裝飾後的函數名字還是函數本身，那要怎麼實現呢？很簡單，只需要引入functools.wraps即可，如下代碼就會輸出『sum』了：
看完後是不是覺得python裝飾器很簡單，只要了解它的本質，怎麼寫都行，有好多種玩法呢。
⑨ python 某一函數上面有多個裝飾器
首先十分不推薦這種做法, 會令程序難以維護.
其次, 多個裝飾器是按照裝飾器的順序進行執行的.
如果你編寫過裝飾器, 你就應該知道, 其實裝飾器就是把函數的名字傳入進去, 在執行函數之前, 進行一些提前的處理.
例如下面這段代碼, 自定義的裝飾器
def add_schedid(handler_func):
"""
@handler_func: 請求處理函數
"""
@functools.wraps(handler_func)
def wrapper(self, *args, **kwargs):
"""
wrapper
"""
# handler_func就是所裝飾的函數,可以在這里做一些真正函數執行前所需的處理,
handler_func(self, *args, **kwargs)
return wrapper
裝飾器本身就是一個函數, 將所裝飾的函數, 作為一個參數傳進來, 然後在執行這個函數之前, 進行一個處理,這就是裝飾器. 所以和正常函數執行順序是一樣的..
⑩ PYTHON里的裝飾器能裝飾類嗎
可以的啦
#-*-coding:UTF-8-*-
fromfunctoolsimportwraps
__author__='lpe234'
defsingleton(cls):
"""
裝飾器實現單例模式
:paramcls:
:return:
"""
instances={}
@wraps(cls)
def_singleton(*args,**kwargs):
ifclsnotininstances:
instances[cls]=cls(*args,**kwargs)
returninstances[cls]
return_singleton
@singleton
classSelfClass(object):
pass
defmain():
s1=SelfClass()
s2=SelfClass()
asserts1iss2
if__name__=='__main__':
main()