decoratorpython

Ⅰ python装饰器有什么用

先来个形象比方

内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤，有了长裤后宝宝再也不冷了，装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

再回到我们的主题

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

先来看一个简单例子：

def foo():
print('i am foo')

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

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

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

def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()def bar():
print('i am bar')use_logging(bar)

逻辑上不难理解，
但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器
def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapperdef bar():
print('i am bar')bar = use_logging(bar)bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时
，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。

@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper@use_loggingdef foo():
print("i am foo")@use_loggingdef bar():
print("i am bar")bar()

如上所示，这样我们就可以省去bar =
use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

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

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator@use_logging(level="warn")def foo(name='foo'):
print("i am %s" % name)foo()

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

类装饰器

再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps

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

装饰器

def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数

@loggeddef f(x):
"""does some math"""
return x + x * x

该函数完成等价于：

def f(x):
"""does some math"""
return x + x * xf = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。

print f.__name__ # prints 'with_logging'print f.__doc__ # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。

from functools import wrapsdef logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging@loggeddef f(x):
"""does some math"""
return x + x * xprint f.__name__ # prints 'f'print f.__doc__ # prints 'does some math'

内置装饰器

@staticmathod、@classmethod、@property

装饰器的顺序
@a@b@cdef f ():

等效于

f = a(b(c(f)))

Ⅱ 如何理解Python装饰器

内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤，有了长裤后宝宝再也不冷了，装饰器就像我们这里说的长裤，在不影响内裤作用的前提下，给我们的身子提供了保暖的功效。

再回到我们的主题

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

先来看一个简单例子：
def foo():
print('i am foo')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：
def foo():
print('i am foo')
logging.info("foo is running")

bar()、bar2()也有类似的需求，怎么做？再写一个logging在bar函数里？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门处理日志 ，日志处理完之后再执行真正的业务代码
def use_logging(func):
logging.warn("%s is running" % func.__name__)
func()

def bar():
print('i am bar')

use_logging(bar)

逻辑上不难理解， 但是这样的话，我们每次都要将一个函数作为参数传递给use_logging函数。而且这种方式已经破坏了原有的代码逻辑结构，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成use_logging(bar)。那么有没有更好的方式的呢？当然有，答案就是装饰器。

简单装饰器

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args, **kwargs)
return wrapper

def bar():
print('i am bar')

bar = use_logging(bar)
bar()

函数use_logging就是装饰器，它把执行真正业务方法的func包裹在函数里面，看起来像bar被use_logging装饰了。在这个例子中，函数进入和退出时 ，被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。
@符号是装饰器的语法糖，在定义函数的时候使用，避免再一次赋值操作

def use_logging(func):

def wrapper(*args, **kwargs):
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

@use_logging
def foo():
print("i am foo")

@use_logging
def bar():
print("i am bar")

bar()

如上所示，这样我们就可以省去bar = use_logging(bar)这一句了，直接调用bar()即可得到想要的结果。如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。

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

带参数的装饰器
装饰器还有更大的灵活性，例如带参数的装饰器：在上面的装饰器调用中，比如@use_logging，该装饰器唯一的参数就是执行业务的函数。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。
def use_logging(level):
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warn("%s is running" % func.__name__)
return func(*args)
return wrapper

return decorator

@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)

foo()

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

类装饰器
再来看看类装饰器，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的\_\_call\_\_方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
def __init__(self, func):
self._func = func

def __call__(self):
print ('class decorator runing')
self._func()
print ('class decorator ending')

@Foo
def bar():
print ('bar')

bar()

functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表，先看例子：
装饰器
def logged(func):
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

函数
@logged
def f(x):
"""does some math"""
return x + x * x

该函数完成等价于：

def f(x):
"""does some math"""
return x + x * x
f = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。
print f.__name__ # prints 'with_logging'
print f.__doc__ # prints None

这个问题就比较严重的，好在我们有functools.wraps，wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。
from functools import wraps
def logged(func):
@wraps(func)
def with_logging(*args, **kwargs):
print func.__name__ + " was called"
return func(*args, **kwargs)
return with_logging

@logged
def f(x):
"""does some math"""
return x + x * x

print f.__name__ # prints 'f'
print f.__doc__ # prints 'does some math'

内置装饰器
@staticmathod、@classmethod、@property
装饰器的顺序

@a
@b
@c
def f ():

等效于

f = a(b(c(f)))

编辑于 2016-08-09

8 条评论

感谢
分享

收藏

•

没有帮助

•
举报

•

作者保留权利

收起

4
赞同

反对，不会显示你的姓名

许多人选择编程是因为他们喜欢把时间花在…

4 人赞同

先理解一下闭包的概念吧，之前回答过一个有关闭包和装饰器的问题，可以参考一下：Python 里函数里返回一个函数内部定义的函数？ - 知乎用户的回答

显示全部

先理解一下闭包的概念吧，之前回答过一个有关闭包和装饰器的问题，可以参考一下：
Python 里函数里返回一个函数内部定义的函数？ - 知乎用户的回答

发布于 2014-12-09

2 条评论

感谢
分享

