Python 装饰器

作者 耿嘉豪 日期 2018-04-13 阅读量 次
Python
Python 装饰器

装饰器

面向切面的编程范式(Aspect-Oriented Programming - AOP)

在运行时, 动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程, 更通俗一点就是通过在现有代码中添加额外行为而不修改代码本身。

装饰器概念

内裤可以用来遮羞, 但是只穿内裤会冷, 我们还需要在外面再穿上长裤, 装饰器就相当于长裤, 在不影响内裤作用的前提下, 为我们提供了额外的保暖的效果。

装饰器本质上是一个 Python 函数, 它可以让其它函数在不需要做任何代码变动的前提下增加额外的功能, 装饰器的返回值也是一个函数对象(函数的指针)。概括地讲, 装饰器的作用就是为已经存在的对象添加额外的功能。

装饰器经常用于有切面需求的场景, 比如: 插入日志、性能测试、事务处理、缓存、权限校验等场景。装饰器是解决这类问题的绝佳设计, 有了装饰器, 我们就可以抽离出大量与函数功能本身无关的雷同代码并实现重用。(参考于知乎用户“刘志军的回答”)

装饰器的实现

首先我们有下面这两个函数:

def func1():
    print('inside func1()')
    return 1

def func2():
    print('inside func2()')
    return 2

现在我们有了一个新的需求, 我们需要在函数 func1() 和 func2() 的结尾处打印出当前时间:

from datetime import datetime


def func1():
    print('inside func1()')
    print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    return 1

def func2():
    print('inside func2()')
    print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    return 2

通过上面的代码我们实现了在 func1() 和 func2() 中打印时间的需求, 但是这样处理有以下几个问题:

1.如果现在有 func3()、fun4()….或者更多的函数都需要实现这个需求怎么办呢？如果每个函数都增加这部分逻辑的代码, 不仅工作量大写起来麻烦, 还会让函数主体内容改变, 但通常我们希望保持函数的逻辑不受影响。

2.现在只是打印当前时间这个简单的需求, 如果需要实现一个比较复杂的功能增加的就远远不止这一行代码。

3.代码的维护问题。如果某天这个需求改变了, 那么每个用到它的地方都需要改变, 这样就很容易出现遗漏或者错误。

我们需要把需求抽象出来。

def do(func):
    rs = func()
    print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    return rs

In: do(func1)
Out:
inside func1()
2018-04-12 21:16:19

上面的代码中实现了一个 do() 函数, 我们可以把函数作为参数传入进去实现功能, 但这种处理方法的问题是: 现在已经不是在调用 func1() 了,而是调用了 do() 函数传递了 func1()。

我们需要在调用 func1() 的时候实现需求, 我们需要用到 工厂函数, 工厂函数定义了一个外部的函数, 这个函数生成并返回一个内嵌的函数, 仅仅是返回却不调用, 因此通过调用工厂函数, 可以得到内嵌函数的一个引用。

def do(func):
    def wrapper():
        rs = func()
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        return rs
    return wrapper

In: func1 = do(func1)

In: func1()

Out:
inside func1()
2018-04-12 21:21:47
1

In: func1
Out: <function do.<locals>.wrapper at 0x0000021924431F28>

上面代码的 do() 函数返回的是一个函数, func1() 经过 do() 函数的处理, 实现了需求的添加, 这样就能在执行 func1() 时打印当前时间了, 这就是装饰器的概念。

在 Java 中装饰器是一种设计模式, 而在 Python 中原生支持了这一设计模式, 可以使用如下代码实现:

def do(func):
    def wrapper():
        rs = func()
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        return rs
    return wrapper

@do # 等于 func1 = do(func1)
def func1():
    print('inside func1()')
    return 1

In: func1()
Out:
inside func1()
2018-04-12 21:29:14
1

In: func1
Out: <function do.<locals>.wrapper at 0x0000011FBAA5D620>

@ 符号是装饰器的语法糖, 语法糖是指计算机语言中添加的某种语法, 这种语法对语言的功能没有影响, 但是更方便程序员使用。语法糖让程序更加简洁, 增强可读性。

