>

python中的decorator的魔法详解,函数式编程

- 编辑:www.bifa688.com -

python中的decorator的魔法详解,函数式编程

1、概念

1、概念

13.1 装饰器

概念:在不改变原函数的情况下,给函数增加新功能,。可以极大地简化代码,避免每个函数编写重复性代码。

应用:打印日志@log,检测性能@performance,数据库事务@transaction,URL路由@post('/register')

例子:

def log(func):

    def f():

        print('call ' func._name_)

    return f

@log

def myfunc(a):

    return a

print(myfunc(3))

>>call myfunc

>>3

装饰器(decorator)就是:定义了一个函数,想在运行时动态增加功能,又不想改动函数本身的代码。可以起到复用代码的功能,避免每个函数重复性编写代码,简言之就是拓展原来函数功能的一种函数。在python中,装饰器(decorator)分为函数装饰器和类装饰器两种。python中内置的@语言就是为了简化装饰器调用。

装饰器(decorator)就是:定义了一个函数,想在运行时动态增加功能,又不想改动函数本身的代码。可以起到复用代码的功能,避免每个函数重复性编写代码,简言之就是拓展原来函数功能的一种函数。在python中,装饰器(decorator)分为 函数装饰器 和 类装饰器 两种。python中内置的@语言就是为了简化装饰器调用。

13.2 python中编写无参数decorator

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

    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都能正常工作。

列出几个装饰器函数:

列出几个装饰器函数:

13.3 python中编写带参数decorator

考察上一节的@log 装饰器:

def log(f):

    def fn(x):

        print 'call ' f.__name__ '()...'

        return f(x)

    return fn

发现对于被装饰的函数,log打印的语句是不能变的(除了函数名)。

如果有的函数非常重要,希望打印出'[必发88手机版,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,所以,把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

打印日志:@log

打印日志:@log

13.4 python中完善decorator

@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'。

检测性能:@performance

检测性能:@performance

13.5 python中偏函数

当一个函数有很多参数时,调用者就需要提供多个参数。如果减少参数个数,就可以简化调用者的负担。

比如,int()函数可以把字符串转换为整数,当仅传入字符串时,int()函数默认按十进制转换:

>>> int('12345')

12345

但int()函数还提供额外的base参数,默认值为10。如果传入base参数,就可以做N 进制的转换:

>>> int('12345', base=8)

5349

>>> int('12345', 16)

74565

假设要转换大量的二进制字符串,每次都传入int(x, base=2)非常麻烦,于是,我们想到,可以定义一个int2()的函数,默认把base=2传进去:

def int2(x, base=2):

    return int(x, base)

这样,我们转换二进制就非常方便了:

>>> int2('1000000')

64

>>> int2('1010101')

85

functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2:

>>> import functools

>>> int2 = functools.partial(int, base=2)

>>> int2('1000000')

64

>>> int2('1010101')

85

所以,functools.partial可以把一个参数多的函数变成一个参数少的新函数,少的参数需要在创建时指定默认值,这样,新函数调用的难度就降低了。

数据库事务:@transaction

数据库事务:@transaction

URL路由:@post('/register')

URL路由:@post('/register')

2、使用方法

2、使用方法

(1)无参数decorator

(1)无参数decorator

编写一个@performance,它可以打印出函数调用的时间。

编写一个@performance,它可以打印出函数调用的时间。

 1 import time
 2 
 3 def performance(f):
 4     def log_time(x):
 5         t1 = time.time()
 6         res = f(x)
 7         t2 = time.time()
 8         print 'call %s() in %fs' %(f.__name__,(t2 - t1))
 9         return res
10     return log_time
11 
12 @performance
13 def factorial(n):
14     return reduce(lambda x,y : x*y,range(1,n 1))
15 
16 print factorial(10)
import time

def performance(f):
 def log_time(x):
  t1 = time.time()
  res = f(x)
  t2 = time.time()
  print 'call %s() in %fs' %(f.__name__,(t2 - t1))
  return res
 return log_time

@performance
def factorial(n):
 return reduce(lambda x,y : x*y,range(1,n 1))

print factorial(10)

运行结果:

运行结果:

 1 call factorial() in 0.006009s 2 3628800 

call factorial() in 0.006009s 2 3628800

运行原理:

运行原理:

此时,factorial就作为performance的函数对象,传递给f。当调用factorial(10)的时候也就是调用log_time(10)函数,而在log_time函数内部,又调用了f,这就造成了装饰器的效果。说明f是被装饰函数,而x是被装饰函数的参数。

此时,factorial就作为performance的函数对象,传递给f。当调用factorial(10)的时候也就是调用log_time(10)函数,而在log_time函数内部,又调用了f,这就造成了装饰器的效果。说明f是被装饰函数,而x是被装饰函数的参数。

(2)带参数decorator

(2)带参数decorator

请给 @performace 增加一个参数,允许传入's'或'ms'。

请给 @performace 增加一个参数,允许传入's'或'ms'。

 1 import time
 2 
 3 def performance(unit):
 4     def perf_decorator(f):
 5         def wrapper(*args, **kw):
 6             t1 = time.time()
 7             r = f(*args, **kw)
 8             t2 = time.time()
 9             t = (t2 - t1)*1000 if unit =='ms' else (t2 - t1)
10             print 'call %s() in %f %s'%(f.__name__, t, unit)
11             return r
12         return wrapper
13     return perf_decorator
14 
15 @performance('ms')  
16 def factorial(n):
17     return reduce(lambda x,y: x*y, range(1, n 1))
18 
19 print factorial(10)
import time

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)

运行结果:

运行结果:

 1 call factorial() in 9.381056 ms 2 3628800 

call factorial() in 9.381056 ms 2 3628800

运行原理:

运行原理:

它的内部逻辑为factorial=performance('ms')(factorial);

它的内部逻辑为factorial=performance('ms')(factorial);

这里面performance('ms')返回是perf_decorator函数对象,performance('ms')(factorial)其实就是perf_decorator(factorial),然后其余的就和上面是一样的道理了。

这里面performance('ms')返回是perf_decorator函数对象,performance('ms')(factorial)其实就是perf_decorator(factorial),然后其余的就和上面是一样的道理了。

 

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

您可能感兴趣的文章:

  • python实现Decorator模式实例代码
  • Python装饰器(decorator)定义与用法详解
  • 12步入门Python中的decorator装饰器使用方法
  • Python使用logging结合decorator模式实现优化日志输出的方法
  • 分析Python中设计模式之Decorator装饰器模式的要点
  • Python中decorator使用实例
  • Python中用Decorator来简化元编程的教程
  • python装饰器decorator介绍
  • Python装饰器decorator用法实例
  • python self,cls,decorator的理解

本文由必发88手机版发布,转载请注明来源:python中的decorator的魔法详解,函数式编程