资讯专栏INFORMATION COLUMN

Python知识点:理解和使用装饰器 @decorator

cyqian / 894人阅读

摘要:使用类装饰器,优点是灵活性大,高内聚,封装性。不过不用担心,有,本身也是一个装饰器,它的作用就是把原函数的元信息拷贝到装饰器函数中,使得装饰器函数也有和原函数一样的元信息。


Python的装饰器(decorator)是一个很棒的机制,也是熟练运用Python的必杀技之一。装饰器,顾名思义,就是用来装饰的,它装饰的是一个函数,保持被装饰函数的原有功能,再装饰上(添油加醋)一些其它功能,并返回带有新增功能的函数对象,所以装饰器本质上是一个返回函数对象的函数(确切的说,装饰器应该是可调用对象,除了函数,类也可以作为装饰器)。

在编程过程中,我们经常遇到这样的场景:登录校验,权限校验,日志记录等,这些功能代码在各个环节都可能需要,但又十分雷同,通过装饰器来抽象、剥离这部分代码可以很好解决这类场景。

装饰器是什么?

要理解Python的装饰器,首先我们先理解一下Python的函数对象。我们知道,在Python里一切都是对象,函数也不例外,函数是第一类对象(first-class objects),它可以赋值给变量,也可以作为list的元素,还可以作为参数传递给其它函数。

函数可以被变量引用

定义一个简单的函数:

</>复制代码

  1. def say_hi():
  2. print("Hi!")
  3. say_hi()
  4. # Output: Hi!

我们可以通过另外一个变量say_hi2来引用say_hi函数:

</>复制代码

  1. say_hi2 = say_hi
  2. print(say_hi2)
  3. # Output:
  4. say_hi2()
  5. # Output: Hi!

上面的语句中say_hi2 和 say_hi 指向了同样的函数定义,二者的执行结果也相同。

函数可以作为参数传递给其它函数

</>复制代码

  1. def say_more(say_hi_func):
  2. print("More")
  3. say_hi_func()
  4. say_more(say_hi)
  5. # Output:
  6. # More
  7. # Hi

在上面的例子中,我们把say_hi函数当做参数传递给say_more函数,say_hi 被变量 say_hi_func 引用。

函数可以定义在其它函数内部

</>复制代码

  1. def say_hi():
  2. print("Hi!")
  3. def say_name():
  4. print("Tom")
  5. say_name()
  6. say_hi()
  7. # Output:
  8. # Hi!
  9. # Tom
  10. say_name() # 报错

上述代码中,我们在say_hi()函数内部定义了另外一个函数say_name()。say_name()只在say_hi函数内部可见(即,它的作用域在say_hi函数内部),在say_hi外包调用时就会出错。

函数可以返回其它函数的引用

</>复制代码

  1. def say_hi():
  2. print("Hi!")
  3. def say_name():
  4. print("Tom")
  5. return say_name
  6. say_name_func = say_hi()
  7. # 打印Hi!,并返回say_name函数对象
  8. # 并赋值给say_name_func
  9. say_name_func()
  10. # 打印 Tom

上面的例子,say_hi函数返回了其内部定义的函数say_name的引用。这样在say_hi函数外部也可以使用say_name函数了。

前面我们理解了函数,这有助于我们接下来弄明白装饰器。

装饰器(Decorator)

装饰器是可调用对象(callable objects),它用来修改函数或类。
可调用对象就是可以接受某些参数并返回某些对象的对象。Python里的函数和类都是可调用对象。

函数装饰器,就是接受函数作为参数,并对函数参数做一些包装,然后返回增加了包装的函数,即生成了一个新函数。

让我们看看下面这个例子:

</>复制代码

  1. def decorator_func(some_func):
  2. # define another wrapper function which modifies some_func
  3. def wrapper_func():
  4. print("Wrapper function started")
  5. some_func()
  6. print("Wrapper function ended")
  7. return wrapper_func # Wrapper function add something to the passed function and decorator returns the wrapper function
  8. def say_hello():
  9. print ("Hello")
  10. say_hello = decorator_func(say_hello)
  11. say_hello()
  12. # Output:
  13. # Wrapper function started
  14. # Hello
  15. # Wrapper function ended