收藏

•

没有帮助

•
举报

•

作者保留权利

1
赞同

反对，不会显示你的姓名

Ⅲ python中怎么安装decorator

(这里我是因为电脑上同时装了多个版本的python，所以命令有点不一样，效果和pip install 是一样的，运行完命令提示都是已经安装过decorator的意思)

两个命令都可以：

pip install decorator

pip2 install decorator（如果你的是python3，那么则是pip3 install decorator）

Ⅳ python装饰器使用

装饰器是从英文decorator翻译过来的，从字面上来看就是对某个东西进行修饰，增强被修饰物的功能，下面我们对装饰器做下简单介绍。

一、怎么编写装饰器

装饰器的实现很简单，本质是一个可调用对象，可以是函数、方法、对象等，它既可以装饰函数也可以装饰类和方法，为了简单说明问题，我们实现一个函数装饰器，如下代码：

有了这个装饰器，我们就可以打印出什么时候开始和结束调用函数，对于排查函数的调用链非常方便。

二、带参数的装饰器

上面的例子无论什么时候调用sum都会输出信息，如果我们需要按需输出信息怎么实现呢，这时就要用到带参数的装饰器了，如下代码：

对sum使用装饰器时没有参数，这时debug为0，所以调用sum时不会输出函数调用相关信息。

对multi使用装饰器时有参数，这时debug为1，所以调用multi时会输出函数调用相关信息。

三、函数名字问题

当我们打印被装饰后的函数名字时，不知道大家有没发现输出的不是函数本身的名字，如下代码会输出‘wrap’而不是‘sum’：

有时这种表现并不是我们想要的，我们希望被装饰后的函数名字还是函数本身，那要怎么实现呢？很简单，只需要引入functools.wraps即可，如下代码就会输出‘sum’了：

看完后是不是觉得python装饰器很简单，只要了解它的本质，怎么写都行，有好多种玩法呢。

Ⅳ 关于python装饰器的wapper函数的作用

一层层地装饰上去，如果不分成多个嵌套函数就无法传递参数了
装饰器
在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。关键字wrapper

[python] view plain
</pre><pre name="code" class="python">>>>def now():
print ('2014-12-10')
#定义装饰器
>>>def log(func):
@functools.wraps(func) #防止函数的名字被改变
def wrapper(*s,**kw):
print('call %s()'%func.__name__)
return func(*s,**kw)
return wrapper
>>>@log
defmmm(x,y):
print(x+y)

#调用装饰器
>>>mmm
<functionmmm at 0x02C44660>
>>>mmm.__name__
'mmm'
>>>now.__name__
'wapper'
>>>@log
defnow(x,y):
print('d')

>>>now(1,4)
callnow()
d

Ⅵ 什么是Python装饰器

所谓装饰器就是把函数包装一下，为函数添加一些附加功能，装饰器就是一个函数，参数为被包装的函数，返回包装后的函数：你可以试下：

defd(fp):
def_d(*arg,**karg):
print"dosthbeforefp.."
r=fp(*arg,**karg)
print"dosthafterfp.."
returnr
return_d
@d
deff():
print"callf"
#上面使用@d来表示装饰器和下面是一个意思
#f=d(f)
f()#调用f

Ⅶ python的这段代码的原因是什么

if __name__ == '__main__':

这个是确保执行的本文件的主函数。

python在执行时，会默认给__name__一个值，就是__main__。

举个栗子：文件p1.py和p2.py，其中在p1中调用了p2.

那么p2中的if __name__ == '__main__':就不成立，因为在p2环境中，__name__为p2。

Ⅷ “低门槛 手把手”python 装饰器(Decorators)原理说明

本文目的是由浅入深地介绍python装饰器原理

装饰器(Decorators)是 Python 的一个重要部分

其功能是， 在不修改原函数(类)定义代码的情况下，增加新的功能

为了理解和实现装饰器，我们先引入2个核心操作：

在这个例子中，函数hi的形参name，默认为'world'

在函数内部，又定义了另一个函数 howdoyoudo，定义这个函数时，将形参name作为新函数的形参name2的默认值。

因此，在函数内部调用howdoyoudo()时，将以调用hi时的实参为默认值，但也可以给howdoyoudo输入其他参数。

上面的例子运行后输出结果为：

这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念，但其实没必要给它取一个多专业的名字。我们知道闭包是 函数内的函数 就可以了

当我们进行 def 的时候，我们在做什么？

这时，hi函数，打印一个字符串，同时返回一个字符串。

但hi函数本身也是一个对象，一个可以执行的对象。执行的方式是hi()。

这里hi和hi()有本质区别，

hi 代表了这个函数对象本身

hi() 则是运行了函数，得到函数的返回值。

作为对比，可以想象以下代码

此时也是b存在，可以正常使用。

我们定义2个函数，分别实现自加1， 自乘2，

再定义一个函数double_exec，内容是将某个函数调用2次

在调用double_exec时，可以将函数作为输入传进来

输出结果就是

7

27

同样，也可以将函数作为输出

输出结果为

6

10

有了以上两个核心操作，我们可以尝试构造装饰器了。

