ToB企服应用市场:ToB评测及商务社交产业平台

标题: Python 类型注解 [打印本页]
作者: 滴水恩情    时间: 2023-2-12 17:36
标题: Python 类型注解
在Python语言发展的过程中，PEP提案发挥了巨大的作用，如PEP 3107 和 PEP 484提案，分别给我们带来了函数注解（Function Annotations）和类型提示（Type Hints）的功能。
PEP 3107：定义了函数注解的语法，允许为函数的参数和返回值添加元数据注解。
PEP 484：按照PEP 3107函数注解的语法，从Python语法层面全面支持类型提示，类型提示可以是内置类型、内置类、抽象基类、types模块中提供的类型和开发人员自定义的类。
另外 PEP 526, PEP 544, PEP 586, PEP 589, PEP 591 这些东西对 PEP 3107 和 PEP 484 进行了补充，比如添加了变量注释，字面量注释这些东西。
需要注意的是，类型提示仅有提示的作用，这里的提示是指用户阅读Python代码的时候的提示，仅在语法层面支持，对代码的运行没有任何影响，Python 解释器在运行代码的时候会忽略类型提示，也就是说，Python的类型提示仅是为了提升代码可读性，一定程度上缓解"动态语言一时爽，代码重构火葬场"的尴尬。
下面将函数注解和类型提示，统称为类型注解。

类型注解优点

1、可以使Python拥有部分静态语言的特性，利用类型注解可以实现一种类似类型声明的效果，提升代码的可读性及后续的可维护性。
2、类型注解可以让IDE（如pycharm）像静态语言那样分析我们的代码，及时给我们相应的提示，如下图对比：
VS3、多多使用类型注解，不仅可以让Python拥有强类型语言的严谨，还能保持Python作为动态类型语言的灵活性。

普通变量类型注解

在声明变量时，变量的后面可以加一个冒号，后面再写上变量的类型，如 int、list 等等，以此实现类型注解。
  1. a: int = 22
  2. b: str = "name"
  3. c: float = 55.5
  4. d: bool = True
  5. e: list = [1, 2, 3]
  6. f: set = {1, 2, 3}
  7. g: dict = {"name": "ming", "age": 22}
  8. h: tuple = (1, 2, 3)
  9. i: bytes = b'world'
  10. j: bytearray = bytearray("world")
复制代码
函数参数及返回值类型

函数参数的类型声明就是冒号+类型即可，和普通变量类型声明没区别。
函数返回值的类型声明是用箭头指向具体的类型，如果是返回值有多个，使用元组包裹即可（因为函数的多个返回值就是以元组形式返回的），需要注意的是，箭头左右两边都要留有空格。
  1. def handler(a: int, b: int) -> int:
  2.     return a + b
  5. def handler2(a: int, b: int, *args: int) -> int:
  6.     return a + b + sum(args)
  9. def handler3(a: int, b: int, *args: int, **kwargs: int) -> (int, str):
  10.     return a + b + sum(args) + sum(kwargs.values()), ""
复制代码
typing模块

typing模块的加入不会影响程序的运行，也不会报正式的错误，pycharm支持检测基于typing注解的错误，不符合规定类型注解时会出现黄色警告，但不会影响程序运行。
容器类型 & 复合类型

列表、字典、元组等包含元素的复合类型，用简单的 list，dict，tuple 不能够明确说明内部元素的具体类型。
此外，Python本身就是动态类型的语言，如果我们强制使用某种类型，一定程度上会丧失Python作为动态语言的优势，因此 typing 模块提供了一种复合类型注解的语法，即一个参数即可以是类型A，也可以是类型B或者类型C
  1. from typing import Dict, List, Set, Tuple, Union
  3. # 字典
  4. d: Dict[str, int] = {"a": 1, "b": 2}
  5. d1: Dict[str, int or str] = {"a": 1, "b": "2"}          # 使用or表示支持多个类型
  7. # 列表
  8. l: List[int] = [1, 2, 3]
  9. l1: List[int or str] = [1, 2, "3"]
  11. # 元组
  12. t: Tuple[str, int] = ("a", 1)                # 代表了构成元组的第一个元素是 str 类型，第二个元素是 int 类型
  13. t1: Tuple[str, ...] = ("a", "b", "c", "d", "e", "f", "g")                # 代表接受多个 str 类型的元素
  14. t2: Tuple[str or int, ...] = ("a", "b", 2)                # 代表接受多个 str 或 int 类型的元素
  16. # 集合
  17. s: Set[int] = {1, 2, 3, 4}
  18. s1: Set[Union[int, str, float]] = {1, "2", 3.333, 4}        # Union 同 or
复制代码
TypedDict

TypedDict声明一个字典类型，该类型期望它的所有实例都有一组固定的keys，其中每个key都与对应类型的值关联。
  1. from typing import TypedDict
  4. class Student(TypedDict):
  5.     name: str
  6.     age: int
  7.     height: float
  10. s1: Student = {
  11.     "name": "xiao ming",
  12.     "age": 22,
  13.     "height": 55.5
  14. }
  16. s2: Student = {
  17.     "name": "xiao hong",
  18.     "age": 21,
  19. }
复制代码
可以看出，pycharm也会警告我们字典实例中缺失的key。
同时，在我们生成字典实例的时候，pycharm也会给我们key的提示。

类型别名

