Python装饰器

时间  2019-11-12
标签 python 装饰 栏目 Python 繁體版
原文   原文链接

原文：Decorators and Functional Pythonhtml

译者：youngsterxyfpython

装饰器是Python的一大特点。除了在语言中的本来用处，还帮助咱们以一种有趣的方式（函数式）进行思考。git

我打算自底向上解释装饰器如何工做。首先解释几个话题以帮助理解装饰器。而后，深刻一点探索几个简单的装饰器以及它们如何工做。最后，讨论一些更高级的使用装饰器的方式，好比：传递可选参数给装饰器或者串接几个装饰器。github

首先以我能想到的最简单的方式来定义Python函数是什么。基于该定义，咱们能够相似的简单方式来定义装饰器。编程

函数是一个完成特定任务的可复用代码块。设计模式

好的，那么装饰器又是什么呢？缓存

装饰器是一个修改其余函数的函数。数据结构

如今在装饰器的定义上进行详述，先解释一些先决条件。闭包

函数是一等对象

Python中，全部东西都是对象。这意味着能够经过名字引用函数，以及像其余对象那样传递。例如：app

def traveling_function():
	print "Here I am!"

function_dict = {
	"func": traveling_function
}

trav_func = function_dict['func']
trav_func()
# >> Here I am!

traveling_function 被赋值给 function_dict 字典中键 func 的值，仍旧能够正常调用。

一等函数容许高阶函数

咱们能够像其余对象那样传递函数。能够将函数做为值传递给字典，放在列表中，或者做为对象的属性进行赋值。那为何不能做为参数传给另外一个函数呢？固然能够！若是一个函数接受另外一个函数做为其参数或者返回另外一个函数，则称之为高阶函数。

def self_absorbed_function():
	return "I'm an amazing function!"

def printer(func):
	print "The function passed to me says: " + func()

# Call `printer` and give it `self_absorbed_function` as an argument
printer(self_absorbed_function)
# >>> The function passed to me says: I'm an amazing function!

如今你也看到函数能够做为参数传给另外一个函数，并且传给函数的函数还能够调用。这容许咱们建立一些有意思的函数，例如装饰器。

装饰器基础

本质上，装饰器就是一个以另外一个函数为参数的函数。大多数状况下，它们会返回所包装函数的一个修改版本。来看个咱们能想到的最简单的装饰器—同一性（identity）装饰器，或许对咱们理解装饰器的工做原理有所帮助。

def identity_decorator(func):
    def wrapper():
        func()
    return wrapper

def a_function():
    print "I'm a normal function."

# `decorated_function` 是 `identity_function` 返回的函数，也就是嵌套函数 `wrapper`
decorated_function = identity_function(a_function)

# 以下调用 `identity_function` 返回的函数
decorated_function()
# >>> I'm a normal function

这里， identity_decorator 根本没有修改它包装的函数，只是简单地返回一个函数（wrapper），这个函数在被调用之时，会去调用原来做为 identity_decorator 参数的函数。这是个没有用处的装饰器！

关于 identity_decorator 的有趣之处是 wrapper 可以访问变量 func ，即便 func 并不是是它的参数。这归因于闭包。

闭包

闭包是一个花哨的术语，意为声明一个函数时，该函数会维持一个指向声明所处词法环境的引用。

上例中定义的函数 wrapper 可以在其局部做用域（local scope）中访问 func。这意味着在 wrapper （返回并赋值给变量 decorated_function ）的整个生命周期内，它均可以访问 func 变量。一旦 identity_decorator返回，那么访问 func 的惟一方式就是经过 decorated_function 。 func 只做为一个变量存在于 decorated_function 做用域环境的内部。

一个简单的装饰器

如今咱们来建立一个确实有点用的装饰器。这个装饰器所作的就是记录它所修改的函数被调用了多少次。

def logging_decorator(func):
    def wrapper():
        wrapper.count += 1
        print "The function I modify has been called {0} time(s)".format(wrapper.count)
        func()
    wrapper.count = 0

    return wrapper

