[译]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!'

def talk():      # 你可以在运行时, 在"talk"函数内部定义一个函数     def whisper(word="yes"):         return word.lower()+"..."      # ... 然后立马使用它      print whisper()  # 当调用"talk"时, 你的每一次调用都会定义"whisper"一次, # 再调用"whisper" talk() # 输出: # "yes..."  # 但是, "whisper"在"talk"函数之外实际是不存在的  try:     print whisper()     except NameError, e:         print e         #输出 : "name 'whisper' is not defined"         #Python的函数是对象

def getTalk(kind="shout"):      # 我们在运行时定义函数     def shout(word="yes"):         return word.capitalize()+"!"      def whisper(word="yes") :         return word.lower()+"...";      # 然后我们返回其中的一个         if kind == "shout":             # 不适用括号, 我们并不是在调用函数             # 我们是在返回一个函数对象             return shout         else:             return whisper  # 你要如何使用这洪荒巨兽呢?  # 取得函数, 并将其赋给一个变量 talk = getTalk()  # 此处, 你可以看见"talk"是一个函数对象 print talk #输出 : <function shout at 0xb7ea817c>  # 以下对象是函数"talk"的一项返回 print talk() #输出 : Yes!  # 你甚至可以直接使用 # And you can even use it directly if you feel wild: 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):      # 在装饰器的内部, 定义一个"wrapper"函数     # wrapper函数用于包装原函数, 以在原函数前后执行代码     def the_wrapper_around_the_original_function():          # 在此处输入你想在调用原函数之前执行的代码         print "Before the function runs"          # 调用被装饰的函数(是函数调用, 需要括号)         a_function_to_decorate()          # 在此处输入你想在调用原函数之后执行的代码         print "After the function runs"      # 此处, 被装饰的函数并没有被执行     # 返回刚刚创建的包装函数     # 包装函数包括被装饰的函数, 在函数前后执行的代码     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 = 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  # 这就是装饰器的作用了

