python 装饰器详解

最新推荐文章于 2024-08-18 00:33:07 发布

sandorn

最新推荐文章于 2024-08-18 00:33:07 发布

阅读量1.1k

点赞数 1

分类专栏： python 文章标签： python 开发语言

原文链接：http://www.manongjc.com/article/44189.html

版权

python 专栏收录该内容

50 篇文章 1 订阅

订阅专栏

python 装饰器详解

时间:2019-01-14

转自：python 装饰器详解 - 码农教程

本文章向大家介绍python 装饰器详解，主要包括python 装饰器详解使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

4、不支持带参数的被装饰函数的装饰器不是好装饰器

5、不支持有返回值的被装饰函数的装饰器不是好装饰器

6、有没有更骚的操作？

四、内置装饰器

五、装饰器的调用顺序

一、装饰器遵循的原则

装饰器，顾名思义就是起装饰的作用，既然是装饰，那么被装饰的对象是啥样就是啥样，不能有丝毫改变。在这里，我们写装饰器就是必须把握不能修改被修饰函数的源代码这条铁律。如何遵循这条铁律，我们还需还需做一些铺垫，必须先要了解四个概念，如下：

1、函数名即‘“变量”

在python中，函数名其实就像是c语言的函数指针，代表的是我们的函数地址，只有解释器获取到这个地址，它才会去执行这块内存的代码。因此，本质上，函数名就和不同变量没什么区别，只不过函数名和普通变量所指代的那块内存的使用方式不同罢了，这些都是底层解释器的机制所决定的，对于程序猿来说，都是透明的，所以，我们可以认为两者是没有区别的。

2、高阶函数

什么是高阶函数其实很简单，把握两个原则就好：

形式参数有函数名
返回值有函数名

只要满足这两个原则之一，就可以称之为是高阶函数。翻回头来看，这里出现了我们上面说的函数名，仔细体会一下，我们在这里不就是把其当成实参看待的吗？

3、嵌套函数

什么是嵌套函数其实也非常简单，把握一个原则就好：

在一个函数的函数体中去定义另一个函数

在这里需要强调的是，函数定义时是不会执行函数体的，就和定义变量是不会去读取变量里的内容一样。这一点至关重要，对于我们理解装饰器实现原理非常有帮助。

4、闭包

所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时得到的对象，它的主要作用是封存上下文。这一特性可以巧妙的被用于现有函数的包装，从而为现有函数添加功能，这就是装饰器。

二、装饰器介绍

python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。装饰器函数的外部函数传入我要装饰的函数名字，返回经过修饰后函数的名字；内层函数（闭包）负责修饰被修饰函数。从上面这段描述中我们需要记住装饰器的几点属性，以便后面能更好的理解：

　　　　实质：是一个函数

　　　　参数：是你要装饰的函数名（并非函数调用）

　　　　返回：是装饰完的函数名（也非函数调用）

　　　　作用：为已经存在的对象添加额外的功能

　　　　特点：不需要对对象做任何的代码上的变动

装饰器 = 高阶函数 + 函数嵌套 + 闭包

python装饰器有很多经典的应用场景，比如：插入日志、性能测试、事务处理、权限校验等。装饰器是解决这类问题的绝佳设计。并且从引入中的列子中我们也可以归纳出：装饰器最大的作用就是对于我们已经写好的程序，我们可以抽离出一些雷同的代码组建多个特定功能的装饰器，这样我们就可以针对不同的需求去使用特定的装饰器，这时因为源码去除了大量泛化的内容而使得源码具有更加清晰的逻辑。

三、装饰器实例

1、从最简单的装饰器做起

首先明确一下需求，我们有时候会需要在函数调用时打印一个相应的日志，虽然可以通过在所有需要打印日志的函数代码中嵌入打印日志的代码来实现，但这种方法不仅增加了许多重复代码，而且在业务代码中嵌入与业务无关的代码增加了整体的耦合度。因此，我们需要实现一个装饰器，这个装饰器在函数调用时可以打印一个日志记录函数调用行为。

如果我们有以下函数foo，代表具体的业务函数：

def foo():
  print('in function foo')

我们设想通过调用foo = deco(foo)实现给函数foo增加打印日志的功能，并且不影响它原有的业务。那么在这种设想下，装饰器deco应该也是一个函数，它接收另一个函数作为输入，并返回一个新的、经过装饰的函数。在Python中，我们可以这么写：

def deco(func): # 接收一个函数作为参数
  def new_func():
    print(f'[log] run function {func.__name__}') # 此处使用了Python3.6的格式化字符串
    func() # 闭包，在内部函数中使用了外部函数的变量
  return new_func # 将新函数作为返回值返回

执行一下试试效果：

>>> foo = deco(foo)
>>> foo()
[log] run function foo
in function foo

不错，至此我们已经实现了一个最简单的装饰器！在上面的代码中，装饰器deco接收任意的函数作为参数，再在内部构造另一个函数，利用闭包的特性，可以在新函数里调用存在于装饰器deco局部作用域中的函数func。

2、神奇的@

按照上面那么写，每次我们都得为需要装饰的函数赋一个新值，万一函数或者装饰器的数量增加了，手动写赋值和函数调用就会变得非常麻烦。那么在Python中，有没有更优雅的写法呢？答案是有的，你只需要一个@符号。

在Python中，当我们需要一个装饰器时：

def deco(func):
  def new_func():
    print(f'[log] run function {func.__name__}')
    func()
  return new_func

