实现一个装饰器用于检查被装饰函数的参数类型

迈不过友情╰ 2022-12-11 09:18 123阅读 0赞

# 带参数的装饰器，也就是根据参数制定化一个装饰器 可以看成生成装饰器的工厂 #

# 每次调用typeassert, 返回一个特定的装饰器，用它去修饰其他函数 #

def typeassert(*ty_args, **ty_kargs):  # 一个生产装饰器的工厂 根据不同的参数生产不同的装饰器
        def decorator(func):  # 装饰器
            # 获取到函数参数和它类型的之间的映射关系
            # func的签名 也就是有哪些参数 a,b
            # 类型信息*ty_args, **ty_kargs
            # 通过类型信息建立一个字典 d = {"a": int, "b": str}
            def wrapper(*args, **kargs):
                # 在函数调用时做类型检查 arg in d, instance (arg, d[arg]) # 判断arg 是否是d[arg]的实例， 如果是则正常运行，否则抛出一个异常
                func(*args, **kargs)
            return wrapper
        return decorator

# 获取函数的签名 #

from inspect import signature
    def functn(a, b, c=1):
        pass
    sig = signature(functn) # 获取functn的签名
    
    sig.parameters # 参数的字典 包含了functn函数参数的信息
    a = sig.parameters['a']
    print(a.name)
    print(a.default)
    c = sig.parameters['c']
    print(c.default)
    print(c.kind)
    # print(dir(c))

# 为a,b,c 创建一个字典 #

bargs = sig.bind(str, int, int)   # bind 和函数调用是做同样的检查，某些必须传的参数没有穿则会报错
    print(bargs.arguments)  # 字典
    print(bargs.arguments['a'])
    print(bargs.arguments['b'])

# 某一些参数是不做类型检查的，只对某一些参数进行类型映射关系 #

sig.bind_partial(str)
    
    # 开始
    from inspect import signature
    def typeassert(*ty_args, **ty_kargs):  # 一个生产装饰器的工厂
        def decorator(func):  # 装饰器
            sig = signature(func)
            btypes = sig.bind_partial(*ty_args, **ty_kargs).arguments
            def wrapper(*args, **kargs):
                for name, obj in sig.bind(*args, **kargs).arguments.items():
                    if name in btypes:
                        if not isinstance(obj, btypes[name]):
                            raise TypeError(f'{name} must be {btypes[name]}')
                func(*args, **kargs)
            return wrapper
        return decorator
    
    @typeassert(int, str, list)
    def f(a, b, c):
        print(a, b, c)
    
    f(1,'hello', ['world', '!'])
    f(1,'hello', 'world')  # 参数错的