我想在调用某些函数之前定义一些通用装饰器来检查参数。
就像是：
@checkArguments(types = ['int', 'float'])
def myFunction(thisVarIsAnInt, thisVarIsAFloat)
''' Here my code '''
pass
旁注：
编辑 2021：有趣的是，从长远来看，类型检查并没有使用类型提示和mypy 反python。
来自函数和方法的装饰器：
蟒蛇2
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
蟒蛇 3
在 Python 3func_code中已更改为__code__并func_name已更改为__name__.
def accepts(*types):
def check_accepts(f):
assert len(types) == f.__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.__name__ = f.__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'>
arg2可以是int或者float
在 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')"
您可以使用函数而不是 lambda 来获取断言失败中的名称。
如您所知，仅根据其类型拒绝参数并不是pythonic。
Pythonic 方法是“先尝试处理它”
这就是为什么我宁愿做一个装饰器来转换参数
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))
该包typeguard为此提供了一个装饰器，它从类型注释中读取类型信息，但它需要 Python >=3.5.2。我认为生成的代码非常好。
@typeguard.typechecked
def my_function(this_var_is_an_int: int, this_var_is_a_float: float)
''' Here my code '''
pass
为了强制解析器的字符串参数在提供非字符串输入时会引发神秘错误，我编写了以下内容，试图避免分配和函数调用：
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
我有一个稍微改进的@jbouwmans 解决方案版本，使用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
我认为这个问题的 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'>
所有这些帖子似乎都过时了 - pint 现在提供了内置的此功能。请参见此处。为后代复制这里：
检查维度当您希望将品脱量用作函数的输入时，品脱提供了一个包装器以确保单位的类型正确——或者更准确地说，它们与物理量的预期维度相匹配。
与 wraps() 类似，您可以传递 None 来跳过检查某些参数，但不检查返回参数类型。
>>> mypp = ureg.check('[length]')(pendulum_period)在装饰器格式中：
>>> @ureg.check('[length]') ... def pendulum_period(length): ... return 2*math.pi*math.sqrt(length/G)
您可以尝试使用pydantic validation_decorator。从文档pydantic：
使用 python 类型注释的数据验证和设置管理。pydantic 在运行时强制执行类型提示，并在数据无效时提供用户友好的错误。在基准测试中，pydantic 比所有其他经过测试的库都快。
from pydantic import validate_arguments, ValidationError
@validate_arguments
def repeat(s: str, count: int, *, separator: bytes = b'') -> bytes:
b = s.encode()
return separator.join(b for _ in range(count))
a = repeat('hello', 3)
print(a)
#> b'hellohellohello'
b = repeat('x', '4', separator=' ')
print(b)
#> b'x x x x'
try:
c = repeat('hello', 'wrong')
except ValidationError as exc:
print(exc)
"""
1 validation error for Repeat
count
value is not a valid integer (type=type_error.integer)
"""
对我来说，上面共享的代码看起来很复杂。我为类型检查定义“通用装饰器”所做的工作：
我使用了 *args、**kwargs 功能，在使用函数/方法时几乎没有额外的工作，但易于管理。
测试的适当示例定义
argument_types = {
'name':str,
'count':int,
'value':float
}
装修定义
//from functools import wraps
def azure_type(func):
@wraps(func)
def type_decorator(*args, **kwargs):
for key, value in kwargs.items():
if key in argument_types:
if type(value) != argument_types[key]:
#enter code here
return 'Error Message or what ever you like to do'
return func(*args, **kwargs)
return type_decorator
代码中的简单示例
// all other definitions
@azure_type
def stt(name:str, value:float)->(int):
#some calculation and creation of int output
count_output = #something int
return count_output
// call the function:
stt(name='ati', value=32.90) #can test from that