zoukankan      html  css  js  c++  java
  • python装饰器

    编写无参数decorator

    Python的 decorator 本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。

    使用 decorator 用Python提供的 @ 语法,这样可以避免手动编写 f = decorate(f) 这样的代码。

    考察一个@log的定义:

    1 def log(f):
    2     def fn(x):
    3         print 'call ' + f.__name__ + '()...'
    4         return f(x)
    5     return fn

    对于阶乘函数,@log工作得很好:

    @log
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    print factorial(10)

    结果:

    call factorial()...
    3628800

    但是,对于参数不是一个的函数,调用将报错:

    1 @log
    2 def add(x, y):
    3     return x + y
    4 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 都能正常工作。

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

    answer:

    def log(f):
        def fn():
            print "call "+f.__name__+"..."
            return f(x)
        return fn
    
    
    @log
    def new_fun(n):
        return reduce(lambda x, y: x*y, range(1, n+1))
    
    
    def new_log(f):
        def fn(*args, **kw):
            print ("call"+f.__name__+"()...")
            return f(*args, **kw)
        return fn
    
    
    @new_log
    def add(x, y):
        return x+y
    
    
    import time, datetime
    
    
    def performance(f):
        def fn(*args, **kwargs):
            t1 = time.time()
            r= f(*args, **kwargs)
            t2 = time.time()
            print ("call %s() in %fs" % (f.__name__, t2-t1))
            return r
        return fn
    
    
    @performance
    def factires(n):
        return reduce(lambda x, y: x*y, range(1, n+1))
    
    print factires(10)

    编写带参数decorator

    考察上一节的 @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,所以,把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

    question:

    上一节的@performance只能打印秒,请给 @performace 增加一个参数,允许传入's''ms':
    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))

    answer:

    def performance(unit):
        def perf_decorator(f):
            def wrapper(*args, **kwargs):
                t1 = time.time()
                r = f(*args, **kwargs)
                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 factorice(n):
        return reduce(lambda x, y: x*y, range(1, n+1))
    
    print(factorice)

    完善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'。

    任务

    请思考带参数的@decorator,@functools.wraps应该放置在哪:

    def performance(unit):
        def perf_decorator(f):
            def wrapper(*args, **kw):
                ???
            return wrapper
        return perf_decorator
    注意@functools.wraps应该作用在返回的新函数上。
    参考代码:
    import time, functools
    def performance(unit):
        def perf_decorator(f):
            @functools.wraps(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.__name__
  • 相关阅读:
    Working with macro signatures
    Reset and Clear Recent Items and Frequent Places in Windows 10
    git分支演示
    The current .NET SDK does not support targeting .NET Core 2.1. Either target .NET Core 2.0 or lower, or use a version of the .NET SDK that supports .NET Core 2.1.
    Build website project by roslyn through devenv.com
    Configure environment variables for different tools in jenkins
    NUnit Console Command Line
    Code Coverage and Unit Test in SonarQube
    头脑王者 物理化学生物
    头脑王者 常识,饮食
  • 原文地址:https://www.cnblogs.com/blogofwyl/p/4599481.html
Copyright © 2011-2022 走看看