blocks|key|386738|text|在Python3.3上，您可以使用函数注释并检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|386739|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)|code-block|syntax|javascript|386740|如果存在验证错误，请打印：|386741|AssertionError:+call+to+xXy(x=12,+y=3):+y+failed+<lambda>)|386742|如果没有验证错误，请打印：|386743|wrapped+call+to+xXy({'y':+3.0,+'x':+12})
++returning+36.0+with+annotation:+"('x+times+y',+'in+X+and+Y+units')"|386744|您可以使用函数而不是lambda来获得断言失败中的名称。|386745|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

On Python 3.3, you can use function annotations and inspect:

<pre><code>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&lt;_x&lt;100, y: lambda _y: isinstance(_y,float)) -&gt; ('x times y','in X and Y units'):
 return x*y

xy = xXy(10,3)
print(xy)
</code></pre>

If there is a validation error, prints:

<pre><code>AssertionError: call to xXy(x=12, y=3): y failed &lt;lambda&gt;)
</code></pre>

If there is not a validation error, prints:

<pre><code>wrapped call to xXy({'y': 3.0, 'x': 12})
 returning 36.0 with annotation: "('x times y', 'in X and Y units')"
</code></pre>

You can use a function rather than a lambda to get a name in the assertion failure.

blocks|key|1706473|text|来自函数和方法的装饰器|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1706474|Python+2|style|BOLD|1706475|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+%25r+does+not+match+%25s"+%25+(a,t)
++++++++++++return+f(*args,+**kwds)
++++++++new_f.func_name+=+f.func_name
++++++++return+new_f
++++return+check_accepts|code-block|syntax|javascript|1706476|Python+3|1706477|在Python3中，func_code已改为__code__，func_name已更改为__name__。|CODE|1706478|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+%25r+does+not+match+%25s"+%25+(a,t)
++++++++++++return+f(*args,+**kwds)
++++++++new_f.__name__+=+f.__name__
++++++++return+new_f
++++return+check_accepts|1706479|用法：|1706480|@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'>|1706481|arg2可以是int，也可以是float|1706482|entityMap|0|LINK|mutability|MUTABLE|url|http://www.python.org/dev/peps/pep-0318/^0|2|9|0|0|0|8|0|0|0|8|0|A|9|M|8|V|9|18|8|0|0|0|0|0|4|7|3|F|5|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|6|7|1B|8|@$A|1C|B|1D|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1E|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$A|1G|B|1H|F|G]]|9|@]|C|$]]|$1|O|3|P|5|6|7|1I|8|@$A|1J|B|1K|F|Q]|$A|1L|B|1M|F|Q]|$A|1N|B|1O|F|Q]|$A|1P|B|1Q|F|Q]]|9|@]|C|$]]|$1|R|3|S|5|J|7|1R|8|@]|9|@]|C|$K|L]]|$1|T|3|U|5|6|7|1S|8|@]|9|@]|C|$]]|$1|V|3|W|5|J|7|1T|8|@]|9|@]|C|$K|L]]|$1|X|3|Y|5|6|7|1U|8|@$A|1V|B|1W|F|Q]|$A|1X|B|1Y|F|Q]|$A|1Z|B|20|F|Q]]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|21|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]]]

From the <a href="http://www.python.org/dev/peps/pep-0318/" rel="noreferrer">Decorators for Functions and Methods</a>:

Python 2

<pre><code>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
</code></pre>

Python 3

In Python 3 <code>func_code</code> has changed to <code>__code__</code> and <code>func_name</code> has changed to <code>__name__</code>.

<pre><code>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
</code></pre>

Usage:

<pre><code>@accepts(int, (int,float))
def func(arg1, arg2):
 return arg1 * arg2

func(3, 2) # -&gt; 6
func('3', 2) # -&gt; AssertionError: arg '3' does not match &lt;type 'int'&gt;
</code></pre>

<code>arg2</code> can be either <code>int</code> or <code>float</code>

