一篇文章带你了解python中的typing模块和类型注解

function annotation 写法：

• 使用冒号 : 加类型代表参数类型
  • 默认值参数示例：b: int = 2
• 使用 -> 加类型代表返回值类型

python解释器运行时并不会检查类型，类型不对也不会抛异常，仅仅是注解而已。示例：

def plus(a: int, b: int = 2) -> int:
    return a + b

python 解析器并不会在意类型注解，严格来说这是不对的，python 会把类型信息放在 __annotations__ 属性中：

>>> def foo(a: str):
...     print('hello', a)
...

>>> foo.__annotations__
{'a': str}

>>> class bar:
...     a: str
...     b: int

>>> bar.__annotations__
{'a': str, 'b': int}

typing模块

内置提供的类型：int 、str 、float，typing模块提供的类型：dict 、list 、tuble...

typing使用方括号 dict[str, int] 而不是圆括号 dict(str, int)

dict

dict[str, int]： 表示一个 keys 的类型为 str，values 的类型为 int 的字典，比如 {"a": 1, "b": 2}

from typing import dict
dict[str, dict[str, list[str]]]如下：
{
    '原木镇': {
        '第一小学': ['张伟', '王伟', '王芳'],
        '第二小学': ['李伟', '李娜'],
    },
    '鸽子镇': {
        '高山中学': ['张敏', '李静'],
        '亿百中学': ['王静']
        '蟒蛇小学': ['刘伟', '王秀英']
    }
}

list

list[int] 表示由整型组成的列表，比如[0, 1, 1, 2, 3]

list[list[int]] = [[1, 2], [2, 3]]

tuple

tuple[int, float, str] is a tuple of an int, a float and a string.

person: tuple[str, int, float] = ('mike', 22, 1.75)

set/abstractset

根据官方文档，set 推荐用于注解返回类型，abstractset 用于注解参数

def describe(s: abstractset[int]) -> set[int]:
    return set(s)

sequence

sequence，是 collections.abc.sequence 的泛型，在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型，我们可以使用一个更为泛化的类型，叫做 sequence，其用法类似于 list

def square(elements: sequence[float]) -> list[float]:
    return [x ** 2 for x in elements]

noreturn

noreturn，当一个方法没有返回结果时，为了注解它的返回类型，我们可以将其注解为noreturn

def hello() -> noreturn:
    print('hello')

any

any，可以代表所有类型，所有的无参数类型注解和返回类型注解的都会默认使用 any 类型，以下两个函数等价：

def add(a):
    return a + 1

def add(a: any) -> any:
    return a + 1

typevar

typevar，自定义兼容特定类型的变量，比如有的变量声明为 int、float、none 都是符合要求的，实际就是代表任意的数字或者空内容都可以，其他的类型则不可以，比如列表 list、字典 dict 等等，像这样的情况，我们可以使用 typevar 来表示。

height = 1.75
height = typevar('height', int, float, none)
def get_height() -> height:
    return height

newtype

newtype，声明一些具有特殊含义的类型，像 tuple 的例子一样，我们需要将它表示为 person，即一个人的含义，但但从表面上声明为 tuple 并不直观，所以我们可以使用 newtype 为其声明一个类型，如：

person = newtype('person', tuple[str, int, float])
person = person(('mike', 22, 1.75))

实际上 person 就是一个 tuple 类型，我们可以对其像 tuple 一样正常操作。

callable

callable，可调用类型，通常用来注解一个方法， 在声明的时候需要使用 callable[[arg1type, arg2type, ...], returntype] 这样的类型注解，将参数类型和返回值类型都要注解出来，例如：

def date(year: int, month: int, day: int) -> str:
    return f'{year}-{month}-{day}'

def get_date_fn() -> callable[[int, int, int], str]:
    return date

-> callable[[int, int, int], str]: 中括号内分别标记了返回的方法的参数类型和返回值类型。

union

union，联合类型，union[x, y] 代表要么是 x 类型，要么是 y 类型。

union[union[int, str], float] == union[int, str, float]
union[int] == int
union[int, str, int] == union[int, str]
# 无参数顺序
union[int, str] == union[str, int]

在一些方法参数声明的时候比较有用，比如一个方法，要么传一个字符串表示的方法名，要么直接把方法传过来：

def process(fn: union[str, callable]):
    if isinstance(fn, str):
        # str2fn and process
        pass
    elif isinstance(fn, callable):
        fn()

这样的声明在一些类库方法定义的时候十分常见。

optional

optional，意思是说这个参数可以为空或已经声明的类型，即 optional[x] 等价于 union[x, none]。

optional 并不等价于可选参数，当它作为参数类型注解的时候，不代表这个参数可以不传递，而是说这个参数可以传none，不传也会报错。

当一个方法执行结果，如果执行完毕就不返回错误信息， 如果发生问题就返回错误信息，则可以这么声明：

def judge(result: bool) -> optional[str]:
    if result: return 'error occurred'

generator

generator，想代表一个生成器类型，可以使用 generator，它的声明比较特殊，其后的中括号紧跟着三个参数，分别代表 yieldtype、sendtype、returntype，如：

def echo_round() -> generator[int, float, str]:
    sent = yield 0
    while sent >= 0:
        sent = yield round(sent)
    return 'done'

在这里 yield 关键字后面紧跟的变量的类型就是 yieldtype，yield 返回的结果的类型就是 sendtype，最后生成器 return 的内容就是 returntype。

当然很多情况下，生成器往往只需要 yield 内容就够了，我们是不需要 sendtype 和 returntype 的，可以将其设置为空，如：

def infinite_stream(start: int) -> generator[int, none, none]:
    while true:
        yield start
        start += 1

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注的更多内容!