上面例子中,decorator_func 就是定义的装饰器函数,它接受some_func作为参数。它定义了一个wrapper_func函数,该函数调用了some_func但也增加了一些自己的代码。

上面代码中使用装饰器的方法看起来有点复杂,其实真正的装饰器的Python语法是这样的:

装饰器的Python语法

</>复制代码

  1. @decorator_func
  2. def say_hi():
  3. print "Hi!"

@ 符合是装饰器的语法糖,在定义函数say_hi时使用,避免了再一次的赋值语句。
上面的语句等同于:

</>复制代码

  1. def say_hi():
  2. print "Hi!"
  3. say_hi = decorator_func(say_hi)

装饰器的顺序

</>复制代码

  1. @a
  2. @b
  3. @c
  4. def foo():
  5. print("foo")
  6. # 等同于:
  7. foo = a(b(c(foo)))

带参数函数的装饰器

</>复制代码

  1. def decorator_func(some_func):
  2. def wrapper_func(*args, **kwargs):
  3. print("Wrapper function started")
  4. some_func(*args, **kwargs)
  5. print("Wrapper function ended")
  6. return wrapper_func
  7. @decorator_func
  8. def say_hi(name):
  9. print ("Hi!" + name)

上面代码中,say_hi函数带有一个参数。通常情况下,不同功能的函数可以有不同类别、不同数量的参数,在写wrapper_func的时候,我们不确定参数的名称和数量,可以通过args 和 *kwargs 来引用函数参数。

带参数的装饰器

不仅被装饰的函数可以带参数,装饰器本身也可以带参数。参考下面的例子:

</>复制代码

  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. return func(*args)
  7. return wrapper
  8. return decorator
  9. @use_logging(level="warn")
  10. def foo(name="foo"):
  11. print("i am %s" % name)

简单来说,带参数的装饰器就是在没有参数的装饰器外面再嵌套一个参数的函数,该函数返回那个无参数装饰器即可。

类作为装饰器

前面我们提到装饰器是可调用对象。在Python里面,除了函数,类也是可调用对象。使用类装饰器,优点是灵活性大,高内聚,封装性。通过实现类内部的__call__方法,当使用 @ 语法糖把装饰器附加到函数上时,就会调用此方法。

</>复制代码

  1. class Foo(object):
  2. def __init__(self, func):
  3. self._func = func
  4. def __call__(self):
  5. print ("class decorator runing")
  6. self._func()
  7. print ("class decorator ending")
  8. @Foo
  9. def say_hi():
  10. print("Hi!")
  11. say_hi()
  12. # Output:
  13. # class decorator running
  14. # Hi!
  15. # class decorator ending
  16. functools.wraps

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

</>复制代码

  1. def decorator_func(some_func):
  2. def wrapper_func(*args, **kwargs):
  3. print("Wrapper function started")
  4. some_func(*args, **kwargs)
  5. print("Wrapper function ended")
  6. return wrapper_func
  7. @decorator_func
  8. def say_hi(name):
  9. """Say hi to somebody"""
  10. print ("Hi!" + name)
  11. print(say_hi.__name__) # Output: wrapper_func
  12. print(say_hi.__doc__) # Output: None

可以看到,say_hi函数被wrapper_func函数取代,它的__name__ 和 docstring 也自然是wrapper_func函数的了。
不过不用担心,Python有functools.wraps,wraps本身也是一个装饰器,它的作用就是把原函数的元信息拷贝到装饰器函数中,使得装饰器函数也有和原函数一样的元信息。