使用装饰器的好处

  1. 降低模块的耦合度。在现有代码中添加额外的行为而不影响代码本身。

  2. 使系统容易扩展。

  3. 更好地代码复用性。

functools.wraps

from datetime import datetime


def func1():
    '''func1 doc '''
    print('inside func1()')
    return 1

def do(func):
    def wrapper():
        rs = func()
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        return rs
    return wrapper

print(func1.__name__) # 函数的名字
# 输出 func1

print(func1.__module__) # 函数所在的模块文件
# 输出 __main__

print(func1.__doc__) # 帮助文档, 指向函数、方法、类内部第一个没有被赋值的字符串
# 输出 func1 doc

func1 = do(func1)

print(func1.__name__)
# 输出 wrapper

print(func1.__module__)
# 输出 __main__

print(func1.__doc__)
# 输出 None

上面的代码中, func1() 使用 do() 装饰后, name 改变了, module 没改变(这是因为在同一个模块中, 如果装饰器的函数在其它模块中, 那么这个 module 属性也会改变), doc 变成了 None, 这样的话, 如果需要排错或者函数执行的时候, 就不能获得正确的原函数的正确属性了。

Python 提供了 wraps 实现了使用装饰器后保留原函数的属性, 下面是它的使用方法:

from datetime import datetime
from functools import wraps

def func1():
    '''func1 doc '''
    print('inside func1()')
    return 1

def do(func):
    @wraps(func)
    def wrapper():
        rs = func()
        print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
        return rs
    return wrapper

print(func1.__name__)
# 输出 func1

print(func1.__module__)
# 输出 __main__

print(func1.__doc__)
# 输出 func1 doc

func1 = do(func1)

print(func1.__name__)
# 输出 func1

print(func1.__module__)
# 输出 __main__

print(func1.__doc__)
# 输出 func1 doc

可以看到通过 wraps() 函数的处理, 就消除了装饰器的副作用。

给函数的类装饰器

相比函数装饰器, 类装饰器具有灵活度大、高内聚、封装性等特点。使用类装饰器可以依靠类内部的 __call__ 方法, 当使用 @ 形式将装饰器附加到函数上时, 就会调用此方法。类装饰器适合用在复杂的添加额外行为上。

class Common():
    def __init__(self, func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print(f'args: {args}')
        return self.func(*args, **kwargs)


@Common
def fun(num):
    print(f'Number: {num}')


fun(10) # 相当于 Common(test)(10)
# 输出:
args: (10,)
Number: 10

使用函数装饰器实现上面的支持参数的功能可以这样写:

def common(func):
    def wrapper(*args, **kwargs):
        print(f'args: {args}')
        return func(*args, **kwargs)
    return wrapper


common(fun)(10)
# 输出
# args: (10,)
# Number: 10

print(common(fun))
# 输出 <function common.<locals>.wrapper at 0x0000027D88F2D620>

给类用的函数装饰器

def borg(cls):
    cls._state = {}
    orig_init = cls.__init__
    def new_init(self, *args, **kwargs):
        self.__dict__ = cls._state
        orig_init(self, *args, **kwargs)
    cls.__init__ = new_init
    return cls


@borg
class A():
    def common(self):
        print(hex(id(self)))


a, b = A(), A()

b.d = 1

print(a.d)
# 输出 1

a.common()
# 输出 0x2785e11a748

b.common()
# 输出 0x2785e11a748

带参数的装饰器

装饰器还有更大的灵活性, 例如带参数的装饰器, 在之前的代码中, 装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时, 提供其它的参数, 比如 @common('abc')。这样, 就为装饰器的编写和使用提供了更大的灵活性。

def common(*args, **kw):
    a = args
    def _common(func):
        def _deco(*args, **kwargs):
            print(f'args: {args} {a}')
            return func(*args, **kwargs)
        return _deco
    return _common


@common('abc')
def fun(num):
    print(f'Number: {num}')


fun(10) # 相当于 common('abc')(test)(10)
# 输出:
# args: (10,) ('abc',)
# Number: 10
FEATURED TAGS
Python