blocks|key|1706517|text|为了向解析器强制执行字符串参数，在提供非字符串输入时会引发神秘错误，我编写了以下内容，试图避免分配和函数调用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1706518|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("%25s(...):+arg+'%25s'+is+null"
++++++++++++++++++++++++++++++++++++%25+(fname,+argname))
++++++++++++++++if+not+isinstance(argval,+argtype):
++++++++++++++++++++raise+TypeError("%25s(...):+arg+'%25s':+type+is+%25s,+must+be+%25s"
++++++++++++++++++++++++++++++++++++%25+(fname,+argname,+type(argval),+argtype))
++++++++++++return+func(*args,**kwargs)
++++++++return+decorated

++++return+decorator|code-block|syntax|javascript|1706519|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To enforce string arguments to a parser that would throw cryptic errors when provided with non-string input, I wrote the following, which tries to avoid allocation and function calls:

<pre><code>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
</code></pre>

blocks|key|2495683|text|我有一个略为改进的@jbouwman解决方案，使用python装饰器模块，它使装饰器完全透明，不仅保持签名，而且保持文件字符串的位置，这可能是使用装饰器的最优雅的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2495684|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("%25s(...):+arg+'%25s'+is+null"
++++++++++++++++++++++++++++%25+(fname,+argname))
++++++++++++if+not+isinstance(argval,+argtype):
++++++++++++++++raise+TypeError("%25s(...):+arg+'%25s':+type+is+%25s,+must+be+%25s"
++++++++++++++++++++++++++++%25+(fname,+argname,+type(argval),+argtype))
++++return+func(*args,+**kwargs)
return+wrapper|code-block|syntax|javascript|2495685|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I have a slightly improved version of @jbouwmans sollution, using python decorator module, which makes the decorator fully transparent and keeps not only signature but also docstrings in place and might be the most elegant way of using decorators

<pre><code>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
</code></pre>

blocks|key|386893|text|正如你所知道的，仅仅根据一个论点的类型来拒绝它并不是节奏曲。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|386894|Pythonic的方法更像是“先处理它”。|386895|这就是为什么我宁愿做一个装潢师来转换论点|386896|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|code-block|syntax|javascript|386897|这样，您的函数就会得到您所期望的类型，但是如果参数可以像浮点一样嘎嘎地运行，则它将被接受。|386898|@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'|386899|我使用这个技巧(使用适当的转换方法)来处理向量。|offset|length|386900|我编写的许多方法都期望使用MyVector类，因为它具有大量的功能；但是有时您只想编写|386901|transpose+((2,4))|386902|entityMap|0|LINK|mutability|MUTABLE|url|http://holy-python.com/wordpress/la-librairie-vector2d-classe-vector2/^0|0|0|0|0|0|0|L|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|9|@$Q|1B|R|1C|1|1D]]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]]]

As you certainly know, it's not pythonic to reject an argument only based on its type. 
Pythonic approach is rather "try to deal with it first" 
That's why I would rather do a decorator to convert the arguments

<pre><code>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
</code></pre>

This way, your function is fed with the type you expect
But if the parameter can quack like a float, it is accepted

<pre><code>@enforce(int, float)
def func(arg1, arg2):
 return arg1 * arg2

print (func(3, 2)) # -&gt; 6.0
print (func('3', 2)) # -&gt; 6.0
print (func('three', 2)) # -&gt; ValueError: invalid literal for int() with base 10: 'three'
</code></pre>

I use this trick (with proper conversion method) to deal with <a href="http://holy-python.com/wordpress/la-librairie-vector2d-classe-vector2/" rel="noreferrer">vectors</a>. 
Many methods I write expect MyVector class as it has plenty of functionalities; but sometime you just want to write 

<pre><code>transpose ((2,4))
</code></pre>

blocks|key|386922|text|我认为Python3.5对这个问题的回答是轴承型。正如在这个帖子中所解释的，它提供了一些有用的特性。然后，您的代码将如下所示|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|386923|from+beartype+import+beartype
@beartype
def+sprint(s:+str)+->+None:
+++print(s)|code-block|syntax|javascript|386924|和结果|386925|>>>+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'>|386926|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/leycec/3d48cc60e7d5fe8860b077acb067dc54|1|https://stackoverflow.com/a/39145690/4680402^0|L|3|0|U|2|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|14|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

