如何理解Python装饰器

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何理解Python装饰器相关的知识，希望对你有一定的参考价值。

理解Python中的装饰器
@makebold
@makeitalic
def say():
return "Hello"

打印出如下的输出：
<b><i>Hello<i></b>

你会怎么做？最后给出的答案是：

def makebold(fn):
def wrapped():
return "<b>" + fn() + "</b>"
return wrapped

def makeitalic(fn):
def wrapped():
return "<i>" + fn() + "</i>"
return wrapped

@makebold
@makeitalic
def hello():
return "hello world"

print hello() ## 返回 <b><i>hello world</i></b>

现在我们来看看如何从一些最基础的方式来理解Python的装饰器。英文讨论参考Here。
装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
1.1. 需求是怎么来的？
装饰器的定义很是抽象，我们来看一个小例子。

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

这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：

import time
def foo():
start = time.clock()
print 'in foo()'
end = time.clock()
print 'used:', end - start

foo()

很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。
怎么办呢？如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么！而且，如果B君继续看了其他的函数呢？
1.2. 以不变应万变，是变也
还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了！

import time

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

def timeit(func):
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

timeit(foo)

看起来逻辑上并没有问题，一切都很美好并且运作正常！……等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。
1.3. 最大限度地少改动！
既然如此，我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数……想办法把参数统一吧！如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改！

#-*- coding: UTF-8 -*-
import time

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

# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法
def timeit(func):

# 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start

# 将包装后的函数返回
return wrapper

foo = timeit(foo)
foo()

这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。
这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：）
上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。

import time

def timeit(func):
def wrapper():
start = time.clock()
func()
end =time.clock()
print 'used:', end - start
return wrapper

@timeit
def foo():
print 'in foo()'

foo()

重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。
-------------------
要理解python的装饰器，我们首先必须明白在Python中函数也是被视为对象。这一点很重要。先看一个例子：

def shout(word="yes") :
return word.capitalize()+" !"

print shout()
# 输出 : 'Yes !'

# 作为一个对象，你可以把函数赋给任何其他对象变量

scream = shout

# 注意我们没有使用圆括号，因为我们不是在调用函数
# 我们把函数shout赋给scream，也就是说你可以通过scream调用shout

print scream()
# 输出 : 'Yes !'

# 还有，你可以删除旧的名字shout，但是你仍然可以通过scream来访问该函数

del shout
try :
print shout()
except NameError, e :
print e
#输出 : "name 'shout' is not defined"

print scream()
# 输出 : 'Yes !'

我们暂且把这个话题放旁边，我们先看看python另外一个很有意思的属性：可以在函数中定义函数：

def talk() :

# 你可以在talk中定义另外一个函数
def whisper(word="yes") :
return word.lower()+"...";

# ... 并且立马使用它

print whisper()

# 你每次调用'talk'，定义在talk里面的whisper同样也会被调用
talk()
# 输出 :
# yes...

# 但是"whisper" 不会单独存在:

try :
print whisper()
except NameError, e :
print e
#输出 : "name 'whisper' is not defined"*

函数引用
从以上两个例子我们可以得出，函数既然作为一个对象，因此：
1. 其可以被赋给其他变量
2. 其可以被定义在另外一个函数内
这也就是说，函数可以返回一个函数，看下面的例子：

def getTalk(type="shout") :

# 我们定义另外一个函数
def shout(word="yes") :
return word.capitalize()+" !"

def whisper(word="yes") :
return word.lower()+"...";

# 然后我们返回其中一个
if type == "shout" :
# 我们没有使用(),因为我们不是在调用该函数
# 我们是在返回该函数
return shout
else :
return whisper

# 然后怎么使用呢 ?

# 把该函数赋予某个变量
talk = getTalk()

# 这里你可以看到talk其实是一个函数对象:
print talk
#输出 : <function shout at 0xb7ea817c>

# 该对象由函数返回的其中一个对象:
print talk()

# 或者你可以直接如下调用 :
print getTalk("whisper")()
#输出 : yes...

还有，既然可以返回一个函数，我们可以把它作为参数传递给函数：

def doSomethingBefore(func) :
print "I do something before then I call the function you gave me"
print func()

doSomethingBefore(scream)
#输出 :
#I do something before then I call the function you gave me
#Yes !

