Python 实用编程技巧(装饰器篇)

一、如何使用函数装饰器?

1.需求:

比如说,我们想为很多不同的函数添加相同的功能,比如说计时统计、记录日志、缓存运算结果等,但是我们又不想在每个函数中添加相同的代码

2.举个例子:

我们还是以斐波那契数的计算为例

示例代码:

def fib(n):
    if n <= 1:
        return 1
    return fib(n-1)+fib(n-2)

if __name__ == '__main__':
    print fib(50)

这一段代码想要跑出来非常的慢,因为我们在这个运算的过程中经历了非常多的重复运算,比如我们想计算50就要计算49,48 我们要计算49 就要计算 48,47 ,看到了吧,48 就出现了重复运算,那么这里面有着太多太多的重复运算,导致我们的计算非常的慢,并且非常的消耗 CPU

那么怎么办呢?

我们可以创造一个缓存,每次算到一个新的结果我们都放在这个缓存中,这样我们每次都判断缓存有没有我们想要的值就可以了,有的话直接拿过来用,没有再加入缓存,这样就能大大提高我们的运行效率,并且减轻了我们的CPU 的负担

示例代码:

def fib(n,cache = None):
    if cache is None:
        cache = {}
    if n in cache:
        return cache[n]

    if n <= 1:
        return 1

    cache[n] = fib(n-1,cache)+fib(n-2,cache)
    return cache[n]

if __name__ == '__main__':
    print fib(50)

结果:

20365011074

我们发现效率出现了质的飞跃,很快就算出了结果,但是换做别的函数我么又要添加这个缓存的代码了,这样就非常的烦,

那么怎么解决呢?

我们考虑创建一个包裹函数 wrap ,在这个函数内部我们实现我们的缓存代码,并且调用原函数,我们的函数装饰器就是为了生成这样的包裹函数的

示例代码:

