python裝飾器帶參數

① 關於python裝飾器的問題

裝飾器函數參數要傳函數，而不是字元串。

裝飾器函數特點:

1，參數為函數對象

2，使用內部函數

3，返回函數對象

在你的代碼中:

裝飾器函數是arg_func(sex)

內部函數是func1()

被裝飾函數是man()和woman()

所以代碼要改成:

defarg_func(sex):

deffunc1():

sex()

if(sex.__name__=='man'):

print("youcan't")

if(sex.__name__=='woman'):

print("youcan")

returnfunc1

@arg_func

defman():

print('goodgoodstudy')

@arg_func

defwoman():

print('goodgoodstudy')

man()

woman()

PS:裝飾器就是為了簡化代碼，增加可讀性，方便團隊開發，在不修改原函數代碼的前提下，通過封裝修改功能，而@修飾就是為了通過原函數名調用時，不直接執行原函數，而是把原函數傳遞到裝飾器函數，通過內部函數(閉包)來調用原函數。這樣好處，就是統一調用方式。

② python 如何封裝在某帶參數函數之後等待時間

題主你好,

方法及相應代碼見截圖:

*.方法不只一種, 題主看看如果不合適請追問. 上面這種做法的好處是封裝的這個函數func可以帶任意多個位置參數. //就圖主的問題來看, *args就夠了, 如果func函數中還有關鍵字參數,則還需要使用**argv.

-----

希望可以幫到題主, 歡迎追問

③ python中一層裝飾器的函數可以帶參數嗎

可以的，

裝飾器分為可帶參數和不可帶參數的兩種；但是如果帶參數，則帶參數裝飾器的「參數」及「return」必須也是一個裝飾器

具體可以參考一下下面的例子：

defdeco1(func):
	defw(x,*args,**kw):
		print"thisisdeco1"
		returnx+"decorator"
	returnw

defdeco2(deco):
	print"thisisdeco2"
	returndeco

@deco2(deco1)
deffunc(x):
	returnx

printfunc("Hello")

④ 什麼是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中支持參數的裝飾器要比無參數的多一層什麼函數

1. 函數帶多個參數
# 普通的裝飾器, 列印函數的運行時間
def decrator(func):
def wrap(*args, **kwargs):
start_time = time.time()
res = func(*args, **kwargs)
end_time = time.time()
print('運行時間為', end_time-start_time)
return res
return wrap
2. 裝飾器帶有多個參數
當裝飾器帶有多個參數的時候, 裝飾器函數就需要多加一層嵌套:
比如:
def decrator(*dargs, **dkargs):
def wrapper(func):
def _wrapper(*args, **kargs):
print ("裝飾器參數:", dargs, dkargs)
print ("函數參數:", args, kargs)
return func(*args, **kargs)
return _wrapper
return wrapper
為什麼被裝飾函數體可以傳入內層呢?
裝飾器函數有多個參數, 需要以
@decrator(1, a=2)
的方式使用, 這時候decrator是已經執行的(因為加了括弧), 可以粗略的理解為載入被裝飾函數的上的是wrapper, 所以這和普通的裝飾器並無差別.
又如flask源碼中的:
def route(self, rule, **options):
"""Like :meth:`Flask.route` but for a blueprint. The endpoint for the
:func:`url_for` function is prefixed with the name of the blueprint.
"""
def decorator(f):
endpoint = options.pop("endpoint", f.__name__)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
flask的藍圖route源碼中的裝飾器, 最內層直接返回return f 並沒有多加一層處理的函數, 在無需對被裝飾函數進行過多處理的時候這是較為方便的做法. route源碼中只是對裝飾器參數進行了處理.

⑥ python3 如何給裝飾器傳遞參數

def add(func): def wrap(num): ret = func(num) if num == 0: print('test運行結束') return ret return wrap 你的遞歸函數有問題哦，沒有終止

⑦ python如何將函數的參數傳遞給他的裝飾器

不需要傳遞，函數的參數，本來就要先給裝飾器，裝飾器不需要參數了

⑧ 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)))