python装饰器是一个消除冗余的强大工具。随着将功能模块化为大小合适的方法，即使是最复杂的工作流，装饰器也能使它变成简洁的功能。
例如让我们看看django web框架，该框架处理请求的方法接收一个方法对象，返回一个响应对象：
def handle_request(request):
return httpresponse(“hello, world”)
我最近遇到一个案例，需要编写几个满足下述条件的api方法：
返回json响应
如果是get请求，那么返回错误码
做为一个注册api端点例子，我将会像这样编写：
def register(request):
result = none
# check for post only
if request.method != ‘post’:
result = {“error”: “this method only accepts posts!”}
else:
try:
user = user.objects.create_user(request.post[‘username’],
request.post[’email’],
request.post[‘password’])
# optional fields
for field in [‘first_name’, ‘last_name’]:
if field in request.post:
setattr(user, field, request.post[field])
user.save()
result = {“success”: true}
except keyerror as e:
result = {“error”: str(e) }
response = httpresponse(json.dumps(result))
if “error” in result:
response.status_code = 500
return response
然而这样我将会在每个api方法中编写json响应和错误返回的代码。这将会导致大量的逻辑重复。所以让我们尝试用装饰器实现dry原则吧。
装饰器简介
如果你不熟悉装饰器，我可以简单解释一下，实际上装饰器就是有效的函数包装器，python解释器加载函数的时候就会执行包装器，包装器可以修改函数的接收参数和返回值。举例来说，如果我想要总是返回比实际返回值大一的整数结果，我可以这样写装饰器：
# a decorator receives the method it’s wrapping as a variable ‘f’
def increment(f):
# we use arbitrary args and keywords to
# ensure we grab all the input arguments.
def wrapped_f(*args, **kw):
# note we call f against the variables passed into the wrapper,
# and cast the result to an int and increment .
return int(f(*args, **kw)) + 1
return wrapped_f # the wrapped function gets returned.
现在我们就可以用@符号和这个装饰器去装饰另外一个函数了：
@increment
def plus(a, b):
return a + b
result = plus(4, 6)
assert(result == 11, “we wrote our decorator wrong!”)
装饰器修改了存在的函数，将装饰器返回的结果赋值给了变量。在这个例子中，’plus’的结果实际指向increment(plus)的结果。
对于非post请求返回错误
现在让我们在一些更有用的场景下应用装饰器。如果在django中接收的不是post请求，我们用装饰器返回一个错误响应。
def post_only(f):
“”” ensures a method is post only “””
def wrapped_f(request):
if request.method != “post”:
response = httpresponse(json.dumps(
{“error”: “this method only accepts posts!”}))
response.status_code = 500
return response
return f(request)
return wrapped_f
现在我们可以在上述注册api中应用这个装饰器：
@post_only
def register(request):
result = none
try:
user = user.objects.create_user(request.post[‘username’],
request.post[’email’],
request.post[‘password’])
# optional fields
for field in [‘first_name’, ‘last_name’]:
if field in request.post:
setattr(user, field, request.post[field])
user.save()
result = {“success”: true}
except keyerror as e:
result = {“error”: str(e) }
response = httpresponse(json.dumps(result))
if “error” in result:
response.status_code = 500
return response
现在我们就有了一个可以在每个api方法中重用的装饰器。
发送json响应
为了发送json响应（同时处理500状态码），我们可以新建另外一个装饰器：
def json_response(f):
“”” return the response as json, and return a 500 error code if an error exists “””
def wrapped(*args, **kwargs):
result = f(*args, **kwargs)
response = httpresponse(json.dumps(result))
if type(result) == dict and ‘error’ in result:
response.status_code = 500
return response
现在我们就可以在原方法中去除json相关的代码，添加一个装饰器做为代替：
post_only
@json_response
def register(request):
try:
user = user.objects.create_user(request.post[‘username’],
request.post[’email’],
request.post[‘password’])
# optional fields
for field in [‘first_name’, ‘last_name’]:
if field in request.post:
setattr(user, field, request.post[field])
user.save()
return {“success”: true}
except keyerror as e:
return {“error”: str(e) }
现在，如果我需要编写新的方法，那么我就可以使用装饰器做冗余的工作。如果我要写登录方法，我只需要写真正相关的代码：
@post_only
@json_response
def login(request):
if request.user is not none:
return {“error”: “user is already authenticated!”}
user = auth.authenticate(request.post[‘username’], request.post[‘password’])
if user is not none:
if not user.is_active:
return {“error”: “user is inactive”}
auth.login(request, user)
return {“success”: true, “id”: user.pk}
else:
return {“error”: “user does not exist with those credentials”}
bonus: 参数化你的请求方法
我曾经使用过tubogears框架，其中请求参数直接解释转递给方法这一点我很喜欢。所以要怎样在django中模仿这一特性呢？嗯，装饰器就是一种解决方案！
例如:
def parameterize_request(types=(“post”,)):
“””
parameterize the request instead of parsing the request directly.
only the types specified will be added to the query parameters.
e.g. convert a=test&b=cv in request.post to
f(a=test, b=cv)
“””
def wrapper(f):
def wrapped(request):
kw = {}
if “get” in types:
for k, v in request.get.items():
kw[k] = v
if “post” in types:
for k, v in request.post.items():
kw[k] = v
return f(request, **kw)
return wrapped
return wrapper
注意这是一个参数化装饰器的例子。在这个例子中，函数的结果是实际的装饰器。
现在我就可以用参数化装饰器编写方法了！我甚至可以选择是否允许get和post，或者仅仅一种请求参数类型。
@post_only
@json_response
@parameterize_request([“post”])
def register(request, username, email, password,
first_name=none, last_name=none):
user = user.objects.create_user(username, email, password)
user.first_name=first_name
user.last_name=last_name
user.save()
return {“success”: true}
现在我们有了一个简洁的、易于理解的api。
bonus #2: 使用functools.wraps保存docstrings和函数名
很不幸，使用装饰器的一个副作用是没有保存方法名(__name__)和docstring(__doc__)值：
def increment(f):
“”” increment a function result “””
wrapped_f(a, b):
return f(a, b) + 1
return wrapped_f
@increment
def plus(a, b)
“”” add two things together “””
return a + b
plus.__name__ # this is now ‘wrapped_f’ instead of ‘plus’
plus.__doc__ # this now returns ‘increment a function result’ instead of ‘add two things together’
这将对使用反射的应用造成麻烦，比如sphinx，一个 自动生成文档的应用。
为了解决这个问题，我们可以使用’wraps’装饰器附加上名字和docstring：
from functools import wraps
def increment(f):
“”” increment a function result “””
@wraps(f)
wrapped_f(a, b):
return f(a, b) + 1
return wrapped_f
@increment
def plus(a, b)
“”” add two things together “””
return a + b
plus.__name__ # this returns ‘plus’
plus.__doc__ # this returns ‘add two things together’
bonus #3: 使用’decorator’装饰器
如果仔细看看上述使用装饰器的方式，在包装器声明和返回的地方也有不少重复。
你可以安装python egg ‘decorator’，其中包含一个提供装饰器模板的’decorator’装饰器！
使用easy_install:
$ sudo easy_install decorator
或者pip:
$ pip install decorator
然后你可以简单的编写：
from decorator import decorator
@decorator
def post_only(f, request):
“”” ensures a method is post only “””
if request.method != “post”:
response = httpresponse(json.dumps(
{“error”: “this method only accepts posts!”}))
response.status_code = 500
return response
return f(request)
这个装饰器更牛逼的一点是保存了__name__和__doc__的返回值，也就是它封装了 functools.wraps的功能！