这里你已经足够能理解装饰器了，其他它可被视为封装器。也就是说，它能够让你在装饰前后执行代码而无须改变函数本身内容。
手工装饰
那么如何进行手动装饰呢？

# 装饰器是一个函数，而其参数为另外一个函数
def my_shiny_new_decorator(a_function_to_decorate) :

# 在内部定义了另外一个函数：一个封装器。
# 这个函数将原始函数进行封装，所以你可以在它之前或者之后执行一些代码
def the_wrapper_around_the_original_function() :

# 放一些你希望在真正函数执行前的一些代码
print "Before the function runs"

# 执行原始函数
a_function_to_decorate()

# 放一些你希望在原始函数执行后的一些代码
print "After the function runs"

#在此刻，"a_function_to_decrorate"还没有被执行，我们返回了创建的封装函数
#封装器包含了函数以及其前后执行的代码，其已经准备完毕
return the_wrapper_around_the_original_function

# 现在想象下，你创建了一个你永远也不远再次接触的函数
def a_stand_alone_function() :
print "I am a stand alone function, don't you dare modify me"

a_stand_alone_function()
#输出: I am a stand alone function, don't you dare modify me

# 好了，你可以封装它实现行为的扩展。可以简单的把它丢给装饰器
# 装饰器将动态地把它和你要的代码封装起来，并且返回一个新的可用的函数。
a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#输出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

现在你也许要求当每次调用a_stand_alone_function时，实际调用却是a_stand_alone_function_decorated。实现也很简单，可以用my_shiny_new_decorator来给a_stand_alone_function重新赋值。

a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#输出 :
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# And guess what, that's EXACTLY what decorators do !

装饰器揭秘
前面的例子，我们可以使用装饰器的语法：

@my_shiny_new_decorator
def another_stand_alone_function() :
print "Leave me alone"

another_stand_alone_function()
#输出 :
#Before the function runs
#Leave me alone
#After the function runs

当然你也可以累积装饰：

def bread(func) :
def wrapper() :
print "</''''''\>"
func()
print "<\______/>"
return wrapper

def ingredients(func) :
def wrapper() :
print "#tomatoes#"
func()
print "~salad~"
return wrapper

def sandwich(food="--ham--") :
print food

sandwich()
#输出 : --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/>

使用python装饰器语法：

@bread
@ingredients
def sandwich(food="--ham--") :
print food

sandwich()
#输出 :
#</''''''\>
# #tomatoes#
# --ham--
# ~salad~
#<\______/> 参考技术A 简言之，打个比方，我写了一个python的插件，提供给用户使用，但是在使用的过程中我添加了一些功能，可是又不希望用户改变调用的方式，那么该怎么办呢？这个时候就用到了装饰器。
python装饰器就是用于拓展原来函数功能的一种函数，这个函数的特殊之处在于它的返回值也是一个函数，使用python装饰器的好处就是在不用更改原函数的代码前提下给函数增加新的功能。一般而言，我们要想拓展原来函数代码，比较直接的办法就是侵入代码里面修改。
而且装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多小白来讲，这个功能有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，不懂就太说不过去啦。
讲完装饰器，相信大家对于Python的发展前景也比较感兴趣，随着人工智能的发展，Python作为人工智能的首选语言，自然也是发展得如火如荼。现在入行，肯定是一个好时机！

Python之简单理解装饰器

装饰器是Python高级应用的一部分，其应用也很广泛。
网上对其介绍和讲解也是五花八门，我在这里就对其进行简单介绍，并对如何渐进理解使用装饰器进行说明，以便和大家共同学习。
如有更高见解，也请大家留言指正。

  • 装饰器概念简单理解

  • 循序渐进装饰器

装饰器概念简单理解

  • 装饰器按照我的理解，就是在不改变原有函数代码的情况下，对原有函数进行功能的扩展。

  • 这里先写个简单的装饰器，给大家有个概念性的认识。

def anotherone(func):  #定义装饰器
    def inner():
        print(‘this an inner print!‘)
        return func()
    return inner

@anotherone
def test ():  #定义函数
    print (‘this is a test print!‘)
test()

  • 打印结果：

    this an inner print!
    this is a test print!

  • 在上面的例子中， 函数test()，原来只有打印一个“this is a test print!”的功能，但是添加了我们的装饰器anotherone()之后。对于函数test()而言：

    • 首先没有改变原来test()函数的代码。

    • 另外，添加了另外的功能，也就是除了实现原来的功能以外，添加了打印“this an inner print!”的功能。