I think the Python 3.5 answer to this question is <a href="https://gist.github.com/leycec/3d48cc60e7d5fe8860b077acb067dc54" rel="nofollow noreferrer">beartype</a>. As explained in this <a href="https://stackoverflow.com/a/39145690/4680402">post</a> it comes with handy features. Your code would then look like this

<pre><code>from beartype import beartype
@beartype
def sprint(s: str) -&gt; None:
 print(s)
</code></pre>

and results in

<pre><code>&gt;&gt;&gt; sprint("s")
s
&gt;&gt;&gt; sprint(3)
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
 File "&lt;string&gt;", line 13, in func_beartyped
TypeError: sprint() parameter s=3 not of &lt;class 'str'&gt;
</code></pre>

blocks|key|1706681|text|所有这些帖子似乎都过时了--品脱现在提供了内置的功能。见这里。为子孙后代复制：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1706682|检查维度时，当您希望将品脱量用作函数的输入时，品脱提供了一个包装器，以确保单元的类型是正确的--或者更准确地说，它们与物理量的预期维度相匹配。
与wraps()类似，您可以传递None来跳过某些参数的检查，但是返回参数类型没有被选中。ureg.check('length')(pendulum_period)
在装饰格式中：
@ureg.check(‘长度’).def+pendulum_period(长度)：.返回2*math.pi*math.sqrt(长度/G)|blockquote|1706683|entityMap|0|LINK|mutability|MUTABLE|url|http://pint.readthedocs.io/en/latest/wrapping.html#checking-dimensionality^0|S|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@$A|P|B|Q|1|R]]|C|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|C|$]]]|H|$I|$5|J|K|L|C|$M|N]]]]

All of these posts seem out of date - pint now provides this functionality built in. See <a href="http://pint.readthedocs.io/en/latest/wrapping.html#checking-dimensionality" rel="nofollow noreferrer">here</a>. Copied here for posterity:

<blockquote>
 Checking dimensionality When you want pint quantities to be used as
 inputs to your functions, pint provides a wrapper to ensure units are
 of correct type - or more precisely, they match the expected
 dimensionality of the physical quantity.
 
 Similar to wraps(), you can pass None to skip checking of some
 parameters, but the return parameter type is not checked.

<pre><code>&gt;&gt;&gt; mypp = ureg.check('[length]')(pendulum_period) 
</code></pre>
 
 In the decorator format:

<pre><code>&gt;&gt;&gt; @ureg.check('[length]')
... def pendulum_period(length):
... return 2*math.pi*math.sqrt(length/G)
</code></pre>
</blockquote>

blocks|key|386984|text|包typeguard为此提供了一个修饰器，它从类型注释中读取类型信息，但是它需要>=3.5.2。我认为生成的代码相当不错。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|386985|@typeguard.typechecked
def+my_function(this_var_is_an_int:+int,+this_var_is_a_float:+float)
++++'''+Here+my+code+'''
++++pass|code-block|syntax|javascript|386986|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.org/project/typeguard/^0|1|9|1|9|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

The package <a href="https://pypi.org/project/typeguard/" rel="noreferrer"><code>typeguard</code></a> provides a decorator for this, it reads the type information from type annotations, it requires Python >=3.5.2 though. I think the resulting code is quite nice.

<pre class="lang-py prettyprint-override"><code>@typeguard.typechecked
def my_function(this_var_is_an_int: int, this_var_is_a_float: float)
 ''' Here my code '''
 pass
</code></pre>