def a_function():
    print "I'm a normal function."

modified_function = logging_decorator(a_function)

modified_function()
# >>> The function I modify has been called 1 time(s).
# >>> I'm a normal function.

modified_function()
# >>> The function I modify has been called 2 time(s).
# >>> I'm a normal function.

咱们说装饰器会修改函数，这样来想对理解也是有帮助的。但如例子所见， logging_decorator 返回的是一个相似于a_function 的新函数，只是多了一个日志特性。

上例中， logging_decorator 不只接受一个函数做为参数，而且返回一个函数， wrapper 。每次logging_decorator 返回的函数获得调用，它就对 wrapper.count 的值加1，打印出来，而后调用logging_decorator 包装的函数。

你也许正疑惑为何咱们的计数器是 wrapper 的一个属性而不是一个普通的变量。难道 wrapper 的闭包环境不是让咱们访问在其局部做用域中声明的任意变量么？是的，但有个问题。Python中，闭包容许对其函数做用域链中任一变量的进行任意读操做，但只容许对可变对象（列表、字典、等等）进行写操做。整数在Python中是非可变对象，所以咱们不能修改 wrapper 内部整型变量的值。相反，咱们将计数器做为 wrapper 的一个属性—一个可变对象，所以能够随咱们本身增大它的值。

若是改为普通变量，会报错：UnboundLocalError: local variable 'count' referenced before assignment。这里能够参考：

http://www.cnblogs.com/youxin/p/3730610.html

装饰器语法

在前一个例子中，咱们看到能够将一个函数做为参数传给装饰器，从而使用装饰器函数对该函数进行包装。然而，Python还有一个语法模式使得这一切更加直观，更容易阅读，一旦你熟悉了装饰器。

# In the previous example, we used our decorator function by passing the
# function we wanted to modify to it, and assigning the result to a variable
def some_function():
    print "I'm happiest when decorated."

# Here we will make the assigned variable the same name as the wrapped function
some_function = logging_decorator(some_function)
# We can achieve the exact same thing with this syntax:

@logging_decorator
def some_function():
    print "I'm happiest when decorated"

使用装饰器语法，鸟瞰其中发生的事情：

  1. 解释器到达被装饰的函数，编译 some_function，并将其命名为 ‘some_function’。
  2. 而后将该函数传递给装饰行中指定的装饰器函数（ logging_function ）。
  3. 装饰器函数（一般是用来包装原函数的另外一个函数）的返回值取代原来的函数（some_function ），绑定到变量名some_function 。

将这些步骤记住，让咱们来更清晰地解释 identity_decorator 。

def identity_decorator(func):
    # Everything here happens when the decorator LOADS and is passed
    # the function as decribed in step 2 above
    def wrapper():
        # Things here happen each time the final wrapped function gets CALLED
        func()
    return wrapper

但愿那些注释有助于理解。每次调用被包装的函数，仅执行装饰器返回的函数中的指令。返回函数以外的指令仅执行一次—上述步骤2中描述的：装饰器首次接收到传递给它的待包装函数之时。

在观察更多的有意思的装饰器以前，我想再解释同样东西。

*args与**kwargs

之前你也许有时会把这二者相混淆了。让咱们一次性地讨论它们。

  • 经过在形参列表中使用 *args 语法，python函数可以接收可变数量的位置参数(positional arguments)。 *args 会将全部没有关键字的参数放入一个参数元组中，在函数里能够访问元组中的参数。相反，将 *args 用于函数调用时的实参列表之时，它会将参数元组展开成一系列的位置参数。
def function_with_many_arguments(*args):
    print args

# `args` within the function will be a tuple of any arguments we pass
# which can be used within the function like any other tuple
function_with_many_arguments('hello', 123, True)
# >>> ('hello', 123, True)
def function_with_3_parameters(num, boolean, string):
    print "num is " + str(num)
    print "boolean is " + str(boolean)
    print "string is " + string

