python裝飾

發布時間: 2022-07-23 13:55:49

㈠ python裝飾器具體是怎麼工作的

分析線面的代碼可以得出結論，可以復制代碼後自行打斷點進行調試
def task(weight=1): # 代碼被執行的時候首先會到這里，執行裝飾器
def decorator_func(func):
func.locust_task_weight = weight return func return decorator_func # 代碼執行的這里的時候會返回來源函數，獲取到來源函數的對象共裝飾器使用@task(1)def test():
print(test)if __name__ == '__main__':
test()

㈡ Python裝飾器是怎麼實現的

簡單來講，可以不嚴謹地把Python的裝飾器看做一個包裝函數的函數。比如，有一個函數： def func(): print 'func() run.' if '__main__' == __name__: func() 運行後將輸出: func() run. 現在需要在函數運行前後列印一條日誌

㈢什麼是Python裝飾器

所謂裝飾器就是把函數包裝一下，為函數添加一些附加功能，裝飾器就是一個函數，參數為被包裝的函數，返回包裝後的函數：你可以試下：

defd(fp):
def_d(*arg,**karg):
print"dosthbeforefp.."
r=fp(*arg,**karg)
print"dosthafterfp.."
returnr
return_d
@d
deff():
print"callf"
#上面使用@d來表示裝飾器和下面是一個意思
#f=d(f)
f()#調用f

㈣ 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 裝飾器原理

官方文檔如下：

Python 2.2 extended Python's object model by adding static methods and class methods, but it didn't extend Python's syntax to provide any new way of defining static or class methods. Instead, you had to write a statement in the usual way, and pass the resulting method to a or function that would wrap up the function as a method of the new type.

Python

㈥ python裝飾器是什麼意思

裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對於好多小白來講，這個功能有點繞，自學時直接繞過去了，然後面試問到了就掛了，因為裝飾器是程序開發的基礎知識，這個都不會，別跟人家說你會Python, 看了下面的文章，保證你學會裝飾器。

1、先明白這段代碼

####第一波####

deffoo():

print'foo'

foo#表示是函數

foo()#表示執行foo函數

####第二波####

deffoo():

print'foo'

foo=lambdax:x+1

foo()#執行下面的lambda表達式，而不再是原來的foo函數，因為函數foo被重新定義了

2、需求來了

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

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

deff1():

print'f1'

deff2():

print'f2'

deff3():

print'f3'

deff4():

print'f4'

###############業務部門A調用基礎平台提供的功能###############

f1()

f2()

f3()

f4()

###############業務部門B調用基礎平台提供的功能###############

f1()

f2()

f3()

f4()

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

老大把工作交給 Low B，他是這么做的：

跟每個業務部門交涉，每個業務部門自己寫代碼，調用基礎平台的功能之前先驗證。誒，這樣一來基礎平台就不需要做任何修改了。

當天Low B 被開除了…

老大把工作交給 Low BB，他是這么做的：

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

deff1():

#驗證1

#驗證2

#驗證3

print'f1'

deff2():

#驗證1

#驗證2

#驗證3

print'f2'

deff3():

#驗證1

#驗證2

#驗證3

print'f3'

deff4():

#驗證1

#驗證2

#驗證3

print'f4'

###############業務部門不變###############

###業務部門A調用基礎平台提供的功能###

f1()

f2()

f3()

f4()

###業務部門B調用基礎平台提供的功能###

f1()

f2()

f3()

f4()

過了一周 Low BB 被開除了…

老大把工作交給 Low BBB，他是這么做的：

只對基礎平台的代碼進行重構，其他業務部門無需做任何修改

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

defcheck_login():

#驗證1

#驗證2

#驗證3

pass

deff1():

check_login()

print'f1'

deff2():

check_login()

print'f2'

deff3():

check_login()

print'f3'

deff4():

check_login()

print'f4'

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

老大說：

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

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

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

defw1(func):

definner():

#驗證1

#驗證2

#驗證3

returnfunc()

returninner

@w1

deff1():

print'f1'

@w1

deff2():

print'f2'

@w1

deff3():

print'f3'

@w1

deff4():

print'f4'

對於上述代碼，也是僅僅對基礎平台的代碼進行修改，就可以實現在其他人調用函數 f1 f2 f3 f4 之前都進行【驗證】操作，並且其他業務部門無需做任何操作。

Low BBB心驚膽戰的問了下，這段代碼的內部執行原理是什麼呢？

老大正要生氣，突然Low BBB的手機掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一緊一抖，喜笑顏開，交定了Low BBB這個朋友。詳細的開始講解了：

單獨以f1為例：

defw1(func):

definner():

#驗證1

#驗證2

#驗證3

returnfunc()

returninner

@w1

deff1():

print'f1'

當寫完這段代碼後（函數未被執行、未被執行、未被執行），python解釋器就會從上到下解釋代碼，步驟如下：

def w1(func): ==>將w1函數載入到內存
@w1

沒錯，從表面上看解釋器僅僅會解釋這兩句代碼，因為函數在沒有被調用之前其內部代碼不會被執行。

從表面上看解釋器著實會執行這兩句，但是 @w1 這一句代碼里卻有大文章，@函數名是python的一種語法糖。

如上例@w1內部會執行一下操作：

