类型注解

类型提示的装饰器。
python是动态类型语言，也就是说一个变量的类型是在运行时决定的，一个变量的类型在应用的生命周期中是可变的。

但是当我们写一个函数时：

def add(x, y):
    return x + y
1
2

这个时候，就只能用int值作相加，但有时也会出现str + int的这种情况。于是就需要明确函数的类型。
一般在定义的函数中会加上注释：

def add(x, y):
    '''
    x + y
    :param x: int
    :param y: int
    :return: int
    '''
    return x + y
1
2
3
4
5
6
7
8

这样就可以调用help(add)来查看这个函数的文档，以确定函数的类型。但是这种方式并不会保证在更改函数后还能实时的更新文档。为了解决这个问题：

def add(x: int, y: int) -> int:
    return x + y
1
2

• 参数后面加冒号，冒号后面跟类型，对该参数的类型补充
• 函数定义完后，在最后一个冒号前面，加上一个短箭头，后面跟类型，代表该函数的返回类型。

此时用help查看如下：

>>> help(add)
Help on function add in module __main__:

add(x: int, y: int) -> int
1
2
3
4

当然，这只是一个注解而已，并不会强制限定你必须使用int类型，但是在写入参数时会出现警告提示。

如下可查看add的返回参数类型等：

>>> add.__annotations__
{'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
1
2

此外我们也可以使用typing来做类型注解：

import typing
def sum(lst: typing.List[int]) -> int:
    ret = 0
    for x in lst:
        ret += x
    return ret

>>> sum.__annotations__
{'lst': typing.List[int], 'return': <class 'int'>}
1
2
3
4
5
6
7
8
9

用装饰器实现函数的类型检查

写一个装饰器，实现函数的类型检查，导入一个库inspect（是一个反射库）

>>> import inspect
>>> sig = inspect.signature(add)
>>> sig.parameters
mappingproxy(OrderedDict([('x', <Parameter "x: int">), ('y', <Parameter "y: int">)]))
# 上面这个是参数字典

>>> sig.parameters['x']
<Parameter "x: int">
# 获取到整个x参数的详细信息，包括类型

>>> param = sig.parameters['x']
>>> param.default
<class 'inspect._empty'>
# 查看x参数的默认参数，如果有就可以获取到

>>> param.annotation
<class 'int'>
# 查看x参数的类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

利用这个库，就可以做一个类型检查，让我们的类型提示，变得真正的类型检查。
（位置参数都在args里面，关键字参数都在kwargs里面）

如下，写出大致模样：

def typed(fn):
    @functools.wraps(fn)
    def wrap(*args, **kwargs):
        # TODO，如何来检查
        params = inspect.signature(fn).parameters

        # 检查关键字参数
        for k, v in kwargs.items():
            if not isinstance(v, params[k].annotation):
                raise TypeError('parameter {} require {}, but {}'
                                .format(k, params[k].annotation, type(k)))

        # 检查位置参数
        for i, arg in enumerate(args):
            param = list(params.values())[i]
            if not isinstance(arg, param.annotation):
                raise TypeError('parameter {} required {}, but {}'
                                .format(param.name, param.annotation, type(arg)))

        return fn(*args, **kwargs)
    return wrap
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

测试一下：

@typed
def add(x: int, y: int) -> int:
    return x + y

print(add(1, 2))
# 结果
3
print(add('a', 2))
# 结果
TypeError: parameter x required <class 'int'>, but <class 'str'>
1
2
3
4
5
6
7
8
9
10

这里再传入字符后发生了类型报错，是符合参数校验逻辑的。
再对关键字参数进行测试：

print(add(y=3, a='a'))
#结果
if not isinstance(v, params[k].annotation): KeyError: 'a'
1
2
3

这里也发生了报错。目前为止，已经实现了这么一个装饰器的最基本逻辑。

下面对函数进行分析：

@functools.wraps没有问题，就是装饰器都需要加上这个，避免函数名和文档出现异常。
然后就是对关键字和位置参数的检查，注释写得很清楚，不同的是方法。
关键字参数比较简单，直接用k， v就可以获取到。
而位置参数就要用到enumerate来帮助我们获取到他的位置，然后通过param.values的位置匹配来确定。
raise就是一个抛出异常的关键字。
1
2
3
4
5

再来查看一个例外情况：

@typed
def add(x, y: int) -> int:
    return x + y

print(add(1, 1))
# 结果
TypeError: parameter x required <class 'inspect._empty'>, but <class 'int'>
1
2
3
4
5
6
7

这里并没有给x类型注解，就导致了结果的报错，但是类型注解加不加应该都不能影响代码的正常运行，所有需要对装饰器进行纠正：

def typed(fn):
    @functools.wraps(fn)
    def wrap(*args, **kwargs):
        # TODO，如何来检查
        params = inspect.signature(fn).parameters

        # 检查关键字参数
        for k, v in kwargs.items():
            # 对类型注解进行判断：
            param = param[k]
            if param.annotation != inspect._empty and not isinstance(v, params[k].annotation):
            #if not isinstance(v, params[k].annotation):
                raise TypeError('parameter {} require {}, but {}'
                                .format(k, params[k].annotation, type(k)))

        # 检查位置参数
        for i, arg in enumerate(args):
            param = list(params.values())[i]
            if param.annotation != inspect._empty and not isinstance(arg, param.annotation):
                raise TypeError('parameter {} required {}, but {}'
                                .format(param.name, param.annotation, type(arg)))

        return fn(*args, **kwargs)
    return wrap
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

加上一个对类型注解的判断之后便能解决该问题了param.annotation != inspect._empty其中inspect._empty就是判断该参数有没有类型注解。

小结

用装饰器做类型检查，做权限校验，或者注册函数，都可以。