arg_list = [1, False, 'decorators']

# arg_list will be expanded into 3 positional arguments by the `*` symbol function_with_3_parameters(*arg_list)
# >>> num is 1
# >>> boolean is False
# >>> string is decorators

重述一遍：在形参列表中， *args会将一系列的参数压缩进一个名为’args’的元组，而在实参列表中， *args 会将一个可迭代的参数数据结构展开为一系列的位置实参应用于函数。

如你所见在实参展开的例子中， * 符号可与’args’以外的名字一块儿使用。当压缩/展开通常的参数列表，使用 *args 的形式仅仅是一种惯例。

  • **kwargs 与 *args 的行为相似，但用于关键字参数而非位置参数。若是在函数的形参列表中使用 **kwargs ，它会收集函数收到的全部额外关键字参数，放入一个字典中。若是用于函数的实参列表，它会将一个字典展开为一系列的关键字参数。
def funtion_with_many_keyword_args(**kwargs):
    print kwargs

function_with_many_keyword_args(a='apples', b='bananas', c='cantalopes')
# >> {'a':'apples', 'b':'bananas', 'c':'cantalopes'}
def multiply_name(count=0, name=''):
    print name * count

arg_dict = {'count': 3, 'name': 'Brian'}

multiply_name(**arg_dict)
# >> BrianBrianBrian

既然你理解了 *args 与 **kwargs 的工做原理，那么咱们就继续研究一个你会发现颇有用的装饰器。

缓存制表（Memoization）

缓存制表是避免潜在的昂贵的重复计算的一种方法，经过缓存函数每次执行的结果来实现。这样，下一次函数以相同的参数执行，就能够从缓存中获取返回结果，不须要再次计算结果。

from functools import wraps

def memoize(func):
    cache = {}

    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def an_expensive_function(arg1, arg2, arg3):
    ...

你可能注意到了示例代码中一个奇怪的 @wraps 装饰器。在完整地讨论 memoize 以前我将简要地解释这个装饰器。

  • 使用装饰器的一个反作用是被包装的函数失去了原本有的 __name__ ， __doc__ ， 以及 __module__ 属性。 wraps函数是一个包装另外一个装饰器返回的函数的装饰器，将那三个属性的值恢复为函数未装饰之时的值。例如： 若是不使用 wraps 装饰器， an_expensive_function 的名字（经过 an_expensive_function.__name__ 能够看到）将是 ‘wrapper’ 。

我认为 memoize 是一个很好的装饰器用例。它服务于一个不少函数都须要的目的，经过将它建立为一个通用装饰器，咱们能够将它的功能应用于任一可以从其中获益的函数。这就避免了在多种不一样的场合重复实现这个功能。由于不须要重复本身，因此咱们的代码更容易维护，而且更容易阅读和理解。只要读一个单词你就能马上理解函数使用了缓存制表。

须要提醒的是：缓存制表仅适用于纯函数。也就是说给定一个特定的参数设置，函数肯定总会产生相同的结果。若是函数依赖于不做为参数传递的全局变量、I/O、或者其它任意可能影响返回值的东西，缓存制表会产生使人迷惑的结果！而且，一个纯函数不会有任何反作用。所以，若是你的函数会增大一个计数器，或者调用另外一个对象的方法，或者其它任意不在函数的返回结果中表示的东西，当结果是从缓存中返回时，反作用操做并不会获得执行。

类的装饰器

最初，咱们说装饰器是一个修改另外一个函数的函数，但其实它们能够用于修改类或者方法。对类进行装饰并不常见，但某些状况下做为元类(metaclass)的一个替代，类的装饰器是一个有用的工具。

foo = ['important', 'foo', 'stuff']

def add_foo(klass):
    klass.foo = foo
    return klass


@add_foo
class Person(object):
    pass

brian = Person()

print brian.foo
# >> ['important', 'foo', 'stuff']

