讲 Python 装饰器前,我想先举个例子,虽有点污,但跟装饰器这个话题很贴切。

每个人都有的内裤主要功能是用来遮羞,但是到了冬天它没法为我们防风御寒,咋办?我们想到的一个办法就是把内裤改造一下,让它变得更厚更长,这样一来,它不仅有遮羞功能,还能提供保暖,不过有个问题,这个内裤被我们改造成了长裤后,虽然还有遮羞功能,但本质上它不再是一条真正的内裤了。于是聪明的人们发明长裤,在不影响内裤的前提下,直接把长裤套在了内裤外面,这样内裤还是内裤,有了长裤后宝宝再也不冷了。装饰器就像我们这里说的长裤,在不影响内裤作用的前提下,给我们的身子提供了保暖的功效。

谈装饰器前,还要先要明白一件事,Python 中的函数和 Java、C++不太一样,Python 中的函数可以像普通变量一样当做参数传递给另外一个函数,例如:

  1. def foo():
  2. print("foo")
  3.  
  4. def bar(func):
  5. func()
  6.  
  7. bar(foo)

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

先来看一个简单例子,虽然实际代码可能比这复杂很多:

  1. def foo():
  2. print('i am foo')

现在有一个新的需求,希望可以记录下函数的执行日志,于是在代码中添加日志代码:

  1. def foo():
  2. print('i am foo')
  3. logging.info("foo is running")

如果函数 bar()、bar2() 也有类似的需求,怎么做?再写一个 logging 在 bar 函数里?这样就造成大量雷同的代码,为了减少重复写代码,我们可以这样做,重新定义一个新的函数:专门处理日志 ,日志处理完之后再执行真正的业务代码

  1. def use_logging(func):
  2. logging.warn("%s is running" % func.__name__)
  3. func()
  4.  
  5. def foo():
  6. print('i am foo')
  7.  
  8. use_logging(foo)

这样做逻辑上是没问题的,功能是实现了,但是我们调用的时候不再是调用真正的业务逻辑 foo 函数,而是换成了 use_logging 函数,这就破坏了原有的代码结构, 现在我们不得不每次都要把原来的那个 foo 函数作为参数传递给 use_logging 函数,那么有没有更好的方式的呢?当然有,答案就是装饰器。

0x0 简单装饰器

  1. def use_logging(func):
  2.  
  3. def wrapper():
  4. logging.warn("%s is running" % func.__name__)
  5. return func() # 把 foo 当做参数传递进来时,执行func()就相当于执行foo()
  6. return wrapper
  7.  
  8. def foo():
  9. print('i am foo')
  10.  
  11. foo = use_logging(foo) # 因为装饰器 use_logging(foo) 返回的时函数对象 wrapper,这条语句相当于 foo = wrapper
  12. foo() # 执行foo()就相当于执行 wrapper()

use_logging 就是一个装饰器,它一个普通的函数,它把执行真正业务逻辑的函数 func 包裹在其中,看起来像 foo 被 use_logging 装饰了一样,use_logging 返回的也是一个函数,这个函数的名字叫 wrapper。在这个例子中,函数进入和退出时 ,被称为一个横切面,这种编程方式被称为面向切面的编程。

0x1 @ 语法糖

如果你接触 Python 有一段时间了的话,想必你对 @ 符号一定不陌生了,没错 @ 符号就是装饰器的语法糖,它放在函数开始定义的地方,这样就可以省略最后一步再次赋值的操作。

  1. def use_logging(func):
  2.  
  3. def wrapper():
  4. logging.warn("%s is running" % func.__name__)
  5. return func()
  6. return wrapper
  7.  
  8. @use_logging
  9. def foo():
  10. print("i am foo")
  11.  
  12. foo()

如上所示,有了 @ ,我们就可以省去foo = use_logging(foo)这一句了,直接调用 foo() 即可得到想要的结果。你们看到了没有,foo() 函数不需要做任何修改,只需在定义的地方加上装饰器,调用的时候还是和以前一样,如果我们有其他的类似函数,我们可以继续调用装饰器来修饰函数,而不用重复修改函数或者增加新的封装。这样,我们就提高了程序的可重复利用性,并增加了程序的可读性。

装饰器在 Python 使用如此方便都要归因于 Python 的函数能像普通的对象一样能作为参数传递给其他函数,可以被赋值给其他变量,可以作为返回值,可以被定义在另外一个函数内。

0x2 *args、**kwargs

可能有人问,如果我的业务逻辑函数 foo 需要参数怎么办?比如

  1. def foo(name):
  2. print("i am %s" % name)

我们可以在定义 wrapper 函数的时候指定参数:

  1. def wrapper(name):
  2. logging.warn("%s is running" % func.__name__)
  3. return func(name)
  4. return wrapper

