裝飾器

裝飾器

需求

一個加法函數，想增強它的功能，能夠輸出被調用過以及調用的參數信息

def add(x, y):

return x + y

增加信息輸出功能

def add(x, y):

print(“call add, x + y”) ?# 日志輸出到控制臺

return x + y p

上面的加法函數是完成了需求，但是有以下的缺點

打印語句的耦合太高

加法函數屬于業務功能，而輸出信息的功能，屬于非業務功能代碼，不該放在業務函數加法中

裝飾器做到了業務功能分離，但是fn函數調用傳參是個問題

def add(x,y):
return x+y
def logger(fn)
print(‘begin’)#增強輸出
x = fn(4,5)
print(‘end’)#增強的功能
return
print(logger(add)

解決傳參的問題

def add(x,y):
return x+y
def logger(fn,*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
print(logger(add,5,y=60))

將函數柯里化

def add(x,y):
return x+y
def logger(fn):
def _logger(*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
return _logger
print(logger(add)(5,y=60))

開始變形裝飾器

ef logger(fn):
def _logger(*args,**kwargs):
print(“begin”)
x = fn(*args,**kwargs)
print(‘end’)
return x
return _logger
#print(logger(add)(5,y=60))
@logger?#等價于add=logger(add)
def add(x,y):
return x+y
print((add(4,50)))

裝飾器（無參）

他是一個函數

函數作為他的形參

返回值也是一個函數

可以使用@functioname方式，簡化調用

裝飾器和高階函數

裝飾器是高階函數，但是裝飾器是對傳入函數的功能的裝飾（功能增強）

裝飾器具體用法

import datetime
import time
def logger(fn):
def wrap(*args,**kwargs):
print(“args={},kwargs={}”.format(args,kwargs))
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
duration = ?datetime.datetime.now() – start
print(“function {} took {}s.”.format(fn.__name__,duration.total_seconds()))

return ret
return wrap
@logger?#add = logger(add)
def add(x,y):
print(“=============================”)
time.sleep(1)
return x+y
print(add(4,y=10))

Python的文檔

Python是文檔字符串Documenttstion strings

在函數語句的塊的第一行，且習慣是多行的文本，所以多使用三引號

慣例是首字母大寫，第一行寫概述，空一行，第三行寫詳細描述

可以使用特殊屬性__doc__訪問這個文檔

def add(x,y):
“””this is function of addtion”””
????a = x+y
return ?x+y
print(“name={}\ndoc={}”.format(add.__name__,add.__doc__))
print(help(add))

副作用：原函數對象的屬性都被替換了。而使用裝飾器，我們的需求是看被封裝函數的屬性

def logger(fn):
def wrapper(*args,**kwargs):
“iam ???wrapper”
????????print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
return wrapper
@logger
def add(x,y):
”’his ??is a function for add”’
????return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

改進：提供一個函數，本封裝函數屬性 ==copy==> 包裝函數屬性

def copy_pro(src,dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__

def logger(fn):
def wrapper(*args,**kwargs):
“l am wrapper”
????????print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
copy_pro(fn,wrapper)
return wrapper
@logger
def add(x,y):
“this is function for add”
????return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

通過copy_pro函數將被包裝函數的屬性覆蓋掉包裝函數

凡是被裝飾的函數都需要復制這些屬性，這個函數很通用

可以將復制函數屬性的函數構建成裝飾器函數，帶參裝飾器

提供一個函數，被封裝函數屬性 ==copy==> 包裝函數屬性改造成帶參裝飾器

def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy

def logger(fn):
@copy_pro(fn)
def wrapper(*args,**kwargs):
“l am wrapper”
????????print(“begin”)
x = fn(*args,**kwargs)
print(“end”)
return x
return wrapper
@logger
def add(x,y):
“this is function for add”
????return x+y
print(“name={},doc={}”.format(add.__name__,add.__doc__))

帶參裝飾器

獲取函數的執行時長，對時長超過閾值的函數記錄一下

import datetime
import time
def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy
def logger(duration):
def _logger(fn):
@copy_pro(fn)
def wrapper(*args,**kwargs):
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
delta = (datetime.datetime.now() – start).total_seconds()
print(‘so slow’) if delta > duration else print(“so fast”)
return ret
return wrapper
return _logger
@logger(1)
def add(x,y):
time.sleep(2)
return x + y
print(add(5,6))

帶參裝飾器

他是一個函數

函數作為它的形參

返回值是一個不帶參的裝飾器函數

使用@functionname方式調用

可以看做在裝飾器外層又加了一層函數

將記錄的功能提取出來，這樣就可以通過外部提供的函數來靈活的控制輸出

import datetime
import time
def copy_pro(src):
def _copy(dst):
dst.__name__ = src.__name__
dst.__doc__ = src.__doc__
return dst
return _copy
def logger(duration,func=lambda name,duration:print(“{} took {}s”.format(name,duration))):
def _logger(fn):
@copy_pro(fn)
def weapper(*args,**kwargs):
start = datetime.datetime.now()
ret = fn(*args,**kwargs)
delta = (datetime.datetime.now() – start).total_seconds()
print(‘ {}s.’.format(delta))
if ?delta > duration:
func(fn.__name__,duration)
print(delta)
return ret
return weapper
return _logger
@logger(5)
def add(x,y):
“this is function for add”
????print(“============call add===============”)
return x+y
print(add(4,y=7),add.__name__,add.__doc__)

?

?

?

?

?

?

?

?

?

?

?