Python 装饰器详解

1 为什么需要装饰器

Leader让小A写两个数字相加和相减的函数,小A很快就写完了:

def add(x, y):
    return x + y


def sub(x, y):
    return x - y


if __name__ == '__main__':
    result = add(1, 2)
    print(result)

    result = sub(5, 4)
    print(result)

# 输出:
# 3
# 1

Leader让小A添加上统计函数的运行时长的功能, 小A直接在调用函数时加上了时长的计算:

import time


def add(x, y):
    return x + y


def sub(x, y):
    return x - y


if __name__ == '__main__':
    start = time.time()
    result_1 = add(1, 2)
    end = time.time()
    print('result: %d' % result_1)
    print('time taken %f' % (end - start))

    start = time.time()
    result_2 = sub(5, 4)
    end = time.time()
    print('result: %d' % result_2)
    print('time taken %f' % (end - start))

# 输出:
# result: 3
# time taken 0.000000
# result: 1
# time taken 0.000000

Leader看了,说每次调用函数岂不是要写很多重复代码吗。小A进行了优化:

import time


def add(x, y):
    start = time.time()
    rv = x + y
    end = time.time()
    print('time taken %f' % (end - start))
    return rv


def sub(x, y):
    start = time.time()
    rv = x - y
    end = time.time()
    print('time taken %f' % (end - start))
    return rv


if __name__ == '__main__':
    result_1 = add(1, 2)
    print('result: %d' % result_1)

    result_2 = sub(5, 4)
    print('result: %d' % result_2)
    
# 输出
# time taken 0.000000
# result: 3
# time taken 0.000000
# result: 1

这种方法肯定比前一种要好。但是当我们有多个函数时,那么这似乎就不方便了。

小A又定义了一个计时的函数并包装其他函数,然后返回包装后的函数:

import time


def time_taken(func):
    def inner(*args, **kwargs):
        start = time.time()
        rv = func(*args, **kwargs)
        end = time.time()
        print('time taken %f' % (end - start))
        return rv

    return inner


def add(x, y):
    return x + y


def sub(x, y):
    return x - y


if __name__ == '__main__':
    add = time_taken(add)  # 将函数作为参数传给另一个函数
    result_1 = add(1, 2)
    print('result: %d' % result_1)

    sub = time_taken(sub)
    result_2 = sub(5, 4)
    print('result: %d' % result_2)

# 输出:
# time taken 0.000000
# result: 3
# time taken 0.000000
# result: 1

Leader说上面的解决方案以及非常接近装饰器的思想了,小A查了一下装饰器的用法,加入装饰器后代码果然变得很优雅。

import time


def time_taken(func):
    def inner(*args, **kwargs):
        start = time.time()
        rv = func(*args, **kwargs)
        end = time.time()
        print('time taken %f' % (end - start))
        return rv
    return inner


@time_taken
# @time_taken等价于add = time_taken(add)
def add(x, y):
    return x + y


@time_taken
def sub(x, y):
    return x - y


if __name__ == '__main__':
    result_1 = add(1, 2)
    print('result: %d' % result_1)

    result_2 = sub(5, 4)
    print('result: %d' % result_2)

# 输出:
# time taken 0.000000
# result: 3
# time taken 0.000000
# result: 1

2 装饰器

2.1 装饰器的定义

装饰器本质上是一个 Python 函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计,有了装饰器,我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

2.2 给某个函数加上多个装饰器

import time


def logging(func):
    print('logging start')

    def inner(*args, **kwargs):
        print('logging.inner start')
        rv = func(*args, **kwargs)
        print('logging.inner end')
        return rv
    return inner


def time_taken(func):
    print('time_taken start')

    def inner(*args, **kwargs):
        print('time_taken.inner start')
        start = time.time()
        rv = func(*args, **kwargs)
        end = time.time()
        print('time taken %f' % (end - start))
        print('time_taken.inner end')
        return rv
    return inner


@logging
@time_taken
# 等价于 logging(time_taken(add))
def add(x, y):
    return x + y


if __name__ == '__main__':
    result = add(1, 2)
    print('result: %d' % result)

# 输出:
# time_taken start
# logging start
# logging.inner start
# time_taken.inner start
# time taken 0.000000
# time_taken.inner end
# logging.inner end
# result: 3

2.3 带参数的装饰器

2.3.1 闭包

在讲带参数的装饰器前,先简要介绍一下闭包的概念。如果在一个函数的内部定义了另一个函数,外部的我们叫它为外函数,内部的我们叫它为内函数。闭包: 在一个外函数中定义了一个内函数,内函数里运用了外函数的临时变量,并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