@my_shiny_new_decorator def another_stand_alone_function(:     print "Leave me alone"  another_stand_alone_function( #outputs: #Before the function runs #Leave me alone #After the function runs

another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)

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() #输出: #</''''''/> # #tomatoes# # --ham-- # ~salad~ #</______/>

@bread @ingredients def sandwich(food="--ham--"):     print food  sandwich() #输出: #</''''''/> # #tomatoes# # --ham-- # ~salad~ #</______/>

@ingredients @bread def strange_sandwich(food="--ham--"):     print food  strange_sandwich() #输出: ##tomatoes# #</''''''/> # --ham-- #</______/> # ~salad~

# 加粗装饰器 def makebold(fn):     # 装饰器返回的新的函数     def wrapper():         # 在前后插入一些代码         return "<b>" + fn() + "</b>"     return wrapper  # 斜体装饰器 def makeitalic(fn):     # 装饰器返回的新的函数     def wrapper():         # 在前后插入一些代码         return "<i>" + fn() + "</i>"     return wrapper  @makebold @makeitalic def say():     return "hello"  print say() #输出: <b><i>hello</i></b>  # 等价于 def say():     return "hello" say = makebold(makeitalic(say))  print say() #输出: <b><i>hello</i></b>

# 这并不是黑魔法, 你只需要在包装过程中传入参数  def a_decorator_passing_arguments(function_to_decorate):     def a_wrapper_accepting_arguments(arg1, arg2):         print "I got args! Look:", arg1, arg2         function_to_decorate(arg1, arg2)     return a_wrapper_accepting_arguments  # 当你调用装饰器返回的函数时, 你调用了包装纸(wrapper) # 向包装纸传递的参数将可继续传递给被装饰函数  @a_decorator_passing_arguments def print_full_name(first_name, last_name):     print "My name is", first_name, last_name  print_full_name("Peter", "Venkman") # 输出: #I got args! Look: Peter Venkman #My name is Peter Venkman

def method_friendly_decorator(method_to_decorate):     def wrapper(self, lie):         lie = lie - 3 # 真好, 年龄更小了 :-)         return method_to_decorate(self, lie)     return wrapper   class Lucy(object):      def __init__(self):         self.age = 32      @method_friendly_decorator     def sayYourAge(self, lie):         print "I am %s, what did you think?" % (self.age + lie)  l = Lucy() l.sayYourAge(-3) #输出: I am 26, what did you think?

def a_decorator_passing_arbitrary_arguments(function_to_decorate):     # 包装纸接收任意参数     def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):         print "Do I have args?:"         print args         print kwargs         # 将得到的参数解压(unpack), 此处为*args, **kwargs         # 如果对解压不熟悉, 可参考         # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/         function_to_decorate(*args, **kwargs)     return a_wrapper_accepting_arbitrary_arguments  @a_decorator_passing_arbitrary_arguments def function_with_no_argument():     print "Python is cool, no argument here."  function_with_no_argument() #输出 #Do I have args?: #() #{} #python就是这么酷, 此地无参.  @a_decorator_passing_arbitrary_arguments def function_with_arguments(a, b, c):     print a, b, c  function_with_arguments(1,2,3) #输出 #Do I have args?: #(1, 2, 3) #{} #1 2 3  @a_decorator_passing_arbitrary_arguments def function_with_named_arguments(a, b, c, platypus="Why not ?"):     print "Do %s, %s and %s like platypus? %s" %/     (a, b, c, platypus)  function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!") #输出 #Do I have args ? : #('Bill', 'Linus', 'Steve') #{'platypus': 'Indeed!'} #Bill, Linus and Steve喜欢鸭嘴兽吗? 千真万确!  class Mary(object):      def __init__(self):         self.age = 31      @a_decorator_passing_arbitrary_arguments     def sayYourAge(self, lie=-3): # 现在你可以添加一个默认值         print "I am %s, what did you think ?" % (self.age + lie)  m = Mary() m.sayYourAge() #输出 # Do I have args?: #(<__main__.Mary object at 0xb7d303ac>,) #{} #I am 28, what did you think?

# 装饰器是 普通 函数 def my_decorator(func):     print "I am an ordinary function"     def wrapper():         print "I am function returned by the decorator"         func()     return wrapper  # 所以, 你可以不使用"@"调用它  def lazy_function():     print "zzzzzzzz"  decorated_function = my_decorator(lazy_function) #输出: I am an ordinary function  # 它将会输出 "I am an ordinary function", 因为这就是你所做的: # 调用一个函. 没有一点魔法在里面  @my_decorator def lazy_function():     print "zzzzzzzz"  #输出: I am an ordinary function

def decorator_maker():      print "I make decorators! I am executed only once: "+/           "when you make me create a decorator."      def my_decorator(func):          print "I am a decorator! I am executed only when you decorate a function."          def wrapped():             print ("I am the wrapper around the decorated function. "                   "I am called when you call the decorated function. "                   "As the wrapper, I return the RESULT of the decorated function.")             return func()          print "As the decorator, I return the wrapped function."          return wrapped      print "As a decorator maker, I return a decorator"     return my_decorator  # 让我们创建一个装饰器 new_decorator = decorator_maker() # 输出: #I make decorators! I am executed only once: when you make me create a decorator. #As a decorator maker, I return a decorator  # 接下来, 我们来装饰函数  def decorated_function():     print "I am the decorated function."  decorated_function = new_decorator(decorated_function) #输出: #I am a decorator! I am executed only when you decorate a function. #As the decorator, I return the wrapped function  # 调用函数: decorated_function() #输出: #I am the wrapper around the decorated function. I am called when you call the decorated function. #As the wrapper, I return the RESULT of the decorated function. #I am the decorated function.

def decorated_function():     print "I am the decorated function." decorated_function = decorator_maker()(decorated_function) #输出: #I make decorators! I am executed only once: when you make me create a decorator. #As a decorator maker, I return a decorator #I am a decorator! I am executed only when you decorate a function. #As the decorator, I return the wrapped function.  # 最后: decorated_function() #输出: #I am the wrapper around the decorated function. I am called when you call the decorated function. #As the wrapper, I return the RESULT of the decorated function. #I am the decorated function.

@decorator_maker() def decorated_function():     print "I am the decorated function." #outputs: #I make decorators! I am executed only once: when you make me create a decorator. #As a decorator maker, I return a decorator #I am a decorator! I am executed only when you decorate a function. #As the decorator, I return the wrapped function.  #Eventually: decorated_function() #outputs: #I am the wrapper around the decorated function. I am called when you call the decorated function. #As the wrapper, I return the RESULT of the decorated function. #I am the decorated function.

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):      print "I make decorators! And I accept arguments:", decorator_arg1, decorator_arg2      def my_decorator(func):         # 此处传递参数的能力, 得益于闭包的性质         # 如果你不习惯闭包, 你可以假设它是ok的, 或者看一下这篇文章:         # http://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python         print "I am the decorator. Somehow you passed me arguments:", decorator_arg1, decorator_arg2          # 不要混淆了装饰器参数和函数参数!         def wrapped(function_arg1, function_arg2) :             print ("I am the wrapper around the decorated function./n"                   "I can access all the variables/n"                   "/t- from the decorator: {0} {1}/n"                   "/t- from the function call: {2} {3}/n"                   "Then I can pass them to the decorated function"                   .format(decorator_arg1, decorator_arg2,                           function_arg1, function_arg2))             return func(function_arg1, function_arg2)          return wrapped      return my_decorator  @decorator_maker_with_arguments("Leonard", "Sheldon") def decorated_function_with_arguments(function_arg1, function_arg2):     print ("I am the decorated function and only knows about my arguments: {0}"            " {1}".format(function_arg1, function_arg2))  decorated_function_with_arguments("Rajesh", "Howard") #输出: #I make decorators! And I accept arguments: Leonard Sheldon #I am the decorator. Somehow you passed me arguments: Leonard Sheldon #I am the wrapper around the decorated function. #I can access all the variables #   - from the decorator: Leonard Sheldon #   - from the function call: Rajesh Howard #Then I can pass them to the decorated function #I am the decorated function and only knows about my arguments: Rajesh Howard

