标签：完全 imp log打印 ast one 其它 工作 deb 函数调用
问题：
定义了一个函数
想在运行时动态增加功能
又不想改变函数本身的代码
解决：
利用高阶函数，接收一个函数并对其进行包装，然后返回一个函数
def f1(x): #被装饰函数 return x * x def new_fn(f): #装饰器函数 def fn(x): print("Call" + f.__name__ + "()") return f(x) return fn #调用方法1 g1 = new_fn(f1) print(g1(5)) #调用方法2,此种调用完全隐蔽了f1原始定义 f1 = new_fn(f1) print(f1(5))
Callf1() 25 Callf1() 25
python内置的@语法是为了简化语法，接着上面的示例代码：
@new_fn #相当于f1 = new_fn(f1) def f1(x): #被装饰函数 return x * x
打印日志@log
检测性能@performance
数据库事务@transaction
URL路由@post(‘/register‘)
Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。
考察一个@log的定义：
def log(f): def fn(x): print ‘call ‘ + f.__name__ + ‘()...‘ return f(x) return fn
对于阶乘函数，@log工作得很好：
@log def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print factorial(10)
结果：
call factorial()...
3628800
但是，对于参数不是一个的函数，调用将报错：
@log def add(x, y): return x + y print add(1, 2)
结果：
Traceback (most recent call last): File "test.py", line 15, in <module> print add(1,2) TypeError: fn() takes exactly 1 argument (2 given)
因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。
要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：
def log(f): def fn(*args, **kw): print ‘call ‘ + f.__name__ + ‘()...‘ return f(*args, **kw) return fn
现在，对于任意函数，@log 都能正常工作。
请编写一个@performance，它可以打印出函数调用的时间。
import time from functools import reduce def performance(f): def fn(*args, **kw): t1 = time.time() r = f(*args, **kw) t2 = time.time() print (‘call %s() in %fs‘ % (f.__name__, (t2 - t1))) return r return fn @performance def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print (factorial(10))
call factorial() in 0.000000s 3628800
考察上一节的 @log 装饰器：
def log(f): def fn(x): print ‘call ‘ + f.__name__ + ‘()...‘ return f(x) return fn
发现对于被装饰的函数，log打印的语句是不能变的（除了函数名）。
如果有的函数非常重要，希望打印出‘[INFO] call xxx()...‘，有的函数不太重要，希望打印出‘[DEBUG] call xxx()...‘，这时，log函数本身就需要传入‘INFO‘或‘DEBUG‘这样的参数，类似这样：
@log(‘DEBUG‘) def my_func(): pass
把上面的定义翻译成高阶函数的调用，就是：
my_func = log(‘DEBUG‘)(my_func)
上面的语句看上去还是比较绕，再展开一下：
log_decorator = log(‘DEBUG‘) my_func = log_decorator(my_func)
上面的语句又相当于：
log_decorator = log(‘DEBUG‘) @log_decorator def my_func(): pass
所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：
def log(prefix): def log_decorator(f): def wrapper(*args, **kw): print ‘[%s] %s()...‘ % (prefix, f.__name__) return f(*args, **kw) return wrapper return log_decorator @log(‘DEBUG‘) def test(): pass print test()
执行结果：
[DEBUG] test()...
None
对于这种3层嵌套的decorator定义，你可以先把它拆开：
# 标准decorator: def log_decorator(f): def wrapper(*args, **kw): print ‘[%s] %s()...‘ % (prefix, f.__name__) return f(*args, **kw) return wrapper return log_decorator # 返回decorator: def log(prefix): return log_decorator(f)
拆开以后会发现，调用会失败，因为在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。
上一节的@performance只能打印秒，请给 @performace 增加一个参数，允许传入‘s‘或‘ms‘：
@performance(‘ms‘) def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1))
import time from functools import reduce def performance(unit): def perf_decorator(f): def wrapper(*args, **kw): t1 = time.time() r = f(*args, **kw) t2 = time.time() t = (t2 - t1) * 1000 if unit==‘ms‘ else (t2 - t1) print (‘call %s() in %f %s‘ % (f.__name__, t, unit)) return r return wrapper return perf_decorator @performance(‘ms‘) def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print (factorial(10))
call factorial() in 0.000000 ms 3628800
@decorator可以动态实现函数功能的增加，但是，经过@decorator“改造”后的函数，和原函数相比，除了功能多一点外，有没有其它不同的地方？
在没有decorator的情况下，打印函数名：
def f1(x): pass print f1.__name__
输出： f1
有decorator的情况下，再打印函数名：
def log(f): def wrapper(*args, **kw): print ‘call...‘ return f(*args, **kw) return wrapper @log def f2(x): pass print f2.__name__
输出： wrapper
可见，由于decorator返回的新函数函数名已经不是‘f2‘，而是@log内部定义的‘wrapper‘。这对于那些依赖函数名的代码就会失效。decorator还改变了函数的__doc__等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中：
def log(f): def wrapper(*args, **kw): print ‘call...‘ return f(*args, **kw) wrapper.__name__ = f.__name__ wrapper.__doc__ = f.__doc__ return wrapper
这样写decorator很不方便，因为我们也很难把原函数的所有必要属性都一个一个复制到新函数上，所以Python内置的functools可以用来自动化完成这个“复制”的任务：
import functools def log(f): @functools.wraps(f) def wrapper(*args, **kw): print ‘call...‘ return f(*args, **kw) return wrapper
最后需要指出，由于我们把原函数签名改成了(*args, **kw)，因此，无法获得原函数的原始参数信息。即便我们采用固定参数来装饰只有一个参数的函数：
def log(f): @functools.wraps(f) def wrapper(x): print ‘call...‘ return f(x) return wrapper
也可能改变原函数的参数名，因为新函数的参数名始终是 ‘x‘，原函数定义的参数名不一定叫 ‘x‘。
请思考带参数的@decorator，@functools.wraps应该放置在哪：
def performance(unit): def perf_decorator(f): def wrapper(*args, **kw): ??? return wrapper return perf_decorator
import time, functools def performance(unit): def fn(f): @functools.wraps(f) def f1(*args,**kw): print(‘call ‘ + f.__name__ + ‘() in ‘ + "%s" % time.ctime()) print(‘[%s] %s()...‘ % (unit, f.__name__)) return f(*args,**kw) return f1 return fn @performance(‘ms‘) def factorial(n): return reduce(lambda x,y: x*y, range(1, n+1)) print (factorial.__name__)
factorial
标签：完全 imp log打印 ast one 其它 工作 deb 函数调用
原文地址：https://www.cnblogs.com/SCCQ/p/12273705.html