@deco
def foo():
  print('in function foo')

这个地方我们省略了函数的赋值，直接在函数foo定义的上一行加上@deco进行装饰。运行一下试试看：

>>> foo()
[log] run function foo
in function foo

是不是感觉很神奇？其实这里面没什么魔法，只不过是Python在处理函数定义的代码时，帮你在其中把foo=deco(foo)的逻辑加上了而已。

3、装饰器也想要参数

上面的代码实现了在业务函数调用之前打印日志的功能，那如果我们需要在业务代码执行完之后打印一条自定义的消息，怎么办呢？我们必须要让我们的装饰器可以接收自定义参数。

上面提到过，Python做的只是当写了@deco时，把调用deco(func)的结果赋值给它装饰的函数而已。顺着这个逻辑，当我们需要一个带参数的装饰器时，代码上应该是写为@deco('some message')，这时Python将调用deco(msg)(func)的结果赋值给foo。那么事情就变得简单了，我们只需要在上面代码的基础上嵌套一层函数：

def deco(msg):
  def inner_deco(func):
    def new_func():
      print(f'[log] run function {func.__name__}')
      func()
      print(f'[log] {msg}')
    return new_func
  return inner_deco

@deco('some message')
def foo():
  print('in function foo')

执行一下试试：

>>> foo()
[log] run function foo
in function foo
[log] some message

4、不支持带参数的被装饰函数的装饰器不是好装饰器

上面的代码还是有问题，因为我们只考虑了函数foo没有参数时的情况，万一函数foo带了参数，这个装饰器就会丢失参数信息，这不是一个合格的装饰器应该出现的情况。所以，我们借助Python中的*args和**kwargs使被装饰的函数可以支持传入任意参数：

def deco(msg):
  def inner_deco(func):
    def new_func(*args, **kwargs):
      print(f'[log] run function {func.__name__}')
      func(*args, **kwargs)
      print(f'[log] {msg}')
    return new_func
  return inner_deco

@deco('some message')
def foo(a, b=None):
  print('in function foo')
  print(f'a is {a} & b is {b}')

这样一来，无论函数foo的参数列表是怎么样的都不会有问题了：

>>> foo('hello')
[log] run function foo
in function foo
a is hello & b is None
[log] some message

5、不支持有返回值的被装饰函数的装饰器不是好装饰器

别忘了，到目前为止，我们写的函数foo都没有返回值，如果函数foo有返回值怎么办呢？我想你心里应该有答案了：

def deco(msg):
  def inner_deco(func):
    def new_func(*args, **kwargs):
      print(f'[log] run function {func.__name__}')
      rlt = func(*args, **kwargs)
      print(f'[log] {msg}')
      return rlt
    return new_func
  return inner_deco

@deco('some message')
def foo(a, b=None):
  print('in function foo')
  print(f'a is {a} & b is {b}')
  return 'ok'

由于装饰器在原函数执行完之后还有别的操作，所以应该把返回值暂存起来，等到装饰器的逻辑执行完毕，才返回最终结果。这就是我们的最终版装饰器了！

>>> rlt = foo('a')
[log] run function foo
in function foo
a is a & b is None
[log] some message
>>> print(rlt)
ok

6、有没有更骚的操作？

当然有啊！我标题都这么写了难不成会没有？

在Python中，你可以使用类来作为装饰器：

class Deco(object):
  def __call__(self, func):
    def new_func():
      print(f'[log] run function {func.__name__}')
      func()
    return new_func

@Deco()
def foo():
  print('in function foo')
>>> foo()
[log] run function foo
in function foo

这么做的好处就是可以利用类更好地管理参数和调用逻辑，比起之前三层函数嵌套的形式是不是清晰多了？

在Python中，你还可以使用装饰器来装饰一个类，比如这样：

def add_doc(doc):
  def deco(cls):
    cls.__doc__ = doc
    return cls
  return deco

@add_doc('this is the doc of Cls')
class Cls(object):
  pass

来看看效果：

>>> help(Cls)
Help on class Cls in module __main__:

class Cls(builtins.object)
 | this is the doc of Cls

上面的代码只是一个示例，展示装饰器怎么装饰一个类而已，不是说在实际情况下应该这么用。大部分的情况下，我们对于类的拓展应该是通过继承而不是装饰。

具体怎么巧妙地利用装饰器就要靠大家发挥自己的想象力了。

四、内置装饰器

在Python中有三个内置的装饰器，都与class相关：

1）staticmethod：类静态方法，其根跟成员方法的区别是没有self参数，并且可以在类不进行实例化的情况下调用。

2）classmethod：与成员方法的区别在于所接收的第一个参数不是self（类实例的指针），而是cls（当前类的具体类型）。

3）property：属性的意思，表示可以通过类实例直接访问的信息。

class Test(object):
	def __init__(self,name):
		self._name = name
 
	@staticmethod
	def newTest1(name):
		return Test(name)
 
	@classmethod
	def newTest2(cls):
		return Test('')
 
	@property
	def name(self):
		return self._name

五、装饰器的调用顺序

装饰器是可以叠加使用的，那么这就涉及到装饰器的调用顺序。对于Python中的“@”语法糖，装饰器的调用顺序与使用@语法糖的声明顺序相反。


# 装饰器的声明顺序
 
@a
@b
@c
def f():
    pass
# 等效于
f = a(b(c(f)))    # 以c、b、a的顺序调用

从不浪费时间的人，没有工夫抱怨时间不够。

sandorn

关注

1
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录