如今，类 Person 的任一对象都有一个超级重要的 foo 属性！注意，由于咱们装饰的是一个类，因此装饰器返回的不是一个函数，而是一个类。更新一下装饰器的定义：

装饰器是一个修改函数、或方法、或类的函数。

装饰器类

事实证实我早先对你隐瞒了一些其它事情。不只装饰器能够装饰一个类，而且装饰器也能够是一个类！对于装饰器的惟一要求就是它的返回值必须可调用(callable)。这意味着装饰器必须实现 __call__ 魔术方法，当你调用一个对象时，会隐式调用这个方法。函数固然是隐式设置这个方法的。咱们从新将 identity_decorator 建立为一个类来看看它是如何工做的。

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

    def __call__(self):
        self.func()


@IdentityDecorator
def a_function():
    print "I'm a normal function."

a_function()
# >> I'm a normal function.

以下是上例中发生的事情：

  • 当 IdentityDecorator 装饰 a_function 时，它的行为就和装饰器函数同样。这个代码片断等价于上例中的装饰器语法： a_function = IdentityDecorator(a_function) 。调用（实例化）该装饰器类时，需将其装饰的函数做为一个实参传递给它。

  • 实例化 IdentityDecorator 之时，会以被装饰的函数做为实参调用初始化函数 __init__ 。本例中，初始化函数所作的事情就是将被装饰函数赋值给一个属性，这样以后就能够经过其它方法进行调用。

  • 最后，调用 a_function （其实是返回的包装了 a_function 的 IdentityDecorator 对象）之时，会调用对象的 __call__ 方法。这仅是一个同一性装饰器，因此方法只是简单地调用了该类所装饰的函数。

再次更新一下咱们对装饰器的定义！

装饰器是一个修改函数、方法或者类的可调用对象。

带参数的装饰器

有时，须要根据不一样的状况改变装饰器的行为。你能够经过传参来作到这一点。

from functools import wraps

def argumentative_decorator(gift):
    def func_wrapper(func):
        @wraps(func)
        def returned_wrapper(*arg, **kwargs):
             print "I don't like this " + gift + "you gave me!"
             return func(gift, *args, **kwargs)
        return returned_wrapper
    return func_wrapper

@argumentative_decorator("sweater")
def grateful_function(gift):
    print "I love the " + gift + "!Thank you!"

grateful_function()
# >> I don't like this sweater you gave me!
# >> I love the sweater! Thank you!

咱们来看看若是不使用装饰器语法这个装饰器函数是如何工做的：

# If we tried to invoke without an argument:
grateful_function = argumentative_function(grateful_function)

# But when given an argument, the pattern changes to:
grateful_function = argumentative_decorator("sweater")(grateful_function)

须要注意的地方是：当给定参数，首先仅以那些参数调用装饰器—被包装的函数并不在参数中。装饰器调用返回后，装饰器要包装的函数被传递给装饰器初始调用返回的函数（本例中，为 argumentative_decorator("sweater") 的返回值）。

逐步地：

  1. 解释器到达被装饰函数之处，编译 grateful_function ，并将其绑定到名字’grateful_function’。
  2. 传递参数”sweater”调用 argumentative_decorator ，返回 func_wrapper 。
  3. 以 grateful_function 为参调用 func_wrapper ，返回 returned_wrapper 。
  4. 最后， returned_wrapper 取代原来的函数 grateful_function ，并绑定到名字’grateful_function’ 。

我想这一过程相比没有装饰器参数理解起来更难一点，可是若是你花些时间将其理解通透，我但愿是有意义的。

带可选参数的装饰器

有多种方式让装饰器接受可选参数。根据你是想使用位置参数、关键字参数仍是二者皆是，须要使用稍微不一样的模式。以下我将展现一种接受一个可选关键字参数的方式：

from functools import wraps

GLOBAL_NAME = "Brian"

