Python装饰器使用实例：验证参数合法性
python是不带静态检查的动态语言，有时候需要在调用函数时保证参数合法。检查参数合法性是一个显著的切面场景，各个函数都可能有这个需求。但另一方面，参数合法性是不是应该由调用方来保证比较好也是一个需要结合实际才能回答的问题，总之双方约定好，不要都不检查或者都检查就可以了。下面这个模块用于在函数上使用装饰器进行参数的合法性验证。
你可以直接执行这个模块进行测试，如果完全没有输出则表示通过。你也可以找到几个以_test开头的函数，所有的测试用例都包含在这几个函数中。使用方法参见模块文档和测试用例。
#-*-coding:UTF-8-*-
'''
@summary:验证器
该模块提供了一个装饰器用于验证参数是否合法，使用方法为：
fromvalidatorimportvalidParam,nullOk,multiType
@validParam(i=int)
deffoo(i):
returni+1
编写验证器：
1.仅验证类型：
@validParam(type,...)
例如：
检查第一个位置的参数是否为int类型：
@validParam(int)
检查名为x的参数是否为int类型：
@validParam(x=int)
验证多个参数：
@validParam(int,int)
指定参数名验证：
@validParam(int,s=str)
针对*和**参数编写的验证器将验证这些参数实际包含的每个元素：
@validParam(varargs=int)
deffoo(*varargs):pass
@validParam(kws=int)
deffoo7(s,**kws):pass
2.带有条件的验证：
@validParam((type,condition),...)
其中，condition是一个表达式字符串，使用x引用待验证的对象；
根据bool(表达式的值)判断是否通过验证，若计算表达式时抛出异常，视为失败。
例如：
验证一个10到20之间的整数：
@validParam(i=(int,'10<x<20'))
验证一个长度小于20的字符串：
@validParam(s=(str,'len(x)<20'))
验证一个年龄小于20的学生：
@validParam(stu=(Student,'x.age<20'))
另外，如果类型是字符串，condition还可以使用斜杠开头和结尾表示正则表达式匹配。
验证一个由数字组成的字符串：
@validParam(s=(str,'/^\d*$/'))
3.以上验证方式默认为当值是None时验证失败。如果None是合法的参数，可以使用nullOk()。
nullOk()接受一个验证条件作为参数。
例如：
@validParam(i=nullOk(int))
@validParam(i=nullOk((int,'10<x<20')))
也可以简写为：
@validParam(i=nullOk(int,'10<x<20'))
4.如果参数有多个合法的类型，可以使用multiType()。
multiType()可接受多个参数，每个参数都是一个验证条件。
例如：
@validParam(s=multiType(int,str))
@validParam(s=multiType((int,'x>20'),nullOk(str,'/^\d+$/')))
5.如果有更复杂的验证需求，还可以编写一个函数作为验证函数传入。
这个函数接收待验证的对象作为参数，根据bool(返回值)判断是否通过验证，抛出异常视为失败。
例如：
defvalidFunction(x):
returnisinstance(x,int)andx>0
@validParam(i=validFunction)
deffoo(i):pass
这个验证函数等价于：
@validParam(i=(int,'x>0'))
deffoo(i):pass
@author:HUXI
@since:2011-3-22
@change:
'''
importinspect
importre
classValidateException(Exception):pass
defvalidParam(*varargs,**keywords):
'''验证参数的装饰器。'''
varargs=map(_toStardardCondition,varargs)
keywords=dict((k,_toStardardCondition(keywords[k]))
forkinkeywords)
defgenerator(func):
args,varargname,kwname=inspect.getargspec(func)[:3]
dctValidator=_getcallargs(args,varargname,kwname,
varargs,keywords)
defwrapper(*callvarargs,**callkeywords):
dctCallArgs=_getcallargs(args,varargname,kwname,
callvarargs,callkeywords)
k,item=None,None
try:
forkindctValidator:
ifk==varargname:
foritemindctCallArgs[k]:
assertdctValidator[k](item)
elifk==kwname:
foritemindctCallArgs[k].values():
assertdctValidator[k](item)
else:
item=dctCallArgs[k]
assertdctValidator[k](item)
except:
raiseValidateException,\
('%s()parametervalidationfails,param:%s,value:%s(%s)'
%(func.func_name,k,item,item.__class__.__name__))
returnfunc(*callvarargs,**callkeywords)
wrapper=_wrapps(wrapper,func)
returnwrapper
returngenerator
def_toStardardCondition(condition):
'''将各种格式的检查条件转换为检查函数'''
ifinspect.isclass(condition):
returnlambdax:isinstance(x,condition)
ifisinstance(condition,(tuple,list)):
cls,condition=condition[:2]
ifconditionisNone:
return_toStardardCondition(cls)
ifclsin(str,unicode)andcondition[0]==condition[-1]=='/':
returnlambdax:(isinstance(x,cls)
andre.match(condition[1:-1],x)isnotNone)
returnlambdax:isinstance(x,cls)andeval(condition)
returncondition
defnullOk(cls,condition=None):
'''这个函数指定的检查条件可以接受None值'''
returnlambdax:xisNoneor_toStardardCondition((cls,condition))(x)
defmultiType(*conditions):
'''这个函数指定的检查条件只需要有一个通过'''
lstValidator=map(_toStardardCondition,conditions)
defvalidate(x):
forvinlstValidator:
ifv(x):
returnTrue
returnvalidate
def_getcallargs(args,varargname,kwname,varargs,keywords):
'''获取调用时的各参数名-值的字典'''
dctArgs={}
varargs=tuple(varargs)
keywords=dict(keywords)
argcount=len(args)
varcount=len(varargs)
callvarargs=None
ifargcount<=varcount:
forn,argnameinenumerate(args):
dctArgs[argname]=varargs[n]
callvarargs=varargs[-(varcount-argcount):]
else:
forn,varinenumerate(varargs):
dctArgs[args[n]]=var
forargnameinargs[-(argcount-varcount):]:
ifargnameinkeywords:
dctArgs[argname]=keywords.pop(argname)
callvarargs=()
ifvarargnameisnotNone:
dctArgs[varargname]=callvarargs
ifkwnameisnotNone:
dctArgs[kwname]=keywords
dctArgs.update(keywords)
returndctArgs
def_wrapps(wrapper,wrapped):
'''复制元数据'''
forattrin('__module__','__name__','__doc__'):
setattr(wrapper,attr,getattr(wrapped,attr))
forattrin('__dict__',):
getattr(wrapper,attr).update(getattr(wrapped,attr,{}))
returnwrapper
#===============================================================================
#测试
#===============================================================================
def_unittest(func,*cases):
forcaseincases:
_functest(func,*case)
def_functest(func,isCkPass,*args,**kws):
ifisCkPass:
func(*args,**kws)
else:
try:
func(*args,**kws)
assertFalse
exceptValidateException:
pass
def_test1_simple():
#检查第一个位置的参数是否为int类型：
@validParam(int)
deffoo1(i):pass
_unittest(foo1,
(True,1),
(False,'s'),
(False,None))
#检查名为x的参数是否为int类型：
@validParam(x=int)
deffoo2(s,x):pass
_unittest(foo2,
(True,1,2),
(False,'s','s'))
#验证多个参数：
@validParam(int,int)
deffoo3(s,x):pass
_unittest(foo3,
(True,1,2),
(False,'s',2))
#指定参数名验证：
@validParam(int,s=str)
deffoo4(i,s):pass
_unittest(foo4,
(True,1,'a'),
(False,'s',1))
#针对*和**参数编写的验证器将验证这些参数包含的每个元素：
@validParam(varargs=int)
deffoo5(*varargs):pass
_unittest(foo5,
(True,1,2,3,4,5),
(False,'a',1))
@validParam(kws=int)
deffoo6(**kws):pass
_functest(foo6,True,a=1,b=2)
_functest(foo6,False,a='a',b=2)
@validParam(kws=int)
deffoo7(s,**kws):pass
_functest(foo7,True,s='a',a=1,b=2)
def_test2_condition():
#验证一个10到20之间的整数：
@validParam(i=(int,'10<x<20'))
deffoo1(x,i):pass
_unittest(foo1,
(True,1,11),
(False,1,'a'),
(False,1,1))
#验证一个长度小于20的字符串：
@validParam(s=(str,'len(x)<20'))
deffoo2(a,s):pass
_unittest(foo2,
(True,1,'a'),
(False,1,1),
(False,1,'a'*20))
#验证一个年龄小于20的学生：
classStudent(object):
def__init__(self,age):self.age=age
@validParam(stu=(Student,'x.age<20'))
deffoo3(stu):pass
_unittest(foo3,
(True,Student(18)),
(False,1),
(False,Student(20)))
#验证一个由数字组成的字符串：
@validParam(s=(str,r'/^\d*$/'))
deffoo4(s):pass
_unittest(foo4,
(True,'1234'),
(False,1),
(False,'a1234'))
def_test3_nullok():
@validParam(i=nullOk(int))
deffoo1(i):pass
_unittest(foo1,
(True,1),
(False,'a'),
(True,None))
@validParam(i=nullOk(int,'10<x<20'))
deffoo2(i):pass
_unittest(foo2,
(True,11),
(False,'a'),
(True,None),
(False,1))
def_test4_multitype():
@validParam(s=multiType(int,str))
deffoo1(s):pass
_unittest(foo1,
(True,1),
(True,'a'),
(False,None),
(False,1.1))
@validParam(s=multiType((int,'x>20'),nullOk(str,'/^\d+$/')))
deffoo2(s):pass
_unittest(foo2,
(False,1),
(False,'a'),
(True,None),
(False,1.1),
(True,21),
(True,'21'))
def_main():
d=globals()
fromtypesimportFunctionType
print
forfind:
iff.startswith('_test'):
f=d[f]
ifisinstance(f,FunctionType):
f()
if__name__=='__main__':
_main()