blocks|key|387052|text|你可以试试装潢工。来自文档pydantic|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|387053|使用python类型注释进行数据验证和设置管理。pydantic在运行时强制类型提示，并在数据无效时提供用户友好的错误。在基准中，pydantic比所有其他测试库都要快。|blockquote|387054|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)
++++"""|code-block|syntax|javascript|387055|entityMap|0|LINK|mutability|MUTABLE|url|https://pydantic-docs.helpmanual.io/usage/validation_decorator/|1|https://pydantic-docs.helpmanual.io/benchmarks/^0|D|8|5|3|0|0|1P|2|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|I|3|J|5|K|7|17|8|@]|D|@]|E|$L|M]]|$1|N|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

you could try with the <a href="https://pydantic-docs.helpmanual.io/usage/validation_decorator/" rel="nofollow noreferrer">pydantic validation_decorator</a>. from the documentation pydantic:
<blockquote>
Data validation and settings management using python type annotations.
pydantic enforces type hints at runtime, and provides user friendly
errors when data is invalid.
In <a href="https://pydantic-docs.helpmanual.io/benchmarks/" rel="nofollow noreferrer">benchmarks</a> pydantic is faster than all other tested libraries.
</blockquote>
<pre><code>from pydantic import validate_arguments, ValidationError


@validate_arguments
def repeat(s: str, count: int, *, separator: bytes = b'') -&gt; bytes:
 b = s.encode()
 return separator.join(b for _ in range(count))


a = repeat('hello', 3)
print(a)
#&gt; b'hellohellohello'

b = repeat('x', '4', separator=' ')
print(b)
#&gt; b'x x x x'

try:
 c = repeat('hello', 'wrong')
except ValidationError as exc:
 print(exc)
 &quot;&quot;&quot;
 1 validation error for Repeat
 count
 value is not a valid integer (type=type_error.integer)
 &quot;&quot;&quot;
</code></pre>

blocks|key|2495857|text|对我来说，上面共享的代码看起来很复杂。我为类型检查定义“泛型装饰器”所做的工作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2495858|我使用了*args，**kwargs特性，在使用函数/方法时几乎没有额外的工作，但易于管理。|2495859|测试的适当示例定义|offset|length|style|BOLD|2495860|argument_types+=+{
'name':str,
'count':int,
'value':float
}|code-block|syntax|javascript|2495861|装饰定义|2495862|//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+|2495863|代码中的简单示例|2495864|//+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|2495865|entityMap^0|0|0|0|2|0|0|0|4|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|10|8|@$F|11|G|12|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|14|8|@$F|15|G|16|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|17|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|18|8|@$F|19|G|1A|H|I]]|9|@]|A|$]]|$1|U|3|V|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

For me, the codes shared above looks complicated. What I did for defining 'generic decorator' for type-check:
I used *args, **kwargs feature, little extra work when using function/method but easy to manage.
Appropriate example definition for test
<pre><code>argument_types = {
'name':str,
'count':int,
'value':float
}
</code></pre>
Decoration Defination
<pre><code>//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 
</code></pre>
Simple sample in code
<pre><code>// all other definitions

@azure_type
def stt(name:str, value:float)-&gt;(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

</code></pre>

I would like to define some generic decorators to check arguments before calling some functions.
Something like:
<pre><code>@checkArguments(types = ['int', 'float'])
def myFunction(thisVarIsAnInt, thisVarIsAFloat)
 ''' Here my code '''
 pass
</code></pre>
Side notes:
<ol>
<li>Type checking is just here to show an example</li>
<li>I'm using Python 2.7 but Python 3.0 whould be interesting too</li>
</ol>
EDIT 2021: funny that type checking did not go antipythonic in the long run with <a href="https://docs.python.org/3/library/typing.html" rel="noreferrer">type hinting</a> and <a href="https://mypy.readthedocs.io/en/stable/" rel="noreferrer">mypy</a>.

How to use Python decorators to check function arguments?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在调用某些函数之前，我想定义一些泛型装饰器来检查参数。类似于：@checkArguments(types = ['int', 'float'])def myFunction(thisVarIsAnInt, thisVarIsAFloat)    ''' Here my code '''    pass边注：类型检查只是...

问如何使用Python装饰器检查函数参数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使用Python装饰器检查函数参数？EN