这样 foo 函数定义的参数就可以定义在 wrapper 函数中。这时,又有人要问了,如果 foo 函数接收两个参数呢?三个参数呢?更有甚者,我可能传很多个。当装饰器不知道 foo 到底有多少个参数时,我们可以用 *args 来代替:

  1. def wrapper(*args):
  2. logging.warn("%s is running" % func.__name__)
  3. return func(*args)
  4. return wrapper

如此一来,甭管 foo 定义了多少个参数,我都可以完整地传递到 func 中去。这样就不影响 foo 的业务逻辑了。这时还有读者会问,如果 foo 函数还定义了一些关键字参数呢?比如:

  1. def foo(name, age=None, height=None):
  2. print("I am %s, age %s, height %s" % (name, age, height))

这时,你就可以把 wrapper 函数指定关键字函数:

  1. def wrapper(*args, **kwargs):
  2. # args是一个数组,kwargs一个字典
  3. logging.warn("%s is running" % func.__name__)
  4. return func(*args, **kwargs)
  5. return wrapper

0x3 带参数的装饰器

装饰器还有更大的灵活性,例如带参数的装饰器,在上面的装饰器调用中,该装饰器接收唯一的参数就是执行业务的函数 foo 。装饰器的语法允许我们在调用时,提供其它参数,比如@decorator(a)。这样,就为装饰器的编写和使用提供了更大的灵活性。比如,我们可以在装饰器中指定日志的等级,因为不同业务函数可能需要的日志级别是不一样的。

  1. def use_logging(level):
  2. def decorator(func):
  3. def wrapper(*args, **kwargs):
  4. if level == "warn":
  5. logging.warn("%s is running" % func.__name__)
  6. elif level == "info":
  7. logging.info("%s is running" % func.__name__)
  8. return func(*args)
  9. return wrapper
  10.  
  11. return decorator
  12.  
  13. @use_logging(level="warn")
  14. def foo(name='foo'):
  15. print("i am %s" % name)
  16.  
  17. foo()

上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装,并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候,Python 能够发现这一层的封装,并把参数传递到装饰器的环境中。

  1. # @use_logging(level="warn")等价于@decorator

0x4 类装饰器

没错,装饰器不仅可以是函数,还可以是类,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法,当使用 @ 形式将装饰器附加到函数上时,就会调用此方法。

  1. class Foo(object):
  2. def __init__(self, func):
  3. self._func = func
  4.  
  5. def __call__(self):
  6. print ('class decorator runing')
  7. self._func()
  8. print ('class decorator ending')
  9.  
  10. @Foo
  11. def bar():
  12. print ('bar')
  13.  
  14. bar()

0x5 functools.wraps

使用装饰器极大地复用了代码,但是他有一个缺点就是原函数的元信息不见了,比如函数的docstring__name__、参数列表,先看例子:

  1. # 装饰器
  2. def logged(func):
  3. def with_logging(*args, **kwargs):
  4. print func.__name__ # 输出 'with_logging'
  5. print func.__doc__ # 输出 None
  6. return func(*args, **kwargs)
  7. return with_logging
  8.  
  9. # 函数
  10. @logged
  11. def f(x):
  12. """does some math"""
  13. return x + x * x
  14.  
  15. logged(f)

不难发现,函数 f 被with_logging取代了,当然它的docstring__name__就是变成了with_logging函数的信息了。好在我们有functools.wrapswraps本身也是一个装饰器,它能把原函数的元信息拷贝到装饰器里面的 func 函数中,这使得装饰器里面的 func 函数也有和原函数 foo 一样的元信息了。

  1. from functools import wraps
  2. def logged(func):
  3. @wraps(func)
  4. def with_logging(*args, **kwargs):
  5. print func.__name__ # 输出 'f'
  6. print func.__doc__ # 输出 'does some math'
  7. return func(*args, **kwargs)
  8. return with_logging
  9.  
  10. @logged
  11. def f(x):
  12. """does some math"""
  13. return x + x * x

0x6 装饰器顺序

一个函数还可以同时定义多个装饰器,比如:

  1. @a
  2. @b
  3. @c
  4. def f ():
  5. pass

它的执行顺序是从里到外,最先调用最里层的装饰器,最后调用最外层的装饰器,它等效于

  1. f = a(b(c(f)))

请看如下代码

  1. def one(func):
  2. print('----1----')
  3. def two():
  4. print('----2----')
  5. func()
  6. return two
  7.  
  8. def a(func):
  9. print('----a----')
  10. def b():
  11. print('----b----')
  12. func()
  13. return b
  14.  
  15. @one
  16. @a
  17. def demo():
  18. print('----3----')
  19.  
  20. demo()