</>复制代码

  1. from functools import wraps
  2. def decorator_func(some_func):
  3. @wraps(func)
  4. def wrapper_func(*args, **kwargs):
  5. print("Wrapper function started")
  6. some_func(*args, **kwargs)
  7. print("Wrapper function ended")
  8. return wrapper_func
  9. @decorator_func
  10. def say_hi(name):
  11. """Say hi to somebody"""
  12. print ("Hi!" + name)
  13. print(say_hi.__name__) # Output: say_hi
  14. print(say_hi.__doc__) # Output: Say hi to somebody

类的内置装饰器

类属性@property
静态方法@staticmethod
类方法@classmethod

通常,我们需要先实例化一个类的对象,再调用其方法。
若类的方法使用了@staticmethod或@classmethod,就可以不需要实例化,直接类名.方法名()来调用。
从使用上来看,@staticmethod不需要指代自身对象的self或指代自身类的cls参数,就跟使用普通函数一样。@classmethod不需要self参数,但第一个参数必须是指代自身类的cls参数。如果在@staticmethod中要调用到这个类的一些属性方法,只能直接类名.属性名,或类名.方法名的方式。
而@classmethod因为持有cls参数,可以来调用类的属性,类的方法,实例化对象等。

总结

通过认识Python的函数,我们逐步弄清了装饰器的来龙去脉。装饰器是代码复用的好工具,在编程过程中可以在适当的场景用多多使用。

我在我的个人博客“猿人学网站”和公众号“猿人学Python”上写Python教程,有兴趣的可以关注公众号和网站。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/43643.html

相关文章

  • Python 装饰使用指南

    摘要:装饰器是可调用的对象,其参数是另一个函数被装饰的函数。第二大特性是,装饰器在加载模块时立即执行。另一个常见的装饰器是,它的作用是协助构建行为良好的装饰器。 装饰器是可调用的对象,其参数是另一个函数(被装饰的函数)。 装饰器基础知识 首先看一下这段代码 def deco(fn): print I am %s! % fn.__name__ @deco def func(): ...

    NeverSayNever 评论0 收藏0
  • Python 函数式编程、装饰以及一些相关概念简介

    摘要:重写內建名字空间中的函数闭包闭包是词法闭包的简称。另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。 Python 中的 Decorator(装饰器) 是对一个函数或者方法的封装,从而使其可以完成一些与自身功能无关的工作。 预备知识 一切皆对象 在 Python 中,所有的一切都被视为对象,任何的变量、函数、类等都是 object 的子类。因此除了变量之外,函数和类等也可以...

    Jinkey 评论0 收藏0
  • 简单理解Python装饰

    摘要:下面我们一起抛去无关概念,简单地理解下的装饰器。用函数实现装饰器装饰器要求入参是函数对象,返回值是函数对象,嵌套函数完全能胜任。为了对调用方透明,装饰器返回的对象要伪装成被装饰的函数。 来源:http://www.lightxue.com/under...        Python有大量强大又贴心的特性,如果要列个最受欢迎排行榜,那么装饰器绝对会在其中。       刚接触装饰器,会...

    Meils 评论0 收藏0
  • Python: 会打扮的装饰

    摘要:一般情况下,我们使用装饰器提供的语法糖,来简化上面的写法像上面的情况,可以动态修改函数或类功能的函数就是装饰器。本文标题为会打扮的装饰器本文链接为参考资料修饰器的函数式编程中的装饰器介绍思诚之道装饰器入门与提高赖明星 装饰器 我们知道,在 Python 中,我们可以像使用变量一样使用函数: 函数可以被赋值给其他变量 函数可以被删除 可以在函数里面再定义函数 函数可以作为参数传递给另外...

    blastz 评论0 收藏0
  • python装饰详解

    摘要:为了避免重复调用,可以适当地做缓存,的装饰器可以完美的完成这一任务。这意味着我们可以为方法创建装饰器,只是要记得考虑。装饰器封装了函数,这使得调试函数变得困难。另外,使用装饰器去管理缓存和权限。 原文地址 之前用python简单写了一下斐波那契数列的递归实现(如下),发现运行速度很慢。 def fib_direct(n): assert n > 0, invalid n ...

    maybe_009 评论0 收藏0

发表评论

0条评论

cyqian

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<