def f1():
    n = 999

    def f2():
        print(n)

    return f2


if __name__ == '__main__':
    result = f1()
    result()

# 输出:
# 999

函数 f2 被包括在函数 f1 内部,这时 f1 内部的所有局部变量,对 f2 都是可见的。 既然 f2 可以读取 f1 中的局部变量,那么只要把 f2 作为返回值,我们不就可以在 f1 外部读取它的内部变量了吗? 上一部分代码中的 f2函数,就是闭包 。

2.3.2 带参数的装饰器

def logging(func)是一个装饰器,如果装饰器需要参数,需要通过闭包来实现,即在其外面再定义一个外函数def mylog(type),将参数type作为外函数的的变量传递到内函数里面。

def mylog(type):
    def logging(func):
        def inner(*args, **kwargs):
            if type == 'debug':
                print('[DEBUG] logging')
            else:
                print('[INFO] logging')
            rv = func(*args, **kwargs)
            return rv
        return inner
    return logging


@mylog(type='debug')
def add(x, y):
    return x + y


if __name__ == '__main__':
    result = add(1, 2)
    print('result: %d' % result)
    
# 输出:
# [DEBUG] logging
# result: 3

2.4 类装饰器

2.4.1 不带参数的类装饰器

import time


class Timer:
    def __init__(self, func) -> None:
        self.func = func

    def __call__(self, *args, **kwargs):
        start = time.time()
        rv = self.func(*args, **kwargs)
        end = time.time()
        print('time taken %f' % (end - start))
        return rv


@Timer
# 等价于 add = Timer(add)
def add(x, y):
    return x + y


if __name__ == '__main__':
    result = add(2, 3)
    print('result: %d' % result)

# 输出:
# time taken 0.000000
# result: 5

上述相当于把一个装饰器变成了一个 Timer 类的对象,然后 add 函数被传入进了 __init__中,保存为self.func,在后面调用 add(2,3) 的时候,实际上相当于调用了__call__这个函数,做了一个对象的调用,后面参数2和3就被传入到了__call__里面,然后依顺序运行了代码。

2.4.2 带参数的类装饰器

import time


class Timer:
    def __init__(self, prefix) -> None:
        self.prefix = prefix

    def __call__(self, func):
        print('Timer.__call__')

        def wrapper(*args, **kwargs):
            start = time.time()
            ret = func(*args, **kwargs)
            print(f'{self.prefix}:{time.time() - start}')
            return ret

        return wrapper


@Timer(prefix='curr_time:')
# 等价于: add = Timer(prefix = 'curr_time:')(add)
def add(x, y):
    return x + y


if __name__ == '__main__':
    print(add(2, 3))

# 输出:
# Timer.__call__
# curr_time::0.0
# 5

上述把一个装饰器初始化为 Timer 类的对象,然后 prefix 参数被传入进了 __init__中,之后调用__call__函数返回一个闭包。之后就相当于装饰器函数了,用wrapper装饰add函数。

2.5 @wraps语法糖

因为装饰器实质是就是一个函数,是一个被修饰过函数,他与原来未被修饰的函数是两个不同的函数对象。所以,这个装饰器丢失了原来函数对象的一些属性,比如:name,__doc__等属性。

原始函数:

def add(x, y):
    """Add x and y"""
    return x + y


if __name__ == '__main__':
    print(add.__name__)
    print(add.__doc__)

# 输出:
# add
# Add x and y

使用装饰器后:

def logging(func):
    def inner(*args, **kwargs):
        """logging.inner"""
        if type == 'debug':
            print('[DEBUG] logging')
        else:
            print('[INFO] logging')
        rv = func(*args, **kwargs)
        return rv
    return inner


@logging
def add(x, y):
    """Add x and y"""
    return x + y


if __name__ == '__main__':
    print(add.__name__)
    print(add.__doc__)
    
# 输出:
# inner
# logging.inner

使用wraps语法糖可以保留原来函数的属性,@wraps(func)是个带参数的类装饰器

from functools import wraps


def logging(func):
    @wraps(func)
    def inner(*args, **kwargs):
        """logging.inner"""
        if type == 'debug':
            print('[DEBUG] logging')
        else:
            print('[INFO] logging')
        rv = func(*args, **kwargs)
        return rv
    return inner


@logging
def add(x, y):
    """Add x and y"""
    return x + y


if __name__ == '__main__':
    print(add.__name__)
    print(add.__doc__)

# 输出:
# add
# Add x and y

你可能感兴趣的:(python,python,开发语言)