Python装饰器用法实例总结

registry = []
def register(decorated):
 registry.append(decorated)
 return decorated

@register
def foo():
 return 3
@register
def bar():
 return 5

answers = []
for func in registry:
  answers.append(func())

class Registry(object):
 def __init__(self):
  self._functions = []
 def register(self, decorated):
  self._functions.append(decorated)
  return decorated
 def run_all(self, *args, **kwargs):
   return_values = []
   for func in self._functions:
    return_values.append(func(*args, **kwargs))
   return return_values

a = Registry()
b = Registry()
@a.register
def foo(x=3):
 return x
@b.register
def bar(x=5):
 return x
@a.register
@b.register
def baz(x=7):
 return x

a.run_all() # [3, 7]
b.run_all() # [5, 7]

a.run_all(x=4) # [4, 4]

def requires_ints(decorated):
 def inner(*args, **kwargs):
  #获取任何可能被发送的关键值参数
  kwarg_values = [i for i in kwargs.values()]
  #在发送给被装饰方法的每个值上面进行迭代，确保每一个都是整数；
  #如果不是抛 TypeError 
  for arg in list(args) + kwarg_values:
   if not isinstance(arg, int):
    raise TypeError('%s only accepts integers as  
       arguments.' % decorated.__name__)        
    #运行被装饰方法，返回结果
   return decorated(*args, **kwargs)
 return inner

@requires_ints
def foo(x, y):
"""Return the sum of x and y."""
 return x + y

Help on function inner in module __main__:
inner(*args, **kwargs)
(END)

import functools
def requires_ints(decorated):
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  #获取可能已作为键值参数发送的任何值
  kwarg_values = [i for i in kwargs.values()]
  #迭代发送给被装饰函数的每个值, 并
  #确保每个参数都是整数，否则抛TypeError
  for arg in args + kwarg_values:
   if not isinstance(i, int):
    raise TypeError('%s only accepts integers as 
     arguments.' %decorated.__name__)
  #运行被装饰函数然后返回结果
  return decorated(*args, **kwargs)
 return inner

@requires_ints
def foo(x, y):
"""Return the sum of x and y."""
 return x + y

Help on function foo in module __main__:
foo(x, y)
Return the sum of x and y.
(END)

class User(object):
"""A representation of a user in our application."""
 def __init__(self, username, email):
  self.username = username
  self.email = email
class AnonymousUser(User):
"""An anonymous user; a stand-in for an actual user that nonetheless
is not an actual user.
"""
 def __init__(self):
  self.username = None
  self.email = None
 def __nonzero__(self):
  return False

import functools
def requires_user(func):
 @functools.wraps(func)
 def inner(user, *args, **kwargs):
  """Verify that the user is truthy; if so, run the 
  decorated method,
  and if not, raise ValueError.
  """
  # Ensure that user is truthy, and of the correct type.
  # The "truthy"check will fail on anonymous users, since the
  # AnonymousUser subclass has a ‘__nonzero__‘ method that
  # returns False.
  if user and isinstance(user, User):
   return func(user, *args, **kwargs)
  else:
   raise ValueError('A valid user is required to run 
    this.')
 return inner

import functools
import json
def json_output(decorated):
 """Run the decorated function, serialize the result of 
 that function
 to JSON, and return the JSON string.
 """
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  result = decorated(*args, **kwargs)
  return json.dumps(result)
 return inner

@json_output
def do_nothing():
 return {'status': 'done'}

> do_nothing()
'{"status": "done"}'

import functools
import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(decorated):
 """Run the decorated function, serialize the result of  
 that function
 to JSON, and return the JSON string.
 """
 @functools.wraps(decorated)
 def inner(*args, **kwargs):
  try:
   result = decorated(*args, **kwargs)
  except JSONOutputError as ex:
   result = {
   'status': 'error',
   'message': str(ex),
   }
  return json.dumps(result)
 return inner

@json_output
def error():
 raise JSONOutputError('This function is erratic.')

> error()
'{"status": "error", "message": "This function is erratic."}'

import functools
import logging
import time
def logged(method):
 """Cause the decorated method to be run and its results  
 logged, along
 with some other diagnostic information.
 """
 @functools.wraps(method)
 def inner(*args, **kwargs): 
  #Record our start time.
  start = time.time()
  #Run the decorated method.
  return_value = method(*args, **kwargs)
  #Record our completion time, and calculate the delta.
  end = time.time()
  delta = end - start
  #Log the method call and the result.
  logger = logging.getLogger('decorator.logged')
  logger.warn('Called method %s at %.02f; execution time  
   %.02f seconds; result %r.' %
   (method.__name__, start, delta, return_value))    
   #Return the methods original return value.
  return return_value
 return inner

> import time
> @logged… def sleep_and_return(return_value):
... time.sleep(2)
... return return_value…
>
> sleep_and_return(42)
Called method sleep_and_return at 1424462194.70;
execution time 2.00 seconds; result 42.
42

import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(indent=None, sort_keys=False):
 """Run the decorated function, serialize the result of 
 that function
 to JSON, and return the JSON string.
 """
 def actual_decorator(decorated):
  @functools.wraps(decorated)
  def inner(*args, **kwargs):
   try:
     result = decorated(*args, **kwargs)
   except JSONOutputError as ex:
     result = {
     'status': 'error',
     'message': str(ex),
     }
   return json.dumps(result, indent=indent,   
    sort_keys=sort_keys)
   return inner
 return actual_decorator

@json_output(indent=4)
def do_nothing():
 return {'status': 'done'}

> do_nothing()
'{\n   "status": "done"\n}'

@json_output(indent=4)
def do_nothing():
 return {'status': 'done'}

@actual_decorator
def do_nothing():
 return {'status': 'done'}

@json_output()
def do_nothing():
 return {'status': 'done'}

@json_output
def do_nothing():
 return {'status': 'done'}

@json_output
@json_output()
@json_output(indent=4)

import functools
import json
class JSONOutputError(Exception):
 def __init__(self, message):
  self._message = message
 def __str__(self):
  return self._message
def json_output(decorated_=None, indent=None, sort_keys=False):
 """Run the decorated function, serialize the result of that function
 to JSON, and return the JSON string.
 """
 # Did we get both a decorated method and keyword arguments"_blank" href="https://www.jb51.net/Special/663.htm">Python数据结构与算法教程》、《Python加密解密算法与技巧总结》、《Python编码操作技巧总结》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》及《Python入门与进阶经典教程》

希望本文所述对大家Python程序设计有所帮助。