装饰器的目的： 在不修改原函数(类)定义代码的情况下，增加新的功能

试想一下，现在有一个原函数

在不修改原函数定义代码的情况下，如果想进行函数内容的添加，可以将这个函数作为一个整体，添加到这样的包裹中：

我们定义了一个my_decorator函数，这个函数进行了一种操作：

对传入的f，添加操作(运行前后增加打印)，并把添加操作后的内容连同运行原函数的内容，一起传出

这个my_decorator，定义了一种增加前后打印内容的行为

调用my_decorator时，对这个行为进行了操作。

因此，new_function是一个在original_function上增加了前后打印行为的新函数

这个过程被可以被称作装饰。

这里已经可以发现，装饰器本身对于被装饰的函数是什么，是不需要考虑的。装饰器本身只定义了一种装饰行为，这个行为是通过装饰器内部的闭包函数()进行定义的。

运行装饰前后的函数，可以清晰看到装饰的效果

我们复现一下实际要用装饰器的情况，我们往往有一种装饰器，想应用于很多个函数，比如

此时，如果我们想给3个print函数都加上装饰器，需要这么做

实际调用的时候，就需要调用添加装饰器的函数名了

当然，也可以赋值给原函数名

这样至少不需要管理一系列装饰前后的函数。

同时，在不需要进行装饰的时候，需要把

全部删掉。

事实上，这样并不方便，尤其对于更复杂的装饰器来说

为此，python提供了一种简写方式

这个定义print1函数前的@my_decorator，相当于在定义完print1后，自动直接运行了

不论采用@my_decorator放在新函数前，还是显示地重写print1 = my_decorator(print1)，都会存在一个问题：

装饰后的函数，名字改变了(其实不止名字，一系列的索引都改变了)

输出结果为:

这个现象的原因是，装饰行为本身，是通过构造了一个新的函数（例子中是wrap_func函数）来实现装饰这个行为的，然后把这个修改后的函数赋给了原函数名。

这样，会导致我们预期的被装饰函数的一些系统变量（比如__name__）发生了变化。

对此，python提供了解决方案：

经过这个行为后，被装饰函数的系统变量问题被解决了

输出结果为

刚才的例子都比较简单，被装饰的函数是没有参数的。如果被装饰的函数有参数，只需要在定义装饰行为时（事实上，这个才更通用），增加(*args, **kwargs)描述即可

之前的描述中可以感受到，对于例子中的装饰行为(前后加打印)，函数被装饰后，本质上是调用了新的装饰函数wrap_func。

因此，如果原函数需要有输入参数传递，只需要在wrap_func（或其他任意名字的装饰函数）定义时，也增加参数输入(*args, **kwargs)，并将这些参数，原封不动地传给待装饰函数f。

这种定义装饰行为的方式更具有普遍性，忘记之前的定义方式吧

我们试一下

输出

这里需要注意的是，如果按照以下的方式定义装饰器

那么以下语句将不会执行

因为装饰后实际的函数wrap_func(虽然名字被改成了原函数，系统参数也改成了原函数)，运行到return f(*args, **kwargs) 的时候已经结束了

因为装饰器my_decorator本身也是可以输入的，因此，只需要在定义装饰器时，增加参数，并在后续函数中使用就可以了，比如

此时装饰器已经可以有输入参数了

输出

你可能发现，为什么不用简写版的方法了

因为以上代码会报错！！

究其原因，虽然

等价于

但是，

并不等价于

这本身和@语法有关，使用@my_decorator时，是系统在应用一个以单个函数作为参数的闭包函数。即，@是不能带参数的。

但是你应该发现了，之前的@wraps(f)不是带参数了吗？请仔细观察以下代码

通过一层嵌套，my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator)，但因为my_decorator对my_decorator_with_parma来说是一个闭包，my_decorator_with_parma是可以带参数的。（这句话真绕）

通过以上的定义，我们再来看

可以这么理解，my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数，同时，因为my_decorator_with_parma可以传参，参数实际上是参与了my_decorator的（因为my_decorator对my_decorator_with_parma是闭包）， my_decorator_with_parma(msg='yusheng') 全等于 一个有参数参加的my_decorator

因此，以上代码等价于有参数msg传递的

比较绕，需要理解一下，或者干脆强记这种范式：

以上范式包含函数的输入输出、装饰器的输入，可以应对大部分情况了。

实验一下：

输出

以上是一个log装饰器，利用datetime统计了函数的耗时，

并且，装饰器可以进行输出文件操作，如果给出了文件路径，则输出文件，否则就打印。

利用这个装饰器，可以灵活地进行耗时统计

不设置输出文件地址，则打印。运行结果为：

也可以输出到文件

输出结果为

同时在当前目录生成了一个test.log 文件，内容为：

以上的装饰器都是以函数形式出现的，但我们可以稍做改写，将装饰器以类的形式实现。

这个装饰器类Log 上个例子里的装饰器函数log功能是一样的，同时，这个装饰器类还可以作为基类被其他继承，进一步增加功能。

原文 http://www.cnblogs.com/yushengchn/p/15636944.html