得到结果:

  1. ----a----
  2. ----1----
  3. ----2----
  4. ----b----
  5. ----3----

参考

Python面试题之装饰器漫谈的更多相关文章

  1. Python中利用函数装饰器实现备忘功能

    Python中利用函数装饰器实现备忘功能 这篇文章主要介绍了Python中利用函数装饰器实现备忘功能,同时还降到了利用装饰器来检查函数的递归.确保参数传递的正确,需要的朋友可以参考下   " ...

  2. python函数与方法装饰器

    之前用python简单写了一下斐波那契数列的递归实现(如下),发现运行速度很慢. def fib_direct(n): assert n > 0, 'invalid n' if n < 3 ...

  3. guxh的python笔记三:装饰器

    1,函数作用域 这种情况可以顺利执行: total = 0 def run(): print(total) 这种情况会报错: total = 0 def run(): print(total) tot ...

  4. python设计模式之内置装饰器使用(四)

    前言 python内部有许多内建装饰器,它们都有特别的功能,下面对其归纳一下. 系列文章 python设计模式之单例模式(一) python设计模式之常用创建模式总结(二) python设计模式之装饰 ...

  5. python 3.x 的装饰器笔记

    今天学到了python的装饰器,感觉这个东西还是稍微有些复杂,所以记录下来,方便以后的查找.虽然标题是python 3.x的装饰器,但是我也没有怎么用过python 2.x,感觉上应该是和python ...

  6. python 中多个装饰器的执行顺序

    python 中多个装饰器的执行顺序: def wrapper1(f1): print('in wrapper1') def inner1(*args,**kwargs): print('in inn ...

  7. Python函数编程——闭包和装饰器

    Python函数编程--闭包和装饰器 一.闭包 关于闭包,即函数定义和函数表达式位于另一个函数的函数体内(嵌套函数).而且,这些内部函数可以访问它们所在的外部函数中声明的所有局部变量.参数.当其中一个 ...

  8. python基础-内置装饰器classmethod和staticmethod

    面向对象编程之classmethod和staticmethod classmethod 和 staticmethod都是python内置的装饰器 classmethod 的作用:给在类内部定义的方法装 ...

  9. Python 入门之 Python三大器 之 装饰器

    Python 入门之 Python三大器 之 装饰器 1.开放封闭原则: (1)代码扩展进行开放 ​ 任何一个程序,不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改.所以我们必须允许代 ...

随机推荐

  1. css中:hover空格

    前面有空格后代所有节点,前面无空格第一个节点 <div class="task-item"> <span><input type="chec ...

  2. Supervisor(Linux/Unix进程管理工具)安装与配置

    参考链接:https://blog.csdn.net/xyang81/article/details/51555473 Supervisor(http://supervisord.org/)是用Pyt ...

  3. Cloudstack云平台实践

    laaS平台的虚拟化 利用率高 资源整合 节约电能 节约空间 灾难恢复 CloudStack是一个开源的具有高可用性及扩展性的云计算平台.支持管理大部分主流的hypervisor,如KVM虚拟机,Xe ...

  4. 对于Python中回调函数的理解

    关于回调函数,网上有很多说明和各种解释,多数在尝试用语言描述.我认为,如果对各个角色之间的关系不清楚,如果没有相关的编程需求,那么语言便非常无力,很难理解. 这是360百科的解释: 在计算机程序设计中 ...

  5. Chrome浏览器扩展 获取用户密码

    Chrome 浏览器允许安装第三方扩展程序以扩展浏览器并给浏览器加入新的功能,扩展使用 JavaScript 以及 HTMl 编写并允许互相访问和控制 DOM. 因为允许访问 DOM,攻击者就可以读取 ...

  6. https://validator.w3.org

    https://validator.w3.org/nu/?doc=http%3A%2F%2Fdev.mysql.com%2Fdoc%2Frefman%2F5.7%2Fen%2Fmanual-info. ...

  7. curl获取公网IP地址

    curl ip.cn curl cip.cc https://blog.csdn.net/orangleliu/article/details/51994513 https://blog.csdn.n ...

  8. FS Shell命令手册

    1.       FS Shell 1.1     简介 调用文件系统(FS)Shell命令应使用 bin/hadoop fs <args>的形式. 所有的的FS shell命令使用URI ...

  9. UIPageViewController基本使用

    UIPageViewController基本使用 @interface ViewController ()<UIPageViewControllerDelegate,UIPageViewCont ...

  10. Ubuntu搭建solr搜索服务器

    参考:http://blog.csdn.net/makang110/article/details/50971705 一:搭建solr服务器 1:安装jdk1.7,并配置环境变量 2:下载tomcat ...