def print_name(function=None, name=GLOBAL_NAME):
    def actual_decorator(function):
        @wraps(function)
        def returned_func(*args, **kwargs):
            print "My name is " + name
            return function(*args, **kwargs)
        return returned_func

    if not function:    # User passed in a name argument
        def waiting_for_func(function):
            return actual_decorator(function)
        return waiting_for_func

    else:
        return actual_decorator(function)

@print_name
def a_function():
    print "I like the name!"

@print_name(name='Matt')
def another_function():
    print "Hey, that's new!"

a_function()
# >> My name is Brian
# >> I like that name!

another_function()
# >> My name is Matt
# >> Hey, that's new!

若是咱们传递关键字参数 name 给 print_name ，那么它的行为就与前一个例子中的 argumentative_decorator 类似。即，首先以 name 为参调用 print_name 。而后，将待包装的函数传递给首次调用返回的函数。

若是咱们没有提供 name 实参， print_name 的行为就与前面咱们看到的不带参数的装饰器同样。装饰器仅以待包装的函数做为惟一的参数进行调用。

print_name 支持两种可能性。它会检查是否收到做为参数的被包装函数。若是没有，则返回函数 waiting_for_func，该函数能够被包装函数做为参数进行调用。若是收到被包装函数做为参数，则跳过中间步骤，直接调用actual_decorator 。

串接装饰器

如今来探索一下今天要讲的最后一个装饰器的特性：串接。你能够在任意给定的函数之上堆叠使用多个装饰器， 这种构建函数的方式与使用多重继承构建类相相似。不过最好不要疯狂使用这种特性。

@print_name('Sam')
@logging_decorator
def some_function():
    print "I'm the wrapped function!"

some_function()
# >> My name is Sam
# >> The function I modify has been called 1 time(s).
# >> I'm the wrapped function!

当你串接使用装饰器时，它们堆叠的顺序是自底向上的。将被包装的函数 some_function 经编译后传递给它之上的第一个装饰器（ logging_decorator ）。而后第一个装饰器的返回值被传递给第二个装饰器。依此逐个应用链上每一个装饰器。

由于咱们使用的两个装饰器都是 print 一个值，而后执行传递给它们的函数，这意味着当调用被包装函数时，链中的最后一个装饰器 print_name 打印输出中的第一行。

总结

我认为装饰器最大的好处之一在于让你可以从更高的抽象层次进行思考。假如你开始阅读一个函数定义，看到有一个memoize 装饰器，你马上就能明白你正在看的是一个使用缓存制表的函数。若是缓存制表的代码包含在函数体内，就会须要额外的脑力进行解析，而且会有引入误解的可能。使用装饰器也容许代码复用，从而节省时间、简化调试，而且使得重构更加容易。

玩玩装饰器也是一种很好的学习函数式概念（如高阶函数与闭包）的方式。

我但愿本文阅读起来很愉快，而且内容翔实。

转自：http://youngsterxyf.github.io/2013/01/04/Decorators-and-Functional-Python/

python装饰器解释：

今天来讨论一下装饰器。装饰器是一个很著名的设计模式，常常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，咱们就能够抽离出大量函数中与函数功能自己无关的雷同代码并继续重用。归纳的讲，装饰器的做用就是为已经存在的对象添加额外的功能。

1. 装饰器入门

1.1. 需求是怎么来的？

装饰器的定义非常抽象，咱们来看一个小例子。

1
2
3
4
def  foo():
     print  'in foo()'
 
foo()

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

1
2
3
4
5
6
7
8
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君看了多少个函数，咱们都不用去修改函数定义了！

1
2
3
4
5
6
7
8
9
10
11
12
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()的代码彻底不用修改！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#-*- 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带有参数和有返回值的状况，完善它的重任就交给你了 ：）

2. Python的额外支持

2.1. 语法糖

上面这段代码看起来彷佛已经不能再精简了，Python因而提供了一个语法糖来下降字符输入量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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)彻底等价，千万不要觉得@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感受。

2.2. 内置的装饰器