執行w1函數，並將 @w1 下面的函數作為w1函數的參數，即：@w1 等價於 w1(f1)
所以，內部就會去執行：
def inner:
#驗證
return f1() # func是參數，此時 func 等於 f1
return inner # 返回的 inner，inner代表的是函數，非執行函數
其實就是將原來的 f1 函數塞進另外一個函數中
將執行完的 w1 函數返回值賦值給@w1下面的函數的函數名
w1函數的返回值是：
def inner:
#驗證
return 原來f1() # 此處的 f1 表示原來的f1函數
然後，將此返回值再重新賦值給 f1，即：
新f1 =def inner:
#驗證
return 原來f1()
所以，以後業務部門想要執行 f1 函數時，就會執行新f1 函數，在新f1 函數內部先執行驗證，再執行原來的f1函數，然後將原來f1 函數的返回值返回給了業務調用者。
如此一來，即執行了驗證的功能，又執行了原來f1函數的內容，並將原f1函數返回值返回給業務調用著

Low BBB 你明白了嗎？要是沒明白的話，我晚上去你家幫你解決吧！！！

先把上述流程看懂，之後還會繼續更新…

3、問答時間

問題：被裝飾的函數如果有參數呢？

#一個參數

defw1(func):

definner(arg):

#驗證1

#驗證2

#驗證3

returnfunc(arg)

returninner

@w1

deff1(arg):

print'f1'

#兩個參數

defw1(func):

definner(arg1,arg2):

#驗證1

#驗證2

#驗證3

returnfunc(arg1,arg2)

returninner

@w1

deff1(arg1,arg2):

print'f1'

#三個參數

defw1(func):

definner(arg1,arg2,arg3):

#驗證1

#驗證2

#驗證3

returnfunc(arg1,arg2,arg3)

returninner

@w1

deff1(arg1,arg2,arg3):

print'f1'

問題：可以裝飾具有處理n個參數的函數的裝飾器？

defw1(func):

definner(*args,**kwargs):

#驗證1

#驗證2

#驗證3

returnfunc(*args,**kwargs)

returninner

@w1

deff1(arg1,arg2,arg3):

print'f1'

問題：一個函數可以被多個裝飾器裝飾嗎？

defw1(func):

definner(*args,**kwargs):

#驗證1

#驗證2

#驗證3

returnfunc(*args,**kwargs)

returninner

defw2(func):

definner(*args,**kwargs):

#驗證1

#驗證2

#驗證3

returnfunc(*args,**kwargs)

returninner

@w1

@w2

deff1(arg1,arg2,arg3):

print'f1'

問題：還有什麼更吊的裝飾器嗎？

#!/usr/bin/envpython

#coding:utf-8

defBefore(request,kargs):

print'before'

defAfter(request,kargs):

print'after'

defFilter(before_func,after_func):

defouter(main_func):

defwrapper(request,kargs):

before_result=before_func(request,kargs)

if(before_result!=None):

returnbefore_result;

main_result=main_func(request,kargs)

if(main_result!=None):

returnmain_result;

after_result=after_func(request,kargs)

if(after_result!=None):

returnafter_result;

returnwrapper

returnouter

@Filter(Before,After)

defIndex(request,kargs):

print'index'

㈦如何理解Python裝飾器

簡言之，打個比方，我寫了一個python的插件，提供給用戶使用，但是在使用的過程中我添加了一些功能，可是又不希望用戶改變調用的方式，那麼該怎麼辦呢？這個時候就用到了裝飾器。
python裝飾器就是用於拓展原來函數功能的一種函數，這個函數的特殊之處在於它的返回值也是一個函數，使用python裝飾器的好處就是在不用更改原函數的代碼前提下給函數增加新的功能。一般而言，我們要想拓展原來函數代碼，比較直接的辦法就是侵入代碼裡面修改。
而且裝飾器是程序開發中經常會用到的一個功能，用好了裝飾器，開發效率如虎添翼，所以這也是Python面試中必問的問題，但對於好多小白來講，這個功能有點繞，自學時直接繞過去了，然後面試問到了就掛了，因為裝飾器是程序開發的基礎知識，不懂就太說不過去啦。
講完裝飾器，相信大家對於Python的發展前景也比較感興趣，隨著人工智慧的發展，Python作為人工智慧的首選語言，自然也是發展得如火如荼。現在入行，肯定是一個好時機！

㈧ Python中的裝飾模式如何實現

基於普通的函數嵌套

>deflog1(fn):
def_wrapper(*args,**kwargs):
start=time.clock()
result=fn(*args,**kwargs)
print("%sisinvokedwithtimeconsumed:%ssecondsataddress%s"%(fn.__name__,str(time.time()-start),id(fn)))
returnresult
return_wrapper
基於@decorator

@decorator
deflog(f,*args,**kwargs):
start=time.time()
result=f(*args,**kwargs)
print("%sisinvokedwithtimeconsumed:%sataddress%s"%(f.__name__,str(time.time()-start),id(f)))

returnresult
使用@functools

deflog2(f):
@functools.wraps(f)
defwrapper(*args,**kwargs):
start=time.clock()
result=f(*args,**kwargs)
print("%sisinvokedwithtimeconsumed:%ssecondsataddress%s"%(f.__name__,str(time.time()-start),id(f)))
returnresult
returnwrapper

㈨ Python之裝飾器簡介

python函數式編程之裝飾器

1.開放封閉原則

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

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

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

python裝飾

與python裝飾相關的資訊