Как использовать декораторы Python для проверки аргументов функции?

на 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')"

вы можете использовать функцию, а не лямбда, чтобы получить имя в ошибке утверждения.

как вы, конечно, знаете, это не питон, чтобы отклонить аргумент только на основе его типа.
Питонический подход скорее "попробуйте разобраться с ним сначала"
Вот почему я бы предпочел сделать декоратора для преобразования аргументов

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))

чтобы применить строковые аргументы к синтаксическому анализатору, который будет бросать загадочные ошибки при предоставлении нестрокового ввода, я написал следующее, которое пытается избежать выделения и вызовов функций:

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

все эти сообщения кажутся устаревшими - pint теперь предоставляет эту встроенную функциональность. См.здесь. Скопировано здесь для потомков:

проверка размерности, когда вы хотите, чтобы количества пинты использовались как входные сигналы к вашим функциям, Пинта обеспечивают оболочку для обеспечения блоков правильного типа - или, точнее, они соответствуют ожидаемому размерность физической величины.

подобно wraps (), вы можете передать None, чтобы пропустить проверку некоторых параметры, но тип возвращаемого параметра не проверяется.

>>> mypp = ureg.check('[length]')(pendulum_period) 

в формате оформитель:

>>> @ureg.check('[length]')
... def pendulum_period(length):
...     return 2*math.pi*math.sqrt(length/G)

У меня есть немного улучшенная версия @ jbouwmans sollution, используя модуль Python decorator, который делает декоратор полностью прозрачным и сохраняет не только подпись, но и docstrings на месте и может быть самым элегантным способом использования декораторов

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'>