内置的装饰器有三个，分别是staticmethod、classmethod和property，做用分别是把类中定义的实例方法变成静态方法、类方法和类属性。因为模块里能够定义函数，因此静态方法和类方法的用处并非太多，除非你想要彻底的面向对象编程。而属性也不是不可或缺的，Java没有属性也同样活得很滋润。从我我的的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也很是低。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class  Rabbit( object ):
     
     def  __init__( self , name):
         self ._name =  name
     
     @staticmethod
     def  newRabbit(name):
         return  Rabbit(name)
     
     @classmethod
     def  newRabbit2( cls ):
         return  Rabbit('')
     
     @property
     def  name( self ):
         return  self ._name

这里定义的属性是一个只读属性，若是须要可写，则须要再定义一个setter：

1
2
3
@name .setter
def  name( self , name):
     self ._name =  name

2.3. functools模块

functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，通常来讲你们用的应该都高于这个版本。但我平时的工做环境是2.4 T-T

2.3.1. wraps(wrapped[, assigned][, updated]): 
这是一个颇有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性好比函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，若是你但愿使用反射，可能会致使意外的结果。这个装饰器能够解决这个问题，它能将装饰过的函数的特殊属性保留。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import  time
import  functools
 
def  timeit(func):
     @functools .wraps(func)
     def  wrapper():
         start =  time.clock()
         func()
         end = time.clock()
         print  'used:' , end -  start
     return  wrapper
 
@timeit
def  foo():
     print  'in foo()'
 
foo()
print  foo.__name__

首先注意第5行，若是注释这一行，foo.__name__将是'wrapper'。另外相信你也注意到了，这个装饰器居然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你能够经过查看functools的源代码得到它们的默认值。对于这个装饰器，至关于wrapper = functools.wraps(func)(wrapper)。

2.3.2. total_ordering(cls): 
这个装饰器在特定的场合有必定用处，可是它是在Python 2.7后新增的。它的做用是为实现了至少__lt__、__le__、__gt__、__ge__其中一个的类加上其余的比较方法，这是一个类装饰器。若是以为很差理解，不妨仔细看看这个装饰器的源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
53   def  total_ordering( cls ):
54       """Class decorator that fills in missing ordering methods"""
55       convert =  {
56           '__lt__' : [( '__gt__' , lambda  self , other: other < self ),
57                      ( '__le__' , lambda  self , other: not  other < self ),
58                      ( '__ge__' , lambda  self , other: not  self  < other)],
59           '__le__' : [( '__ge__' , lambda  self , other: other < =  self ),
60                      ( '__lt__' , lambda  self , other: not  other < =  self ),
61                      ( '__gt__' , lambda  self , other: not  self  < =  other)],
62           '__gt__' : [( '__lt__' , lambda  self , other: other > self ),
63                      ( '__ge__' , lambda  self , other: not  other > self ),
64                      ( '__le__' , lambda  self , other: not  self  > other)],
65           '__ge__' : [( '__le__' , lambda  self , other: other > =  self ),
66                      ( '__gt__' , lambda  self , other: not  other > =  self ),
67                      ( '__lt__' , lambda  self , other: not  self  > =  other)]
68       }
69       roots =  set ( dir ( cls )) & set (convert)
70       if  not  roots:
71           raise  ValueError( 'must define at least one ordering operation: < > <= >=' )
72       root =  max (roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
73       for  opname, opfunc in  convert[root]:
74           if  opname not  in  roots:
75               opfunc.__name__ =  opname
76               opfunc.__doc__ =  getattr ( int , opname).__doc__
77               setattr ( cls , opname, opfunc)
78       return  cls

本文到这里就所有结束了，有空的话我会整理一个用于检查参数类型的装饰器的源代码放上来，算是一个应用吧 ：

转自：http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html#2817508）

更多：http://www.codecho.com/understanding-python-decorators/

http://doc.42qu.com/python/python-closures-and-decorators.html

http://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程