c1 = "Penny" c2 = "Leslie"  @decorator_maker_with_arguments("Leonard", c1) def decorated_function_with_arguments(function_arg1, function_arg2):     print ("I am the decorated function and only knows about my arguments:"            " {0} {1}".format(function_arg1, function_arg2))  decorated_function_with_arguments(c2, "Howard") #输出: #I make decorators! And I accept arguments: Leonard Penny #I am the decorator. Somehow you passed me arguments: Leonard Penny #I am the wrapper around the decorated function. #I can access all the variables #   - from the decorator: Leonard Penny #   - from the function call: Leslie Howard #Then I can pass them to the decorated function #I am the decorated function and only knows about my arguments: Leslie Howard

def decorator_with_args(decorator_to_enhance):     """     这个函数被用作一个装饰器.     它必须装饰另一个函数, 那个函数也是一个装饰器     它允许任何装饰器接收任意数量的参数, 这样就不用每次写(装饰器)的时候都回忆一遍.     """      # 使用了与上述一样的技巧传递参数     def decorator_maker(*args, **kwargs):          # 我们在运行时创建了一个装饰器, 它接收一个函数作为参数         # 但它可以持有maker传来的参数         def decorator_wrapper(func):              # 我们返回原始装饰器的结果, 一个普通函数             # 唯一的异错的地方在于: 装饰器必须这样才能正常工作             return decorator_to_enhance(func, *args, **kwargs)          return decorator_wrapper      return decorator_maker

# 你可以创建一个用作装饰器的函数. 再用一个装饰器来装饰它 # 不要忘了, 用法是"decorator(func, *args, **kwargs)" @decorator_with_args def decorated_decorator(func, *args, **kwargs):     def wrapper(function_arg1, function_arg2):         print "Decorated with", args, kwargs         return func(function_arg1, function_arg2)     return wrapper  # 现在, 你可以用刚刚创建的被装饰的装饰器来装饰函数了  @decorated_decorator(42, 404, 1024) def decorated_function(function_arg1, function_arg2):     print "Hello", function_arg1, function_arg2  decorated_function("Universe and", "everything") #输出: #Decorated with (42, 404, 1024) {} #Hello Universe and everything  # 哇!

# 为了调试方便, 栈回溯(stacktrace)打印函数的__name__属性 def foo():     print "foo"  print foo.__name__ #输出: foo  # 当使用装饰器时, 就显得混乱了 def bar(func):     def wrapper():         print "bar"         return func()     return wrapper  @bar def foo():     print "foo"  print foo.__name__ #输出: wrapper  # "functools"`模块能解决这个问题  import functools  def bar(func):     # 我们说"wrapper"包装了"func", 然后魔法就发生了     @functools.wraps(func)     def wrapper():         print "bar"         return func()     return wrapper  @bar def foo():     print "foo"  print foo.__name__ #输出: foo

def benchmark(func):     """     打印函数被执行的时间的装饰器     """     import time     def wrapper(*args, **kwargs):         t = time.clock()         res = func(*args, **kwargs)         print func.__name__, time.clock()-t         return res     return wrapper   def logging(func):     """     记录脚本活动的装饰器     (事实上, 它只是进行了打印, 但可以进行日志打印)     """     def wrapper(*args, **kwargs):         res = func(*args, **kwargs)         print func.__name__, args, kwargs         return res     return wrapper   def counter(func):     """     统计并打印函数被执行次数的装饰器     """     def wrapper(*args, **kwargs):         wrapper.count = wrapper.count + 1         res = func(*args, **kwargs)         print "{0} has been used: {1}x".format(func.__name__, wrapper.count)         return res     wrapper.count = 0     return wrapper  @counter @benchmark @logging def reverse_string(string):     return str(reversed(string))  print reverse_string("Able was I ere I saw Elba") print reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!")  #输出: #reverse_string ('Able was I ere I saw Elba',) {} #wrapper 0.0 #wrapper has been used: 1x #ablE was I ere I saw elbA #reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {} #wrapper 0.0 #wrapper has been used: 2x #!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A

@counter @benchmark @logging def get_random_futurama_quote():     from urllib import urlopen     result = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()     try:         value = result.split("<br><b><hr><br>")[1].split("<br><br><hr>")[0]         return value.strip()     except:         return "No, I'm ... doesn't!"   print get_random_futurama_quote() print get_random_futurama_quote()  #输出: #get_random_futurama_quote () {} #wrapper 0.02 #wrapper has been used: 1x #The laws of science be a harsh mistress. #get_random_futurama_quote () {} #wrapper 0.01 #wrapper has been used: 2x #Curse you, merciful Poseidon!