我想定义一些通用的装饰调用一些功能前检查参数。
就像是：
@checkArguments(types = ['int', 'float'])
def myFunction(thisVarIsAnInt, thisVarIsAFloat)
''' Here my code '''
pass
旁注：
- 类型检查只是这里要说明的一个例子
- 我使用Python 2.7但是Python 3.0对子级也很感兴趣
Answer 1:
从装饰的函数和方法 ：
def accepts(*types):
def check_accepts(f):
assert len(types) == f.func_code.co_argcount
def new_f(*args, **kwds):
for (a, t) in zip(args, types):
assert isinstance(a, t), \
"arg %r does not match %s" % (a,t)
return f(*args, **kwds)
new_f.func_name = f.func_name
return new_f
return check_accepts
用法：
@accepts(int, (int,float))
def func(arg1, arg2):
return arg1 * arg2
func(3, 2) # -> 6
func('3', 2) # -> AssertionError: arg '3' does not match <type 'int'>
Answer 2:
关于Python 3.3，你可以使用功能注释和检查：
import inspect
def validate(f):
def wrapper(*args):
fname = f.__name__
fsig = inspect.signature(f)
vars = ', '.join('{}={}'.format(*pair) for pair in zip(fsig.parameters, args))
params={k:v for k,v in zip(fsig.parameters, args)}
print('wrapped call to {}({})'.format(fname, params))
for k, v in fsig.parameters.items():
p=params[k]
msg='call to {}({}): {} failed {})'.format(fname, vars, k, v.annotation.__name__)
assert v.annotation(params[k]), msg
ret = f(*args)
print(' returning {} with annotation: "{}"'.format(ret, fsig.return_annotation))
return ret
return wrapper
@validate
def xXy(x: lambda _x: 10<_x<100, y: lambda _y: isinstance(_y,float)) -> ('x times y','in X and Y units'):
return x*y
xy = xXy(10,3)
print(xy)
如果有一个验证错误，打印：
AssertionError: call to xXy(x=12, y=3): y failed <lambda>)
如果没有验证错误，打印：
wrapped call to xXy({'y': 3.0, 'x': 12})
returning 36.0 with annotation: "('x times y', 'in X and Y units')"
您可以使用一个函数，而不是一个拉姆达在断言失败得名。
Answer 3:
正如你当然知道，这不是Python的拒绝仅基于其类型的参数。
Python化的做法是宁可“先试试对付它”
这就是为什么我宁愿做一个装饰的参数转换
def enforce(*types):
def decorator(f):
def new_f(*args, **kwds):
#we need to convert args into something mutable
newargs = []
for (a, t) in zip(args, types):
newargs.append( t(a)) #feel free to have more elaborated convertion
return f(*newargs, **kwds)
return new_f
return decorator
这样一来，你的函数被送入与你所期望的类型，但如果参数可以嘎嘎像漂浮，被接受
@enforce(int, float)
def func(arg1, arg2):
return arg1 * arg2
print (func(3, 2)) # -> 6.0
print (func('3', 2)) # -> 6.0
print (func('three', 2)) # -> ValueError: invalid literal for int() with base 10: 'three'
我用这一招（与适当的转换方法）来处理载体 。
许多方法我写想到MyVector类，因为它有很多功能的; 但有时你只想写
transpose ((2,4))
Answer 4:
为了执行字符串参数时与非字符串输入提供的，将抛出神秘的错误解析器，我写了下面，它试图避免分配和函数调用：
from functools import wraps
def argtype(**decls):
"""Decorator to check argument types.
Usage:
@argtype(name=str, text=str)
def parse_rule(name, text): ...
"""
def decorator(func):
code = func.func_code
fname = func.func_name
names = code.co_varnames[:code.co_argcount]
@wraps(func)
def decorated(*args,**kwargs):
for argname, argtype in decls.iteritems():
try:
argval = args[names.index(argname)]
except ValueError:
argval = kwargs.get(argname)
if argval is None:
raise TypeError("%s(...): arg '%s' is null"
% (fname, argname))
if not isinstance(argval, argtype):
raise TypeError("%s(...): arg '%s': type is %s, must be %s"
% (fname, argname, type(argval), argtype))
return func(*args,**kwargs)
return decorated
return decorator
Answer 5:
所有这些岗位似乎过时了-现在品脱提供内置此功能，请参阅。 在这里 。 复制在这里为后人：
检查维当你想品脱量用作输入你的函数，品脱提供包装，以确保单位是正确类型的 - 或者更准确地说，它们匹配的物理量的预期维度。
至包装（）类似，您可以通过无跳过某些参数的检查，但返回的参数类型不作检查。
>>> mypp = ureg.check('[length]')(pendulum_period)在装饰格式：
>>> @ureg.check('[length]') ... def pendulum_period(length): ... return 2*math.pi*math.sqrt(length/G)
Answer 6:
我有@jbouwmans sollution的小幅改进版，使用python装饰模块，这使得装饰完全透明的，不仅保持签名，而且文档字符串到位，可能是使用装饰的最优雅的方式
from decorator import decorator
def check_args(**decls):
"""Decorator to check argument types.
Usage:
@check_args(name=str, text=str)
def parse_rule(name, text): ...
"""
@decorator
def wrapper(func, *args, **kwargs):
code = func.func_code
fname = func.func_name
names = code.co_varnames[:code.co_argcount]
for argname, argtype in decls.iteritems():
try:
argval = args[names.index(argname)]
except IndexError:
argval = kwargs.get(argname)
if argval is None:
raise TypeError("%s(...): arg '%s' is null"
% (fname, argname))
if not isinstance(argval, argtype):
raise TypeError("%s(...): arg '%s': type is %s, must be %s"
% (fname, argname, type(argval), argtype))
return func(*args, **kwargs)
return wrapper
Answer 7:
我想了Python 3.5这个问题的答案是beartype 。 作为该解释后它配备了方便的功能。 然后，您的代码应该是这样的
from beartype import beartype
@beartype
def sprint(s: str) -> None:
print(s)
并导致
>>> sprint("s")
s
>>> sprint(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 13, in func_beartyped
TypeError: sprint() parameter s=3 not of <class 'str'>
Answer 8:
def decorator(function):
def validation(*args):
if type(args[0]) == int and \
type(args[1]) == float:
return function(*args)
else:
print('Not valid !')
return validation
文章来源: How to use Python decorators to check function arguments?