类型别名是通过将类型分配给别名来定义的，类型别名可用于简化复杂类型提示。
  1. from typing import Union
  3. Number = Union[int, float]
  5. def process(v: Number) -> Number:
  6.     return v
  8. x: Number = 2
  9. y: Number = 2.2
  10. process(x)
  11. process(22)                # 类型检查成功，类型别名和原始类型是等价的
复制代码
NewType

使用NewType辅助类来创建不同的类型
  1. from typing import NewType
  3. Number = NewType("Number", int)
  5. def process(v: Number) -> Number:
  6.     return v
  8. x: Number = Number(22)
  9. process(x)
  10. process(22)     # 类型检查异常：Expected type 'Number', got 'int' instead
  11. # 原因就是NewType创建的是原始类型的“子类型”
复制代码
因此，类型别名 和 NewType 具体使用哪个，要视情况而定，不知道使用哪个，可以先使用类型别名。

NoReturn

当一个方法没有返回结果时，为了注解它的返回类型，我们可以将其注解为 NoReturn。
因为Python 的函数运行结束时隐式返回 None ，这和真正的无返回值是有区别的。
  1. from typing import NoReturn
  3. def process() -> NoReturn:
  4.     pass
复制代码
可选类型：Optional

使用 Optional[] 表示可能为 None 的值
  1. from typing import Optional
  3. def handler(x: int) -> Optional[int]:
  4.     if x % 2 == 0:
  5.         return x
复制代码
可调用对象：Callable

若一个变量类型是可调用函数，则可以用 Callable[[Arg1Type, Arg2Type], ReturnType] 实现类型提示
  1. from typing import Optional, Callable
  3. def handler(x: int) -> Optional[int]:
  4.     if x % 2 == 0:
  5.         return x
  7. def handler2(func: Callable[[int], Optional[int]]):
  8.     pass
  10. handler2(handler)
复制代码
字面量：Literal

指示相应的变量或函数参数只接收与提供的字面量(或多个字面量之一)等效的值，可以理解为规定了某个参数或变量的所有枚举值。
  1. from typing import Literal, NoReturn
  3. Mode = Literal["r", "w"]
  6. def process(mode: Mode) -> NoReturn:
  7.     pass
  10. process("s")
复制代码
可以看出，pycharm检查出了我们输入的值并不符合字面量规定的值，进而出现了黄色警告。

Any

是一种特殊的类型，每种类型都视为与Any兼容，同样，Any也与所有类型兼容。可以对Any类型的值执行任何操作或方法调用，并将其分配给任何变量。将Any类型的值分配给更精确的类型(more precise type)时，不会执行类型检查，所有没有返回类型或参数类型的函数都将隐式地默认使用Any。
使用Any，说明值是动态类型。
把所有的类型都注解为 Any 将毫无意义，因此 Any 应当尽量少使用
  1. from typing import Any
  3. def foo() -> Any:
  4.     pass
复制代码
抽象基类
  1. # 在某些情况下，我们可能并不需要严格区分一个变量或参数到底是列表 list 类型还是元组 tuple 类型
  2. # 可以使用一个更为泛化的类型，叫做 Sequence，其用法类似于 List
  3. class typing.Sequence(Reversible[T_co], Collection[T_co])
  6. # collections.abc.Iterator的泛型版本
  7. # 注释函数参数中的迭代类型时，推荐使用的抽象集合类型
  8. class typing.Iterable(Generic[T_co])
  10. def print_iterable(x: Iterable):
  11.     for i in x:
  12.         print(i)
  16. # collections.abc.Mapping的泛型(generic)版本
  17. # 注释函数参数中的Key-Value类型时，推荐使用的抽象集合类型
  18. class typing.Mapping(Sized, Collection[KT], Generic[VT_co])
复制代码
泛型：TypeVar

先抛出问题：
假设有一个函数，要求它既能够处理字符串，又能够处理数字。那么你可能很自然地想到了 Union ，如下：
  1. from typing import Union
  3. AddValue = Union[int, str]
  6. def add(a: AddValue, b: AddValue) -> AddValue:
  7.     return a + b
  10. if __name__ == "__main__":
  11.     print(add(1, 2))        # 类型检查通过，输出 3
  12.     print(add("1", "2"))    # 类型检查通过，输出 12
  13.     print(add("1", 2))      # 类型检查通过，报错 TypeError: can only concatenate str (not "int") to str
复制代码
在类型检查通过的情况下，我们完成并运行了这段代码，可是代码却报错了！
原因就是我们的初衷是数字和数字相加实现求和，字符串和字符串相加实现拼接，没有考虑到字符串与数字混用的问题，从而引发错误。
根据以上问题，我们可以引入泛型来解决这个问题：
  1. from typing import TypeVar
  3. AddT = TypeVar("AddT", int, str)
  6. def add(a: AddT, b: AddT) -> AddT:
  7.     return a + b
  10. if __name__ == "__main__":
  11.     print(add(1, 2))                # 类型检查通过，输出 3
  12.     print(add("1", "2"))        # 类型检查通过，输出 12
  13.     print(add("1", 2))                # 类型检查失败，pycharm告警 Expected type 'str' (matched generic type 'AddT'), got 'int' instead
复制代码
"""
通过告警，我们提前发现了混用类型的问题，避免了程序运行时发生异常的可能。
"""
泛型很巧妙地对类型进行了参数化，同时又保留了函数处理不同类型时的灵活性。

引用

1、Python 标准库 typing 类型注解标注
2、Python类型注解，你需要知道的都在这里了

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4