def memo(func):
    cache = {}
    def wrap(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrap


def fib(n):
    if n <= 1:
        return 1
    return fib(n - 1) + fib(n - 2)


if __name__ == '__main__':
    fib = memo(fib)
    print fib(50)

结果:

20365011074

当然这样在函数中写是非常啰嗦的,我们python 给我们提供了一个语法糖,

示例代码:

def memo(func):
    cache = {}
    def wrap(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrap

@memo
def fib(n):
    if n <= 1:
        return 1
    return fib(n - 1) + fib(n - 2)


if __name__ == '__main__':
    print fib(50)

结果:

20365011074

二、如何为被装饰的函数保存元数据

1.概念:

在函数对象中保存着一些函数的元数据,例如:

f.__name__ 函数的名字
f.__doc__ 函数的文档字符串
f.__model__ 函数所属的模块名
f.__dict__ 属性字典
f.__defaults__ 默认参数元组

我们在使用装饰器以后,再使用上面这些属性访问的时候,看到的是包裹函数的元数据,而原始函数的元数据不见了,我们该如何解决

2.举个例子:

下面是原始函数的返回结果

示例代码:

def example():
    '''example function'''
    print "In example"

if __name__ == '__main__':
    print example.__name__
    print example.__doc__

结果:

example
example function

这下面是经过装饰器装饰以后的返回结果

示例代码:

def mydecorator(func):
    def wrap(*args,**kargs):
        '''wrap function'''
        print "In wrapper"
        func(*args,**kargs)
    return wrap


@mydecorator
def example():
    '''example function'''
    print "In example"

if __name__ == '__main__':
    print example.__name__
    print example.__doc__

结果:

wrap
wrap function

解决:

我们使用 functools 中的 wraps 装饰内部的包裹函数,可以定义将原函数的某些属性更新到包裹函数上面

示例代码:

from functools import wraps
def mydecorator(func):
    @wraps(func)
    def wrap(*args,**kargs):
        '''wrap function'''
        print "In wrapper"
        func(*args,**kargs)
    return wrap


@mydecorator
def example():
    '''example function'''
    print "In example"

if __name__ == '__main__':
    print example.__name__
    print example.__doc__

结果:

example
example function

三、如何自定义带参数的装饰器

比如说我们想实现一个装饰器来检查被装饰函数的参数类型,装饰器能定义函数的参数类型,如果函数调用的时参数类型不对就抛出异常

带参数的装饰器就是根据参数定制化一个装饰器,可以看成是生产装饰器的工厂,每次调用这个装饰器都能返回一个特定的装饰器,然后再用其修饰其它函数

示例代码:

from inspect import signature

def typeassert(*ty_args,**ty_kargs):
    def decorator(func):
        sig = signature(func)
        btypes = sig.bind_partial(*ty_args,**ty_kargs).arguments
        def wrapper(*args,**kargs):
            for name,obj in sig.bind(*args,**kargs).arguments.items():
                if name in btypes:
                    if not isinstance(obj,btypes[name]):
                        raise TypeError("%s must be %s" % (name,btypes[name]))
            return func(*args,**kargs)
        return wrapper
    return decorator

@typeassert(int,str,list)
def f(a,b,c):
    print (a,b,c)

if __name__ == '__main__':
    f(1,"abc",[1,2,3])
    f(1,2,[1,2,3])

结果:

1 abc [1, 2, 3]
TypeError: b must be <class 'str'>

四、如何实现属性可修改的装饰器

背景:

为了分析程序内哪些程序开销较大,我们可以定义一个带有timeout 参数的函数装饰器,他实现以下功能:

1.统计被装饰的函数的单次调用的时间
2.时间大于timeout 的将此次函数的调用记录记录在 log 日志文件中
3.运行时可以修改 timeout 的值

示例代码:

from functools import wraps
import time
import logging
from random import randint


def warn(timeout): 
    def decorator(func):
        @wraps(func)
        def wrapper(*args,**kargs):
            start = time.time()
            res = func(*args,**kargs)
            used = time.time() - start
            if used > timeout:
                msg = "%s : %s > %s" % (func.__name__,used,timeout)
                logging.warn(msg)
            return res
        return wrapper
    return decorator

@warn(1.5)
def test():
    print("In test")
    while randint(0,1):
        time.sleep(0.5)


for i in range(30):
    test()

我们可以在包裹中添加一个函数,然后用这个函数来修改闭包中的自由变量

Python3

示例代码:

from functools import wraps
import time
import logging
from random import randint


def warn(timeout):
    def decorator(func):
        @wraps(func)
        def wrapper(*args,**kargs):
            start = time.time()
            res = func(*args,**kargs)
            used = time.time() - start
            if used > timeout:
                msg = "%s : %s > %s" % (func.__name__,used,timeout)
                logging.warn(msg)
            return res

        def setTimeout(k):
            nonlocal timeout
            timeout = k
        wrapper.setTimeout = setTimeout

        return wrapper
    return decorator

@warn(1)
def test():
    print("In test")
    while randint(0,1):
        time.sleep(0.5)


for i in range(30):
    test()

test.setTimeout(1)
for i in range(30):
    test()

但是由于 python2 并不支持 nonlocal ,于是我们还要修改,使用列表将其修改成一个可变变量

示例代码:

from functools import wraps
import time
import logging
from random import randint


def warn(timeout):
    timeout = [timeout]
    def decorator(func):
        @wraps(func)
        def wrapper(*args,**kargs):
            start = time.time()
            res = func(*args,**kargs)
            used = time.time() - start
            if used > timeout[0]:
                msg = "%s : %s > %s" % (func.__name__,used,timeout[0])
                logging.warn(msg)
            return res

        def setTimeout(k):
            #nonlocal timeout
            timeout[0] = k
        wrapper.setTimeout = setTimeout

        return wrapper
    return decorator

@warn(1)
def test():
    print("In test")
    while randint(0,1):
        time.sleep(0.5)


for i in range(30):
    test()

test.setTimeout(1)
for i in range(30):
    test()
文章目录
  1. 1. 一、如何使用函数装饰器?
    1. 1.1. 1.需求:
    2. 1.2. 2.举个例子:
  2. 2. 二、如何为被装饰的函数保存元数据
    1. 2.1. 1.概念:
    2. 2.2. 2.举个例子:
  3. 3. 三、如何自定义带参数的装饰器
  4. 4. 四、如何实现属性可修改的装饰器
    1. 4.1. 背景:
|