循序渐进装饰器

在理解了概念的同时，我们要对该装饰器进行理解，也就是为什么要这样写法呢？我们分步来说：

  • 首先看如下代码：

def test():
  print (‘this is a test‘)

  • 执行：

test

  • 结果：

    function test at 0x000002803E3FAA60

    显示的是test函数的内存地址。函数并没有执行。
    再执行：

test()

  • 结果：

    this is a test

    函数test被执行。

    这说明了什么？
    说明只输入函数test名称，也就仅仅输出函数test的地址，在此基础上，再给函数test添加括号变为test()，就可以执行test函数的功能，即打印“this is a test”。（理解这里很重要哦！）

  • 添加一个需求：如果我们要对函数test()增加另外一个打印功能（增加打印“’this an inner print!’”），
    并且不改变原来的test()函数，如何去做呢？

def test2(func):
  print ("this is an inner print!")
  func()

  • 执行以下：

test2(test)

  • 结果：

    this is an inner print!
    this is a test

    说明一下：定义一个函数test2()，接收的参数是test的内存地址，没有加“()”,因此在接收函数test的时候，函数test()不会被执行。引入到test2()中以后，在test2()中，先执行了“this is an inner print!”,然后对函数test加括号，变成test()执行之。

出现的问题，为了添加这个功能，所有原来使用test函数的地方，即原来“test()”现在都要改为“test2(test)”来执行。如果很多地方都要更改，不但增加了工作量，而且可能会因为疏漏造成一些问题。有什么方法可以解决呢？

解决方案：正如上面我所提到的，如果我们将原来的 test2(test)的内存地址重新赋值给一个叫test变量（亦即test=test2(test)），再加个括号，使用test()就是执行了test2(test)。  以上亦即新的test()实现了test2(test)的功能。 这里注意的是新的test()已被重新赋值，已非原来的test()了。

实现该功能步骤如下：

  1. 新建一个函数anotherone(func)。

  2. func用来传入原来函数（这里是原test()）的内存地址。

  3. 在anotherone(func)中新建一个函数inner()。

  4. inner()函数地址将来会被anotherone(func)返回并赋值给变量test。

  5. 执行test()完成。

  • 函数anotherone(func)框架如下：

def anotherone(func):
  def inner():
      #添加功能
return inner

我们再看一下inner()函数的构成：

def inner():
    print(‘this is an inner print!‘)
    return func()

  • 首先，这里就是添加新的功能和实现原来功能的地方。比如这里添加一个打印功能“print (“this is an inner print!”)”。

  • 实现了新功能之后，使用“return”返回并执行原来函数的功能，亦即“return func()”

  • 注意：不能使用“return func”，因为我们是要返回原来函数的功能，不是返回原来函数的地址 。

最后组合一下看看源码：

def anotherone(func): 
    def inner():
        print(‘this an inner print!‘)
        return func()
    return inner

def test ():
    print (‘this is a test print!‘)

test = anotherone(test)
test()

首先是：“test = anotherone(test)”

  • 将test()函数地址传给func后，anotherone(）返回了内置函数inner()的内存地址，并赋值给一个变量test，这里inner()并未被执行，仅仅是进行了赋值。


紧接着：“test()”

  • 执行新的test()，亦即执行inner()：打印“’this an inner print!”，后return func(),亦即执行原来的test()功能，打印“’this is a test print!”。

正如我们所期望的输入结果如下：

this an inner print!
this is a test print!

最后，我们看的清楚，其实定义anotherone(func)，亦即定义了一个装饰器。其中

@anotherone

等同于：

test = anotherone(test)


转载请注明出处。
了解更多，请关注我的微信公众号：
射手座IT俱乐部

技术分享






本文出自 “HiSea乐园” 博客，请务必保留此出处http://hisea.blog.51cto.com/1093265/1956640

以上是关于如何理解Python装饰器的主要内容，如果未能解决你的问题，请参考以下文章

Python之简单理解装饰器

如何理解Python装饰器

如何理解Python中的装饰器？

如何理解Python装饰器

Python 如何理解又晕又好用的装饰器

理解Python装饰器